Element creation specification parameters in this class may also be passed as an Array of * specification objects. This can be used to insert multiple sibling nodes into an existing * container very efficiently. For example, to add more list items to the example above:

Element creation specification parameters may also be strings. If {@link useDom} is false, then the string is used * as innerHTML. If {@link useDom} is true, a string specification results in the creation of a text node.

DomQuery supports most of the CSS3 selectors spec, along with some custom selectors and basic XPath.

All selectors, attribute filters and pseudos below can be combined infinitely in any order. For example "div.foo:nth-child(odd)[@foo=bar].bar:first" would be a perfectly valid selector. Node filters are processed in the order in which they appear, which allows you to optimize your queries for your document structure.

Element Selectors:

Attribute Selectors:

The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.

Pseudo Classes:

CSS Value Selectors:

* Combining Options
* Using the options argument, it is possible to combine different types of listeners:
*
* A normalized, delayed, one-time listener that auto stops the event and passes a custom argument (forumId) *

* Attaching multiple handlers in 1 call
* The method also allows for a single argument to be passed which is a config object containing properties * which specify multiple handlers. *

See {@link CQ.Ext.Element#addListener} for examples of how to use these options.

* Combining Options
* In the following examples, the shorthand form {@link #on} is used rather than the more verbose * addListener. The two are equivalent. Using the options argument, it is possible to combine different * types of listeners:
*
* A normalized, delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the * options object. The options object is available as the third parameter in the handler function.

* Code:


el.on('click', this.onClick, this, {
    single: true,
    delay: 100,
    stopEvent : true,
    forumId: 4
});

* Attaching multiple handlers in 1 call
* The method also allows for a single argument to be passed which is a config object containing properties * which specify multiple handlers.

* Code:


el.on({
    'click' : {
        fn: this.onClick,
        scope: this,
        delay: 100
    },
    'mouseover' : {
        fn: this.onMouseOver,
        scope: this
    },
    'mouseout' : {
        fn: this.onMouseOut,
        scope: this
    }
});

* Or a shorthand syntax:
* Code:


el.on({
    'click' : this.onClick,
    'mouseover' : this.onMouseOver,
    'mouseout' : this.onMouseOut,
    scope: this
});

*/ addListener : function(eventName, fn, scope, options){ CQ.Ext.EventManager.on(this.dom, eventName, fn, scope || this, options); }, /** * Removes an event handler from this element. The shorthand version {@link #un} is equivalent. Example: *


el.removeListener('click', this.handlerFn);
// or
el.un('click', this.handlerFn);

* @param {String} eventName the type of event to remove * @param {Function} fn the method the event invokes * @param {Object} scope (optional) The scope (The this reference) of the handler function. Defaults * to this Element. * @return {CQ.Ext.Element} this */ removeListener : function(eventName, fn, scope){ CQ.Ext.EventManager.removeListener(this.dom, eventName, fn, scope || this); return this; }, /** * Removes all previous added listeners from this element * @return {CQ.Ext.Element} this */ removeAllListeners : function(){ CQ.Ext.EventManager.removeAll(this.dom); return this; }, /** * Create an event handler on this element such that when the event fires and is handled by this element, * it will be relayed to another object (i.e., fired again as if it originated from that object instead). * @param {String} eventName The type of event to relay * @param {Object} object Any object that extends {@link CQ.Ext.util.Observable} that will provide the context * for firing the relayed event */ relayEvent : function(eventName, observable){ this.on(eventName, function(e){ observable.fireEvent(eventName, e); }); }, /** * Set the opacity of the element * @param {Float} opacity The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ setOpacity : function(opacity, animate){ if(!animate || !A){ var s = this.dom.style; if(CQ.Ext.isIE){ s.zoom = 1; s.filter = (s.filter || '').replace(/alpha$[^$]*\)/gi,"") + (opacity == 1 ? "" : " alpha(opacity=" + opacity * 100 + ")"); }else{ s.opacity = opacity; } }else{ this.anim({opacity: {to: opacity}}, this.preanim(arguments, 1), null, .35, 'easeIn'); } return this; }, /** * Gets the left X coordinate * @param {Boolean} local True to get the local css position instead of page coordinate * @return {Number} */ getLeft : function(local){ if(!local){ return this.getX(); }else{ return parseInt(this.getStyle("left"), 10) || 0; } }, /** * Gets the right X coordinate of the element (element X position + element width) * @param {Boolean} local True to get the local css position instead of page coordinate * @return {Number} */ getRight : function(local){ if(!local){ return this.getX() + this.getWidth(); }else{ return (this.getLeft(true) + this.getWidth()) || 0; } }, /** * Gets the top Y coordinate * @param {Boolean} local True to get the local css position instead of page coordinate * @return {Number} */ getTop : function(local) { if(!local){ return this.getY(); }else{ return parseInt(this.getStyle("top"), 10) || 0; } }, /** * Gets the bottom Y coordinate of the element (element Y position + element height) * @param {Boolean} local True to get the local css position instead of page coordinate * @return {Number} */ getBottom : function(local){ if(!local){ return this.getY() + this.getHeight(); }else{ return (this.getTop(true) + this.getHeight()) || 0; } }, /** * Initializes positioning on this element. If a desired position is not passed, it will make the * the element positioned relative IF it is not already positioned. * @param {String} pos (optional) Positioning to use "relative", "absolute" or "fixed" * @param {Number} zIndex (optional) The zIndex to apply * @param {Number} x (optional) Set the page X position * @param {Number} y (optional) Set the page Y position */ position : function(pos, zIndex, x, y){ if(!pos){ if(this.getStyle('position') == 'static'){ this.setStyle('position', 'relative'); } }else{ this.setStyle("position", pos); } if(zIndex){ this.setStyle("z-index", zIndex); } if(x !== undefined && y !== undefined){ this.setXY([x, y]); }else if(x !== undefined){ this.setX(x); }else if(y !== undefined){ this.setY(y); } }, /** * Clear positioning back to the default when the document was loaded * @param {String} value (optional) The value to use for the left,right,top,bottom, defaults to '' (empty string). You could use 'auto'. * @return {CQ.Ext.Element} this */ clearPositioning : function(value){ value = value ||''; this.setStyle({ "left": value, "right": value, "top": value, "bottom": value, "z-index": "", "position" : "static" }); return this; }, /** * Gets an object with all CSS positioning properties. Useful along with setPostioning to get * snapshot before performing an update and then restoring the element. * @return {Object} */ getPositioning : function(){ var l = this.getStyle("left"); var t = this.getStyle("top"); return { "position" : this.getStyle("position"), "left" : l, "right" : l ? "" : this.getStyle("right"), "top" : t, "bottom" : t ? "" : this.getStyle("bottom"), "z-index" : this.getStyle("z-index") }; }, /** * Gets the width of the border(s) for the specified side(s) * @param {String} side Can be t, l, r, b or any combination of those to add multiple values. For example, * passing lr would get the border (l)eft width + the border (r)ight width. * @return {Number} The width of the sides passed added together */ getBorderWidth : function(side){ return this.addStyles(side, El.borders); }, /** * Gets the width of the padding(s) for the specified side(s) * @param {String} side Can be t, l, r, b or any combination of those to add multiple values. For example, * passing lr would get the padding (l)eft + the padding (r)ight. * @return {Number} The padding of the sides passed added together */ getPadding : function(side){ return this.addStyles(side, El.paddings); }, /** * Set positioning with an object returned by getPositioning(). * @param {Object} posCfg * @return {CQ.Ext.Element} this */ setPositioning : function(pc){ this.applyStyles(pc); if(pc.right == "auto"){ this.dom.style.right = ""; } if(pc.bottom == "auto"){ this.dom.style.bottom = ""; } return this; }, // private fixDisplay : function(){ if(this.getStyle("display") == "none"){ this.setStyle("visibility", "hidden"); this.setStyle("display", this.originalDisplay); // first try reverting to default if(this.getStyle("display") == "none"){ // if that fails, default to block this.setStyle("display", "block"); } } }, // private setOverflow : function(v){ if(v=='auto' && CQ.Ext.isMac && CQ.Ext.isGecko2){ // work around stupid FF 2.0/Mac scroll bar bug this.dom.style.overflow = 'hidden'; (function(){this.dom.style.overflow = 'auto';}).defer(1, this); }else{ this.dom.style.overflow = v; } }, /** * Quick set left and top adding default units * @param {String} left The left CSS property value * @param {String} top The top CSS property value * @return {CQ.Ext.Element} this */ setLeftTop : function(left, top){ this.dom.style.left = this.addUnits(left); this.dom.style.top = this.addUnits(top); return this; }, /** * Move this element relative to its current position. * @param {String} direction Possible values are: "l" (or "left"), "r" (or "right"), "t" (or "top", or "up"), "b" (or "bottom", or "down"). * @param {Number} distance How far to move the element in pixels * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ move : function(direction, distance, animate){ var xy = this.getXY(); direction = direction.toLowerCase(); switch(direction){ case "l": case "left": this.moveTo(xy[0]-distance, xy[1], this.preanim(arguments, 2)); break; case "r": case "right": this.moveTo(xy[0]+distance, xy[1], this.preanim(arguments, 2)); break; case "t": case "top": case "up": this.moveTo(xy[0], xy[1]-distance, this.preanim(arguments, 2)); break; case "b": case "bottom": case "down": this.moveTo(xy[0], xy[1]+distance, this.preanim(arguments, 2)); break; } return this; }, /** * Store the current overflow setting and clip overflow on the element - use {@link #unclip} to remove * @return {CQ.Ext.Element} this */ clip : function(){ if(!this.isClipped){ this.isClipped = true; this.originalClip = { "o": this.getStyle("overflow"), "x": this.getStyle("overflow-x"), "y": this.getStyle("overflow-y") }; this.setStyle("overflow", "hidden"); this.setStyle("overflow-x", "hidden"); this.setStyle("overflow-y", "hidden"); } return this; }, /** * Return clipping (overflow) to original clipping before clip() was called * @return {CQ.Ext.Element} this */ unclip : function(){ if(this.isClipped){ this.isClipped = false; var o = this.originalClip; if(o.o){this.setStyle("overflow", o.o);} if(o.x){this.setStyle("overflow-x", o.x);} if(o.y){this.setStyle("overflow-y", o.y);} } return this; }, /** * Gets the x,y coordinates specified by the anchor position on the element. * @param {String} anchor (optional) The specified anchor position (defaults to "c"). See {@link #alignTo} * for details on supported anchor positions. * @param {Boolean} local (optional) True to get the local (element top/left-relative) anchor position instead * of page coordinates * @param {Object} size (optional) An object containing the size to use for calculating anchor position * {width: (target width), height: (target height)} (defaults to the element's current size) * @return {Array} [x, y] An array containing the element's x and y coordinates */ getAnchorXY : function(anchor, local, s){ //Passing a different size is useful for pre-calculating anchors, //especially for anchored animations that change the el size. var w, h, vp = false; if(!s){ var d = this.dom; if(d == document.body || d == document){ vp = true; w = D.getViewWidth(); h = D.getViewHeight(); }else{ w = this.getWidth(); h = this.getHeight(); } }else{ w = s.width; h = s.height; } var x = 0, y = 0, r = Math.round; switch((anchor || "tl").toLowerCase()){ case "c": x = r(w*.5); y = r(h*.5); break; case "t": x = r(w*.5); y = 0; break; case "l": x = 0; y = r(h*.5); break; case "r": x = w; y = r(h*.5); break; case "b": x = r(w*.5); y = h; break; case "tl": x = 0; y = 0; break; case "bl": x = 0; y = h; break; case "br": x = w; y = h; break; case "tr": x = w; y = 0; break; } if(local === true){ return [x, y]; } if(vp){ var sc = this.getScroll(); return [x + sc.left, y + sc.top]; } //Add the element's offset xy var o = this.getXY(); return [x+o[0], y+o[1]]; }, /** * Gets the x,y coordinates to align this element with another element. See {@link #alignTo} for more info on the * supported position values. * @param {Mixed} element The element to align to. * @param {String} position The position to align to. * @param {Array} offsets (optional) Offset the positioning by [x, y] * @return {Array} [x, y] */ getAlignToXY : function(el, p, o){ el = CQ.Ext.get(el); if(!el || !el.dom){ throw "Element.alignToXY with an element that doesn't exist"; } var d = this.dom; var c = false; //constrain to viewport var p1 = "", p2 = ""; o = o || [0,0]; if(!p){ p = "tl-bl"; }else if(p == "?"){ p = "tl-bl?"; }else if(p.indexOf("-") == -1){ p = "tl-" + p; } p = p.toLowerCase(); var m = p.match(/^([a-z]+)-([a-z]+)(\?)?$/); if(!m){ throw "Element.alignTo with an invalid alignment " + p; } p1 = m[1]; p2 = m[2]; c = !!m[3]; //Subtract the aligned el's internal xy from the target's offset xy //plus custom offset to get the aligned el's new offset xy var a1 = this.getAnchorXY(p1, true); var a2 = el.getAnchorXY(p2, false); var x = a2[0] - a1[0] + o[0]; var y = a2[1] - a1[1] + o[1]; if(c){ //constrain the aligned el to viewport if necessary var w = this.getWidth(), h = this.getHeight(), r = el.getRegion(); // 5px of margin for ie var dw = D.getViewWidth()-5, dh = D.getViewHeight()-5; //If we are at a viewport boundary and the aligned el is anchored on a target border that is //perpendicular to the vp border, allow the aligned el to slide on that border, //otherwise swap the aligned el to the opposite border of the target. var p1y = p1.charAt(0), p1x = p1.charAt(p1.length-1); var p2y = p2.charAt(0), p2x = p2.charAt(p2.length-1); var swapY = ((p1y=="t" && p2y=="b") || (p1y=="b" && p2y=="t")); var swapX = ((p1x=="r" && p2x=="l") || (p1x=="l" && p2x=="r")); var doc = document; var scrollX = (doc.documentElement.scrollLeft || doc.body.scrollLeft || 0)+5; var scrollY = (doc.documentElement.scrollTop || doc.body.scrollTop || 0)+5; if((x+w) > dw + scrollX){ x = swapX ? r.left-w : dw+scrollX-w; } if(x < scrollX){ x = swapX ? r.right : scrollX; } if((y+h) > dh + scrollY){ y = swapY ? r.top-h : dh+scrollY-h; } if (y < scrollY){ y = swapY ? r.bottom : scrollY; } } return [x,y]; }, // private getConstrainToXY : function(){ var os = {top:0, left:0, bottom:0, right: 0}; return function(el, local, offsets, proposedXY){ el = CQ.Ext.get(el); offsets = offsets ? CQ.Ext.applyIf(offsets, os) : os; var vw, vh, vx = 0, vy = 0; if(el.dom == document.body || el.dom == document){ vw = CQ.Ext.lib.Dom.getViewWidth(); vh = CQ.Ext.lib.Dom.getViewHeight(); }else{ vw = el.dom.clientWidth; vh = el.dom.clientHeight; if(!local){ var vxy = el.getXY(); vx = vxy[0]; vy = vxy[1]; } } var s = el.getScroll(); vx += offsets.left + s.left; vy += offsets.top + s.top; vw -= offsets.right; vh -= offsets.bottom; var vr = vx+vw; var vb = vy+vh; var xy = proposedXY || (!local ? this.getXY() : [this.getLeft(true), this.getTop(true)]); var x = xy[0], y = xy[1]; var w = this.dom.offsetWidth, h = this.dom.offsetHeight; // only move it if it needs it var moved = false; // first validate right/bottom if((x + w) > vr){ x = vr - w; moved = true; } if((y + h) > vb){ y = vb - h; moved = true; } // then make sure top/left isn't negative if(x < vx){ x = vx; moved = true; } if(y < vy){ y = vy; moved = true; } return moved ? [x, y] : false; }; }(), // private adjustForConstraints : function(xy, parent, offsets){ return this.getConstrainToXY(parent || document, false, offsets, xy) || xy; }, /** * Aligns this element with another element relative to the specified anchor points. If the other element is the * document it aligns it to the viewport. * The position parameter is optional, and can be specified in any one of the following formats: *

Blank: Defaults to aligning the element's top-left corner to the target's bottom-left corner ("tl-bl").
One anchor (deprecated): The passed anchor position is used as the target element's anchor point. * The element being aligned will position its top-left corner (tl) to that point. This method has been * deprecated in favor of the newer two anchor syntax below.
Two anchors: If two values from the table below are passed separated by a dash, the first value is used as the * element's anchor point, and the second value is used as the target's anchor point.

* In addition to the anchor points, the position parameter also supports the "?" character. If "?" is passed at the end of * the position string, the element will attempt to align as specified, but the position will be adjusted to constrain to * the viewport if necessary. Note that the element being aligned might be swapped to align to a different position than * that specified in order to enforce the viewport constraints. * Following are all of the supported anchor positions:

Value  Description
-----  -----------------------------
tl     The top left corner (default)
t      The center of the top edge
tr     The top right corner
l      The center of the left edge
c      In the center of the element
r      The center of the right edge
bl     The bottom left corner
b      The center of the bottom edge
br     The bottom right corner

Example Usage:


// align el to other-el using the default positioning ("tl-bl", non-constrained)
el.alignTo("other-el");

// align the top left corner of el with the top right corner of other-el (constrained to viewport)
el.alignTo("other-el", "tr?");

// align the bottom right corner of el with the center left edge of other-el
el.alignTo("other-el", "br-l?");

// align the center of el with the bottom left corner of other-el and
// adjust the x position by -6 pixels (and the y position by 0)
el.alignTo("other-el", "c-bl", [-6, 0]);

* @param {Mixed} element The element to align to. * @param {String} position The position to align to. * @param {Array} offsets (optional) Offset the positioning by [x, y] * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ alignTo : function(element, position, offsets, animate){ var xy = this.getAlignToXY(element, position, offsets); this.setXY(xy, this.preanim(arguments, 3)); return this; }, /** * Anchors an element to another element and realigns it when the window is resized. * @param {Mixed} element The element to align to. * @param {String} position The position to align to. * @param {Array} offsets (optional) Offset the positioning by [x, y] * @param {Boolean/Object} animate (optional) True for the default animation or a standard Element animation config object * @param {Boolean/Number} monitorScroll (optional) True to monitor body scroll and reposition. If this parameter * is a number, it is used as the buffer delay (defaults to 50ms). * @param {Function} callback The function to call after the animation finishes * @return {CQ.Ext.Element} this */ anchorTo : function(el, alignment, offsets, animate, monitorScroll, callback){ var action = function(){ this.alignTo(el, alignment, offsets, animate); CQ.Ext.callback(callback, this); }; CQ.Ext.EventManager.onWindowResize(action, this); var tm = typeof monitorScroll; if(tm != 'undefined'){ CQ.Ext.EventManager.on(window, 'scroll', action, this, {buffer: tm == 'number' ? monitorScroll : 50}); } action.call(this); // align immediately return this; }, /** * Clears any opacity settings from this element. Required in some cases for IE. * @return {CQ.Ext.Element} this */ clearOpacity : function(){ if (window.ActiveXObject) { if(typeof this.dom.style.filter == 'string' && (/alpha/i).test(this.dom.style.filter)){ this.dom.style.filter = ""; } } else { this.dom.style.opacity = ""; this.dom.style["-moz-opacity"] = ""; this.dom.style["-khtml-opacity"] = ""; } return this; }, /** * Hide this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}. * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ hide : function(animate){ this.setVisible(false, this.preanim(arguments, 0)); return this; }, /** * Show this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}. * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ show : function(animate){ this.setVisible(true, this.preanim(arguments, 0)); return this; }, /** * @private Test if size has a unit, otherwise appends the default */ addUnits : function(size){ return CQ.Ext.Element.addUnits(size, this.defaultUnit); }, /** * Update the innerHTML of this element, optionally searching for and processing scripts * @param {String} html The new HTML * @param {Boolean} loadScripts (optional) True to look for and process scripts (defaults to false) * @param {Function} callback (optional) For async script loading you can be notified when the update completes * @return {CQ.Ext.Element} this */ update : function(html, loadScripts, callback){ if(typeof html == "undefined"){ html = ""; } if(loadScripts !== true){ this.dom.innerHTML = html; if(typeof callback == "function"){ callback(); } return this; } var id = CQ.Ext.id(); var dom = this.dom; html += ''; E.onAvailable(id, function(){ var hd = document.getElementsByTagName("head")[0]; var re = /(?:]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig; var srcRe = /\ssrc=([\'\"])(.*?)\1/i; var typeRe = /\stype=([\'\"])(.*?)\1/i; var match; while(match = re.exec(html)){ var attrs = match[1]; var srcMatch = attrs ? attrs.match(srcRe) : false; if(srcMatch && srcMatch[2]){ var s = document.createElement("script"); s.src = srcMatch[2]; var typeMatch = attrs.match(typeRe); if(typeMatch && typeMatch[2]){ s.type = typeMatch[2]; } hd.appendChild(s); }else if(match[2] && match[2].length > 0){ if(window.execScript) { window.execScript(match[2]); } else { window.eval(match[2]); } } } var el = document.getElementById(id); if(el){CQ.Ext.removeNode(el);} if(typeof callback == "function"){ callback(); } }); dom.innerHTML = html.replace(/(?:)((\n|\r|.)*?)(?:<\/script>)/ig, ""); return this; }, /** * Direct access to the Updater {@link CQ.Ext.Updater#update} method. The method takes the same object * parameter as {@link CQ.Ext.Updater#update} * @return {CQ.Ext.Element} this */ load : function(){ var um = this.getUpdater(); um.update.apply(um, arguments); return this; }, /** * Gets this element's Updater * @return {CQ.Ext.Updater} The Updater */ getUpdater : function(){ if(!this.updateManager){ this.updateManager = new CQ.Ext.Updater(this); } return this.updateManager; }, /** * Disables text selection for this element (normalized across browsers) * @return {CQ.Ext.Element} this */ unselectable : function(){ this.dom.unselectable = "on"; this.swallowEvent("selectstart", true); this.applyStyles("-moz-user-select:none;-khtml-user-select:none;"); this.addClass("x-unselectable"); return this; }, /** * Calculates the x, y to center this element on the screen * @return {Array} The x, y values [x, y] */ getCenterXY : function(){ return this.getAlignToXY(document, 'c-c'); }, /** * Centers the Element in either the viewport, or another Element. * @param {Mixed} centerIn (optional) The element in which to center the element. */ center : function(centerIn){ this.alignTo(centerIn || document, 'c-c'); return this; }, /** * Tests various css rules/browsers to determine if this element uses a border box * @return {Boolean} */ isBorderBox : function(){ return noBoxAdjust[this.dom.tagName.toLowerCase()] || CQ.Ext.isBorderBox; }, /** * Return a box {x, y, width, height} that can be used to set another elements * size/location to match this element. * @param {Boolean} contentBox (optional) If true a box for the content of the element is returned. * @param {Boolean} local (optional) If true the element's left and top are returned instead of page x/y. * @return {Object} box An object in the format {x, y, width, height} */ getBox : function(contentBox, local){ var xy; if(!local){ xy = this.getXY(); }else{ var left = parseInt(this.getStyle("left"), 10) || 0; var top = parseInt(this.getStyle("top"), 10) || 0; xy = [left, top]; } var el = this.dom, w = el.offsetWidth, h = el.offsetHeight, bx; if(!contentBox){ bx = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: w, height: h}; }else{ var l = this.getBorderWidth("l")+this.getPadding("l"); var r = this.getBorderWidth("r")+this.getPadding("r"); var t = this.getBorderWidth("t")+this.getPadding("t"); var b = this.getBorderWidth("b")+this.getPadding("b"); bx = {x: xy[0]+l, y: xy[1]+t, 0: xy[0]+l, 1: xy[1]+t, width: w-(l+r), height: h-(t+b)}; } bx.right = bx.x + bx.width; bx.bottom = bx.y + bx.height; return bx; }, /** * Returns the sum width of the padding and borders for the passed "sides". See getBorderWidth() for more information about the sides. * @param {String} sides * @return {Number} */ getFrameWidth : function(sides, onlyContentBox){ return onlyContentBox && CQ.Ext.isBorderBox ? 0 : (this.getPadding(sides) + this.getBorderWidth(sides)); }, /** * Sets the element's box. Use getBox() on another element to get a box obj. If animate is true then width, height, x and y will be animated concurrently. * @param {Object} box The box to fill {x, y, width, height} * @param {Boolean} adjust (optional) Whether to adjust for box-model issues automatically * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {CQ.Ext.Element} this */ setBox : function(box, adjust, animate){ var w = box.width, h = box.height; if((adjust && !this.autoBoxAdjust) && !this.isBorderBox()){ w -= (this.getBorderWidth("lr") + this.getPadding("lr")); h -= (this.getBorderWidth("tb") + this.getPadding("tb")); } this.setBounds(box.x, box.y, w, h, this.preanim(arguments, 2)); return this; }, /** * Forces the browser to repaint this element * @return {CQ.Ext.Element} this */ repaint : function(){ var dom = this.dom; this.addClass("x-repaint"); setTimeout(function(){ CQ.Ext.get(dom).removeClass("x-repaint"); }, 1); return this; }, /** * Returns an object with properties top, left, right and bottom representing the margins of this element unless sides is passed, * then it returns the calculated width of the sides (see getPadding) * @param {String} sides (optional) Any combination of l, r, t, b to get the sum of those sides * @return {Object/Number} */ getMargins : function(side){ if(!side){ return { top: parseInt(this.getStyle("margin-top"), 10) || 0, left: parseInt(this.getStyle("margin-left"), 10) || 0, bottom: parseInt(this.getStyle("margin-bottom"), 10) || 0, right: parseInt(this.getStyle("margin-right"), 10) || 0 }; }else{ return this.addStyles(side, El.margins); } }, // private addStyles : function(sides, styles){ var val = 0, v, w; for(var i = 0, len = sides.length; i < len; i++){ v = this.getStyle(styles[sides.charAt(i)]); if(v){ w = parseInt(v, 10); if(w){ val += (w >= 0 ? w : -1 * w); } } } return val; }, /** * Creates a proxy element of this element * @param {String/Object} config The class name of the proxy element or a DomHelper config object * @param {String/HTMLElement} renderTo (optional) The element or element id to render the proxy to (defaults to document.body) * @param {Boolean} matchBox (optional) True to align and size the proxy to this element now (defaults to false) * @return {CQ.Ext.Element} The new proxy element */ createProxy : function(config, renderTo, matchBox){ config = typeof config == "object" ? config : {tag : "div", cls: config}; var proxy; if(renderTo){ proxy = CQ.Ext.DomHelper.append(renderTo, config, true); }else { proxy = CQ.Ext.DomHelper.insertBefore(this.dom, config, true); } if(matchBox){ proxy.setBox(this.getBox()); } return proxy; }, /** * Puts a mask over this element to disable user interaction. Requires core.css. * This method can only be applied to elements which accept child nodes. * @param {String} msg (optional) A message to display in the mask * @param {String} msgCls (optional) A css class to apply to the msg element * @return {Element} The mask element */ mask : function(msg, msgCls){ if(this.getStyle("position") == "static"){ this.setStyle("position", "relative"); } if(this._maskMsg){ this._maskMsg.remove(); } if(this._mask){ this._mask.remove(); } this._mask = CQ.Ext.DomHelper.append(this.dom, {cls:"ext-el-mask"}, true); this.addClass("x-masked"); this._mask.setDisplayed(true); if(typeof msg == 'string'){ this._maskMsg = CQ.Ext.DomHelper.append(this.dom, {cls:"ext-el-mask-msg", cn:{tag:'div'}}, true); var mm = this._maskMsg; mm.dom.className = msgCls ? "ext-el-mask-msg " + msgCls : "ext-el-mask-msg"; mm.dom.firstChild.innerHTML = msg; mm.setDisplayed(true); mm.center(this); } if(CQ.Ext.isIE && !(CQ.Ext.isIE7 && CQ.Ext.isStrict) && this.getStyle('height') == 'auto'){ // ie will not expand full height automatically this._mask.setSize(this.dom.clientWidth, this.getHeight()); } return this._mask; }, /** * Removes a previously applied mask. */ unmask : function(){ if(this._mask){ if(this._maskMsg){ this._maskMsg.remove(); delete this._maskMsg; } this._mask.remove(); delete this._mask; } this.removeClass("x-masked"); }, /** * Returns true if this element is masked * @return {Boolean} */ isMasked : function(){ return this._mask && this._mask.isVisible(); }, /** * Creates an iframe shim for this element to keep selects and other windowed objects from * showing through. * @return {CQ.Ext.Element} The new shim element */ createShim : function(){ var el = document.createElement('iframe'); el.frameBorder = '0'; el.className = 'ext-shim'; if(CQ.Ext.isIE && CQ.Ext.isSecure){ el.src = CQ.Ext.SSL_SECURE_URL; } var shim = CQ.Ext.get(this.dom.parentNode.insertBefore(el, this.dom)); shim.autoBoxAdjust = false; return shim; }, /** * Removes this element from the DOM and deletes it from the cache */ remove : function(){ CQ.Ext.removeNode(this.dom); delete El.cache[this.dom.id]; }, /** * Sets up event handlers to call the passed functions when the mouse is over this element. Automatically * filters child element mouse events. * @param {Function} overFn * @param {Function} outFn * @param {Object} scope (optional) * @return {CQ.Ext.Element} this */ hover : function(overFn, outFn, scope){ var preOverFn = function(e){ if(!e.within(this, true)){ overFn.apply(scope || this, arguments); } }; var preOutFn = function(e){ if(!e.within(this, true)){ outFn.apply(scope || this, arguments); } }; this.on("mouseover", preOverFn, this.dom); this.on("mouseout", preOutFn, this.dom); return this; }, /** * Sets up event handlers to add and remove a css class when the mouse is over this element * @param {String} className * @return {CQ.Ext.Element} this */ addClassOnOver : function(className){ this.hover( function(){ CQ.Ext.fly(this, '_internal').addClass(className); }, function(){ CQ.Ext.fly(this, '_internal').removeClass(className); } ); return this; }, /** * Sets up event handlers to add and remove a css class when this element has the focus * @param {String} className * @return {CQ.Ext.Element} this */ addClassOnFocus : function(className){ this.on("focus", function(){ CQ.Ext.fly(this, '_internal').addClass(className); }, this.dom); this.on("blur", function(){ CQ.Ext.fly(this, '_internal').removeClass(className); }, this.dom); return this; }, /** * Sets up event handlers to add and remove a css class when the mouse is down and then up on this element (a click effect) * @param {String} className * @return {CQ.Ext.Element} this */ addClassOnClick : function(className){ var dom = this.dom; this.on("mousedown", function(){ CQ.Ext.fly(dom, '_internal').addClass(className); var d = CQ.Ext.getDoc(); var fn = function(){ CQ.Ext.fly(dom, '_internal').removeClass(className); d.removeListener("mouseup", fn); }; d.on("mouseup", fn); }); return this; }, /** * Stops the specified event from bubbling and optionally prevents the default action * @param {String} eventName * @param {Boolean} preventDefault (optional) true to prevent the default action too * @return {CQ.Ext.Element} this */ swallowEvent : function(eventName, preventDefault){ var fn = function(e){ e.stopPropagation(); if(preventDefault){ e.preventDefault(); } }; if(CQ.Ext.isArray(eventName)){ for(var i = 0, len = eventName.length; i < len; i++){ this.on(eventName[i], fn); } return this; } this.on(eventName, fn); return this; }, /** * Gets the parent node for this element, optionally chaining up trying to match a selector * @param {String} selector (optional) Find a parent node that matches the passed simple selector * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an CQ.Ext.Element * @return {CQ.Ext.Element/HTMLElement} The parent node or null */ parent : function(selector, returnDom){ return this.matchNode('parentNode', 'parentNode', selector, returnDom); }, /** * Gets the next sibling, skipping text nodes * @param {String} selector (optional) Find the next sibling that matches the passed simple selector * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an CQ.Ext.Element * @return {CQ.Ext.Element/HTMLElement} The next sibling or null */ next : function(selector, returnDom){ return this.matchNode('nextSibling', 'nextSibling', selector, returnDom); }, /** * Gets the previous sibling, skipping text nodes * @param {String} selector (optional) Find the previous sibling that matches the passed simple selector * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an CQ.Ext.Element * @return {CQ.Ext.Element/HTMLElement} The previous sibling or null */ prev : function(selector, returnDom){ return this.matchNode('previousSibling', 'previousSibling', selector, returnDom); }, /** * Gets the first child, skipping text nodes * @param {String} selector (optional) Find the next sibling that matches the passed simple selector * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an CQ.Ext.Element * @return {CQ.Ext.Element/HTMLElement} The first child or null */ first : function(selector, returnDom){ return this.matchNode('nextSibling', 'firstChild', selector, returnDom); }, /** * Gets the last child, skipping text nodes * @param {String} selector (optional) Find the previous sibling that matches the passed simple selector * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an CQ.Ext.Element * @return {CQ.Ext.Element/HTMLElement} The last child or null */ last : function(selector, returnDom){ return this.matchNode('previousSibling', 'lastChild', selector, returnDom); }, matchNode : function(dir, start, selector, returnDom){ var n = this.dom[start]; while(n){ if(n.nodeType == 1 && (!selector || CQ.Ext.DomQuery.is(n, selector))){ return !returnDom ? CQ.Ext.get(n) : n; } n = n[dir]; } return null; }, /** * Appends the passed element(s) to this element * @param {String/HTMLElement/Array/Element/CompositeElement} el * @return {CQ.Ext.Element} this */ appendChild: function(el){ el = CQ.Ext.get(el); el.appendTo(this); return this; }, /** * Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element. * @param {Object} config DomHelper element config object. If no tag is specified (e.g., {tag:'input'}) then a div will be * automatically generated with the specified attributes. * @param {HTMLElement} insertBefore (optional) a child element of this element * @param {Boolean} returnDom (optional) true to return the dom node instead of creating an Element * @return {CQ.Ext.Element} The new child element */ createChild: function(config, insertBefore, returnDom){ config = config || {tag:'div'}; if(insertBefore){ return CQ.Ext.DomHelper.insertBefore(insertBefore, config, returnDom !== true); } return CQ.Ext.DomHelper[!this.dom.firstChild ? 'overwrite' : 'append'](this.dom, config, returnDom !== true); }, /** * Appends this element to the passed element * @param {Mixed} el The new parent element * @return {CQ.Ext.Element} this */ appendTo: function(el){ // CQ:START // handle special case CQ root if (CQ.Util.isRoot(el)) { el = CQ.Util.getRoot(); } // CQ:END el = CQ.Ext.getDom(el); el.appendChild(this.dom); return this; }, /** * Inserts this element before the passed element in the DOM * @param {Mixed} el The element before which this element will be inserted * @return {CQ.Ext.Element} this */ insertBefore: function(el){ el = CQ.Ext.getDom(el); el.parentNode.insertBefore(this.dom, el); return this; }, /** * Inserts this element after the passed element in the DOM * @param {Mixed} el The element to insert after * @return {CQ.Ext.Element} this */ insertAfter: function(el){ el = CQ.Ext.getDom(el); el.parentNode.insertBefore(this.dom, el.nextSibling); return this; }, /** * Inserts (or creates) an element (or DomHelper config) as the first child of this element * @param {Mixed/Object} el The id or element to insert or a DomHelper config to create and insert * @return {CQ.Ext.Element} The new child */ insertFirst: function(el, returnDom){ el = el || {}; if(typeof el == 'object' && !el.nodeType && !el.dom){ // dh config return this.createChild(el, this.dom.firstChild, returnDom); }else{ el = CQ.Ext.getDom(el); this.dom.insertBefore(el, this.dom.firstChild); return !returnDom ? CQ.Ext.get(el) : el; } }, /** * Inserts (or creates) the passed element (or DomHelper config) as a sibling of this element * @param {Mixed/Object/Array} el The id, element to insert or a DomHelper config to create and insert *or* an array of any of those. * @param {String} where (optional) 'before' or 'after' defaults to before * @param {Boolean} returnDom (optional) True to return the raw DOM element instead of CQ.Ext.Element * @return {CQ.Ext.Element} the inserted Element */ insertSibling: function(el, where, returnDom){ var rt; if(CQ.Ext.isArray(el)){ for(var i = 0, len = el.length; i < len; i++){ rt = this.insertSibling(el[i], where, returnDom); } return rt; } where = where ? where.toLowerCase() : 'before'; el = el || {}; var refNode = where == 'before' ? this.dom : this.dom.nextSibling; if(typeof el == 'object' && !el.nodeType && !el.dom){ // dh config if(where == 'after' && !this.dom.nextSibling){ rt = CQ.Ext.DomHelper.append(this.dom.parentNode, el, !returnDom); }else{ rt = CQ.Ext.DomHelper[where == 'after' ? 'insertAfter' : 'insertBefore'](this.dom, el, !returnDom); } }else{ rt = this.dom.parentNode.insertBefore(CQ.Ext.getDom(el), refNode); if(!returnDom){ rt = CQ.Ext.get(rt); } } return rt; }, /** * Creates and wraps this element with another element * @param {Object} config (optional) DomHelper element config object for the wrapper element or null for an empty div * @param {Boolean} returnDom (optional) True to return the raw DOM element instead of CQ.Ext.Element * @return {HTMLElement/Element} The newly created wrapper element */ wrap: function(config, returnDom){ if(!config){ config = {tag: "div"}; } var newEl = CQ.Ext.DomHelper.insertBefore(this.dom, config, !returnDom); newEl.dom ? newEl.dom.appendChild(this.dom) : newEl.appendChild(this.dom); return newEl; }, /** * Replaces the passed element with this element * @param {Mixed} el The element to replace * @return {CQ.Ext.Element} this */ replace: function(el){ el = CQ.Ext.get(el); this.insertBefore(el); el.remove(); return this; }, /** * Replaces this element with the passed element * @param {Mixed/Object} el The new element or a DomHelper config of an element to create * @return {CQ.Ext.Element} this */ replaceWith: function(el){ if(typeof el == 'object' && !el.nodeType && !el.dom){ // dh config el = this.insertSibling(el, 'before'); }else{ el = CQ.Ext.getDom(el); this.dom.parentNode.insertBefore(el, this.dom); } El.uncache(this.id); this.dom.parentNode.removeChild(this.dom); this.dom = el; this.id = CQ.Ext.id(el); El.cache[this.id] = this; return this; }, /** * Inserts an html fragment into this element * @param {String} where Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd. * @param {String} html The HTML fragment * @param {Boolean} returnEl (optional) True to return an CQ.Ext.Element (defaults to false) * @return {HTMLElement/CQ.Ext.Element} The inserted node (or nearest related if more than 1 inserted) */ insertHtml : function(where, html, returnEl){ var el = CQ.Ext.DomHelper.insertHtml(where, this.dom, html); return returnEl ? CQ.Ext.get(el) : el; }, /** * Sets the passed attributes as attributes of this element (a style attribute can be a string, object or function) * @param {Object} o The object with the attributes * @param {Boolean} useSet (optional) false to override the default setAttribute to use expandos. * @return {CQ.Ext.Element} this */ set : function(o, useSet){ var el = this.dom; useSet = typeof useSet == 'undefined' ? (el.setAttribute ? true : false) : useSet; for(var attr in o){ if(attr == "style" || typeof o[attr] == "function") continue; if(attr=="cls"){ el.className = o["cls"]; }else if(o.hasOwnProperty(attr)){ if(useSet) el.setAttribute(attr, o[attr]); else el[attr] = o[attr]; } } if(o.style){ CQ.Ext.DomHelper.applyStyles(el, o.style); } return this; }, /** * Convenience method for constructing a KeyMap * @param {Number/Array/Object/String} key Either a string with the keys to listen for, the numeric key code, array of key codes or an object with the following options: * {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)} * @param {Function} fn The function to call * @param {Object} scope (optional) The scope of the function * @return {CQ.Ext.KeyMap} The KeyMap created */ addKeyListener : function(key, fn, scope){ var config; if(typeof key != "object" || CQ.Ext.isArray(key)){ config = { key: key, fn: fn, scope: scope }; }else{ config = { key : key.key, shift : key.shift, ctrl : key.ctrl, alt : key.alt, fn: fn, scope: scope }; } return new CQ.Ext.KeyMap(this, config); }, /** * Creates a KeyMap for this element * @param {Object} config The KeyMap config. See {@link CQ.Ext.KeyMap} for more details * @return {CQ.Ext.KeyMap} The KeyMap created */ addKeyMap : function(config){ return new CQ.Ext.KeyMap(this, config); }, /** * Returns true if this element is scrollable. * @return {Boolean} */ isScrollable : function(){ var dom = this.dom; return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth; }, /** * Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll(). * @param {String} side Either "left" for scrollLeft values or "top" for scrollTop values. * @param {Number} value The new scroll value * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {Element} this */ scrollTo : function(side, value, animate){ var prop = side.toLowerCase() == "left" ? "scrollLeft" : "scrollTop"; if(!animate || !A){ this.dom[prop] = value; }else{ var to = prop == "scrollLeft" ? [value, this.dom.scrollTop] : [this.dom.scrollLeft, value]; this.anim({scroll: {"to": to}}, this.preanim(arguments, 2), 'scroll'); } return this; }, /** * Scrolls this element the specified direction. Does bounds checking to make sure the scroll is * within this element's scrollable range. * @param {String} direction Possible values are: "l" (or "left"), "r" (or "right"), "t" (or "top", or "up"), "b" (or "bottom", or "down"). * @param {Number} distance How far to scroll the element in pixels * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object * @return {Boolean} Returns true if a scroll was triggered or false if the element * was scrolled as far as it could go. */ scroll : function(direction, distance, animate){ if(!this.isScrollable()){ return; } var el = this.dom; var l = el.scrollLeft, t = el.scrollTop; var w = el.scrollWidth, h = el.scrollHeight; var cw = el.clientWidth, ch = el.clientHeight; direction = direction.toLowerCase(); var scrolled = false; var a = this.preanim(arguments, 2); switch(direction){ case "l": case "left": if(w - l > cw){ var v = Math.min(l + distance, w-cw); this.scrollTo("left", v, a); scrolled = true; } break; case "r": case "right": if(l > 0){ var v = Math.max(l - distance, 0); this.scrollTo("left", v, a); scrolled = true; } break; case "t": case "top": case "up": if(t > 0){ var v = Math.max(t - distance, 0); this.scrollTo("top", v, a); scrolled = true; } break; case "b": case "bottom": case "down": if(h - t > ch){ var v = Math.min(t + distance, h-ch); this.scrollTo("top", v, a); scrolled = true; } break; } return scrolled; }, /** * Translates the passed page coordinates into left/top css values for this element * @param {Number/Array} x The page x or an array containing [x, y] * @param {Number} y (optional) The page y, required if x is not an array * @return {Object} An object with left and top properties. e.g. {left: (value), top: (value)} */ translatePoints : function(x, y){ if(typeof x == 'object' || CQ.Ext.isArray(x)){ y = x[1]; x = x[0]; } var p = this.getStyle('position'); var o = this.getXY(); var l = parseInt(this.getStyle('left'), 10); var t = parseInt(this.getStyle('top'), 10); if(isNaN(l)){ l = (p == "relative") ? 0 : this.dom.offsetLeft; } if(isNaN(t)){ t = (p == "relative") ? 0 : this.dom.offsetTop; } return {left: (x - o[0] + l), top: (y - o[1] + t)}; }, /** * Returns the current scroll position of the element. * @return {Object} An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)} */ getScroll : function(){ var d = this.dom, doc = document; if(d == doc || d == doc.body){ var l, t; if(CQ.Ext.isIE && CQ.Ext.isStrict){ l = doc.documentElement.scrollLeft || (doc.body.scrollLeft || 0); t = doc.documentElement.scrollTop || (doc.body.scrollTop || 0); }else{ l = window.pageXOffset || (doc.body.scrollLeft || 0); t = window.pageYOffset || (doc.body.scrollTop || 0); } return {left: l, top: t}; }else{ return {left: d.scrollLeft, top: d.scrollTop}; } }, /** * Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values * are convert to standard 6 digit hex color. * @param {String} attr The css attribute * @param {String} defaultValue The default value to use when a valid color isn't found * @param {String} prefix (optional) defaults to #. Use an empty string when working with * color anims. */ getColor : function(attr, defaultValue, prefix){ var v = this.getStyle(attr); if(!v || v == "transparent" || v == "inherit") { return defaultValue; } var color = typeof prefix == "undefined" ? "#" : prefix; if(v.substr(0, 4) == "rgb("){ var rvs = v.slice(4, v.length -1).split(","); for(var i = 0; i < 3; i++){ var h = parseInt(rvs[i]); var s = h.toString(16); if(h < 16){ s = "0" + s; } color += s; } } else { if(v.substr(0, 1) == "#"){ if(v.length == 4) { for(var i = 1; i < 4; i++){ var c = v.charAt(i); color += c + c; } }else if(v.length == 7){ color += v.substr(1); } } } return(color.length > 5 ? color.toLowerCase() : defaultValue); }, /** * Wraps the specified element with a special markup/CSS block that renders by default as a gray container with a * gradient background, rounded corners and a 4-way shadow. Example usage: *


// Basic box wrap
CQ.Ext.get("foo").boxWrap();

// You can also add a custom class and use CSS inheritance rules to customize the box look.
// 'x-box-blue' is a built-in alternative -- look at the related CSS definitions as an example
// for how to create a custom box wrap style.
CQ.Ext.get("foo").boxWrap().addClass("x-box-blue");

* @param {String} class (optional) A base CSS class to apply to the containing wrapper element (defaults to 'x-box'). * Note that there are a number of CSS rules that are dependent on this name to make the overall effect work, * so if you supply an alternate base class, make sure you also supply all of the necessary rules. * @return {CQ.Ext.Element} this */ boxWrap : function(cls){ cls = cls || 'x-box'; var el = CQ.Ext.get(this.insertHtml('beforeBegin', String.format('

'+El.boxMarkup+'

', cls))); el.child('.'+cls+'-mc').dom.appendChild(this.dom); return el; }, /** * Returns the value of a namespaced attribute from the element's underlying DOM node. * @param {String} namespace The namespace in which to look for the attribute * @param {String} name The attribute name * @return {String} The attribute value */ getAttributeNS : CQ.Ext.isIE ? function(ns, name){ var d = this.dom; var type = typeof d[ns+":"+name]; if(type != 'undefined' && type != 'unknown'){ return d[ns+":"+name]; } return d[name]; } : function(ns, name){ var d = this.dom; return d.getAttributeNS(ns, name) || d.getAttribute(ns+":"+name) || d.getAttribute(name) || d[name]; }, /** * Returns the width in pixels of the passed text, or the width of the text in this Element. * @param {String} text The text to measure. Defaults to the innerHTML of the element. * @param {Number} min (Optional) The minumum value to return. * @param {Number} max (Optional) The maximum value to return. * @return {Number} The text width in pixels. */ getTextWidth : function(text, min, max){ return (CQ.Ext.util.TextMetrics.measure(this.dom, CQ.Ext.value(text, this.dom.innerHTML, true)).width).constrain(min || 0, max || 1000000); } }; var ep = El.prototype; /** * Appends an event handler (shorthand for {@link #addListener}). * @param {String} eventName The type of event to handle * @param {Function} fn The handler function the event invokes * @param {Object} scope (optional) The scope (this element) of the handler function * @param {Object} options (optional) An object containing standard {@link #addListener} options * @member CQ.Ext.Element * @method on */ ep.on = ep.addListener; // backwards compat ep.mon = ep.addListener; ep.getUpdateManager = ep.getUpdater; /** * Removes an event handler from this element (shorthand for {@link #removeListener}). * @param {String} eventName the type of event to remove * @param {Function} fn the method the event invokes * @return {CQ.Ext.Element} this * @member CQ.Ext.Element * @method un */ ep.un = ep.removeListener; /** * true to automatically adjust width and height settings for box-model issues (default to true) */ ep.autoBoxAdjust = true; // private El.unitPattern = /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i; // private El.addUnits = function(v, defaultUnit){ if(v === "" || v == "auto"){ return v; } if(v === undefined){ return ''; } if(typeof v == "number" || !El.unitPattern.test(v)){ return v + (defaultUnit || 'px'); } return v; }; // special markup used throughout Ext when box wrapping elements El.boxMarkup = '

'; /** * Visibility mode constant - Use visibility to hide element * @static * @type Number */ El.VISIBILITY = 1; /** * Visibility mode constant - Use display to hide element * @static * @type Number */ El.DISPLAY = 2; El.borders = {l: "border-left-width", r: "border-right-width", t: "border-top-width", b: "border-bottom-width"}; El.paddings = {l: "padding-left", r: "padding-right", t: "padding-top", b: "padding-bottom"}; El.margins = {l: "margin-left", r: "margin-right", t: "margin-top", b: "margin-bottom"}; /** * @private */ El.cache = {}; var docEl; /** * Static method to retrieve CQ.Ext.Element objects. *

This method does not retrieve {@link CQ.Ext.Component Component}s. This method * retrieves CQ.Ext.Element objects which encapsulate DOM elements. To retrieve a Component by * its ID, use {@link CQ.Ext.ComponentMgr#get}.

Uses simple caching to consistently return the same object. * Automatically fixes if an object was recreated with the same id via AJAX or DOM.

* @param {Mixed} el The id of the node, a DOM Node or an existing Element. * @return {Element} The {@link CQ.Ext.Element Element} object (or null if no matching element was found) * @static */ El.get = function(el){ var ex, elm, id; if(!el){ return null; } if(typeof el == "string"){ // element id if(!(elm = document.getElementById(el))){ // CQ:START // create CQ root if it doesn't exist yet if (CQ.Util.isRoot(el)) { return CQ.Util.createRoot(); } // CQ:END return null; } if(ex = El.cache[el]){ ex.dom = elm; }else{ ex = El.cache[el] = new El(elm); } return ex; }else if(el.tagName){ // dom element if(!(id = el.id)){ id = CQ.Ext.id(el); } if(ex = El.cache[id]){ ex.dom = el; }else{ ex = El.cache[id] = new El(el); } return ex; }else if(el instanceof El){ if(el != docEl){ el.dom = document.getElementById(el.id) || el.dom; // refresh dom element in case no longer valid, // catch case where it hasn't been appended El.cache[el.id] = el; // in case it was created directly with Element(), let's cache it } return el; }else if(el.isComposite){ return el; }else if(CQ.Ext.isArray(el)){ return El.select(el); }else if(el == document){ // create a bogus element object representing the document object if(!docEl){ var f = function(){}; f.prototype = El.prototype; docEl = new f(); docEl.dom = document; } return docEl; } return null; }; // private El.uncache = function(el){ for(var i = 0, a = arguments, len = a.length; i < len; i++) { if(a[i]){ delete El.cache[a[i].id || a[i]]; } } }; // private // Garbage collection - uncache elements/purge listeners on orphaned elements // so we don't hold a reference and cause the browser to retain them El.garbageCollect = function(){ if(!CQ.Ext.enableGarbageCollector){ clearInterval(El.collectorThread); return; } for(var eid in El.cache){ var el = El.cache[eid], d = el.dom; // ------------------------------------------------------- // Determining what is garbage: // ------------------------------------------------------- // !d // dom node is null, definitely garbage // ------------------------------------------------------- // !d.parentNode // no parentNode == direct orphan, definitely garbage // ------------------------------------------------------- // !d.offsetParent && !document.getElementById(eid) // display none elements have no offsetParent so we will // also try to look it up by it's id. However, check // offsetParent first so we don't do unneeded lookups. // This enables collection of elements that are not orphans // directly, but somewhere up the line they have an orphan // parent. // ------------------------------------------------------- if(!d || !d.parentNode || (!d.offsetParent && !document.getElementById(eid))){ delete El.cache[eid]; if(d && CQ.Ext.enableListenerCollection){ CQ.Ext.EventManager.removeAll(d); } } } } El.collectorThreadId = setInterval(El.garbageCollect, 30000); var flyFn = function(){}; flyFn.prototype = El.prototype; var _cls = new flyFn(); // dom is optional El.Flyweight = function(dom){ this.dom = dom; }; El.Flyweight.prototype = _cls; El.Flyweight.prototype.isFlyweight = true; El._flyweights = {}; /** * Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element - * the dom node can be overwritten by other code. * @param {String/HTMLElement} el The dom node or id * @param {String} named (optional) Allows for creation of named reusable flyweights to * prevent conflicts (e.g. internally Ext uses "_internal") * @static * @return {Element} The shared Element object (or null if no matching element was found) */ El.fly = function(el, named){ named = named || '_global'; el = CQ.Ext.getDom(el); if(!el){ return null; } if(!El._flyweights[named]){ El._flyweights[named] = new El.Flyweight(); } El._flyweights[named].dom = el; return El._flyweights[named]; }; /** * Static method to retrieve Element objects. Uses simple caching to consistently return the same object. * Automatically fixes if an object was recreated with the same id via AJAX or DOM. * Shorthand of {@link CQ.Ext.Element#get} * @param {Mixed} el The id of the node, a DOM Node or an existing Element. * @return {Element} The Element object * @member CQ.Ext * @method get */ CQ.Ext.get = El.get; /** * Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element - * the dom node can be overwritten by other code. * Shorthand of {@link CQ.Ext.Element#fly} * @param {String/HTMLElement} el The dom node or id * @param {String} named (optional) Allows for creation of named reusable flyweights to * prevent conflicts (e.g. internally Ext uses "_internal") * @static * @return {Element} The shared Element object * @member CQ.Ext * @method fly */ CQ.Ext.fly = El.fly; // speedy lookup for elements never to box adjust var noBoxAdjust = CQ.Ext.isStrict ? { select:1 } : { input:1, select:1, textarea:1 }; if(CQ.Ext.isIE || CQ.Ext.isGecko){ noBoxAdjust['button'] = 1; } CQ.Ext.EventManager.on(window, 'unload', function(){ delete El.cache; delete El._flyweights; }); })();/* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ //Notifies Element that fx methods are available CQ.Ext.enableFx = true; /** * @class CQ.Ext.Fx *

A class to provide basic animation and visual effects support. Note: This class is automatically applied * to the {@link CQ.Ext.Element} interface when included, so all effects calls should be performed via Element. * Conversely, since the effects are not actually defined in Element, CQ.Ext.Fx must be included in order for the * Element effects to work.

* *

It is important to note that although the Fx methods and many non-Fx Element methods support "method chaining" in that * they return the Element object itself as the method return value, it is not always possible to mix the two in a single * method chain. The Fx methods use an internal effects queue so that each effect can be properly timed and sequenced. * Non-Fx methods, on the other hand, have no such internal queueing and will always execute immediately. For this reason, * while it may be possible to mix certain Fx and non-Fx method calls in a single chain, it may not always provide the * expected results and should be done with care.

* *

Motion effects support 8-way anchoring, meaning that you can choose one of 8 different anchor points on the Element * that will serve as either the start or end point of the animation. Following are all of the supported anchor positions:

Value  Description
-----  -----------------------------
tl     The top left corner
t      The center of the top edge
tr     The top right corner
l      The center of the left edge
r      The center of the right edge
bl     The bottom left corner
b      The center of the bottom edge
br     The bottom right corner

* Although some Fx methods accept specific custom config parameters, the ones shown in the Config Options section * below are common options that can be passed to any Fx method. * * @cfg {Function} callback A function called when the effect is finished. Note that effects are queued internally by the * Fx class, so do not need to use the callback parameter to specify another effect -- effects can simply be chained together * and called in sequence (e.g., el.slideIn().highlight();). The callback is intended for any additional code that should * run once a particular effect has completed. The Element being operated upon is passed as the first parameter. * @cfg {Object} scope The scope of the effect function * @cfg {String} easing A valid Easing value for the effect * @cfg {String} afterCls A css class to apply after the effect * @cfg {Number} duration The length of time (in seconds) that the effect should last * @cfg {Boolean} remove Whether the Element should be removed from the DOM and destroyed after the effect finishes * @cfg {Boolean} useDisplay Whether to use the display CSS property instead of visibility when hiding Elements (only applies to * effects that end with the element being visually hidden, ignored otherwise) * @cfg {String/Object/Function} afterStyle A style specification string, e.g. "width:100px", or an object in the form {width:"100px"}, or * a function which returns such a specification that will be applied to the Element after the effect finishes * @cfg {Boolean} block Whether the effect should block other effects from queueing while it runs * @cfg {Boolean} concurrent Whether to allow subsequently-queued effects to run at the same time as the current effect, or to ensure that they run in sequence * @cfg {Boolean} stopFx Whether subsequent effects should be stopped and removed after the current effect finishes */ CQ.Ext.Fx = { /** * Slides the element into view. An anchor point can be optionally passed to set the point of * origin for the slide effect. This function automatically handles wrapping the element with * a fixed-size container if needed. See the Fx class overview for valid anchor point options. * Usage: *


// default: slide the element in from the top
el.slideIn();

// custom: slide the element in from the right with a 2-second duration
el.slideIn('r', { duration: 2 });

// common config options shown with default values
el.slideIn('t', {
    easing: 'easeOut',
    duration: .5
});

* @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't') * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ slideIn : function(anchor, o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ anchor = anchor || "t"; // fix display to visibility this.fixDisplay(); // restore values after effect var r = this.getFxRestore(); var b = this.getBox(); // fixed size for slide this.setSize(b); // wrap if needed var wrap = this.fxWrap(r.pos, o, "hidden"); var st = this.dom.style; st.visibility = "visible"; st.position = "absolute"; // clear out temp styles after slide and unwrap var after = function(){ el.fxUnwrap(wrap, r.pos, o); st.width = r.width; st.height = r.height; el.afterFx(o); }; // time to calc the positions var a, pt = {to: [b.x, b.y]}, bw = {to: b.width}, bh = {to: b.height}; switch(anchor.toLowerCase()){ case "t": wrap.setSize(b.width, 0); st.left = st.bottom = "0"; a = {height: bh}; break; case "l": wrap.setSize(0, b.height); st.right = st.top = "0"; a = {width: bw}; break; case "r": wrap.setSize(0, b.height); wrap.setX(b.right); st.left = st.top = "0"; a = {width: bw, points: pt}; break; case "b": wrap.setSize(b.width, 0); wrap.setY(b.bottom); st.left = st.top = "0"; a = {height: bh, points: pt}; break; case "tl": wrap.setSize(0, 0); st.right = st.bottom = "0"; a = {width: bw, height: bh}; break; case "bl": wrap.setSize(0, 0); wrap.setY(b.y+b.height); st.right = st.top = "0"; a = {width: bw, height: bh, points: pt}; break; case "br": wrap.setSize(0, 0); wrap.setXY([b.right, b.bottom]); st.left = st.top = "0"; a = {width: bw, height: bh, points: pt}; break; case "tr": wrap.setSize(0, 0); wrap.setX(b.x+b.width); st.left = st.bottom = "0"; a = {width: bw, height: bh, points: pt}; break; } this.dom.style.visibility = "visible"; wrap.show(); arguments.callee.anim = wrap.fxanim(a, o, 'motion', .5, 'easeOut', after); }); return this; }, /** * Slides the element out of view. An anchor point can be optionally passed to set the end point * for the slide effect. When the effect is completed, the element will be hidden (visibility = * 'hidden') but block elements will still take up space in the document. The element must be removed * from the DOM using the 'remove' config option if desired. This function automatically handles * wrapping the element with a fixed-size container if needed. See the Fx class overview for valid anchor point options. * Usage: *


// default: slide the element out to the top
el.slideOut();

// custom: slide the element out to the right with a 2-second duration
el.slideOut('r', { duration: 2 });

// common config options shown with default values
el.slideOut('t', {
    easing: 'easeOut',
    duration: .5,
    remove: false,
    useDisplay: false
});

* @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't') * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ slideOut : function(anchor, o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ anchor = anchor || "t"; // restore values after effect var r = this.getFxRestore(); var b = this.getBox(); // fixed size for slide this.setSize(b); // wrap if needed var wrap = this.fxWrap(r.pos, o, "visible"); var st = this.dom.style; st.visibility = "visible"; st.position = "absolute"; wrap.setSize(b); var after = function(){ if(o.useDisplay){ el.setDisplayed(false); }else{ el.hide(); } el.fxUnwrap(wrap, r.pos, o); st.width = r.width; st.height = r.height; el.afterFx(o); }; var a, zero = {to: 0}; switch(anchor.toLowerCase()){ case "t": st.left = st.bottom = "0"; a = {height: zero}; break; case "l": st.right = st.top = "0"; a = {width: zero}; break; case "r": st.left = st.top = "0"; a = {width: zero, points: {to:[b.right, b.y]}}; break; case "b": st.left = st.top = "0"; a = {height: zero, points: {to:[b.x, b.bottom]}}; break; case "tl": st.right = st.bottom = "0"; a = {width: zero, height: zero}; break; case "bl": st.right = st.top = "0"; a = {width: zero, height: zero, points: {to:[b.x, b.bottom]}}; break; case "br": st.left = st.top = "0"; a = {width: zero, height: zero, points: {to:[b.x+b.width, b.bottom]}}; break; case "tr": st.left = st.bottom = "0"; a = {width: zero, height: zero, points: {to:[b.right, b.y]}}; break; } arguments.callee.anim = wrap.fxanim(a, o, 'motion', .5, "easeOut", after); }); return this; }, /** * Fades the element out while slowly expanding it in all directions. When the effect is completed, the * element will be hidden (visibility = 'hidden') but block elements will still take up space in the document. * The element must be removed from the DOM using the 'remove' config option if desired. * Usage: *


// default
el.puff();

// common config options shown with default values
el.puff({
    easing: 'easeOut',
    duration: .5,
    remove: false,
    useDisplay: false
});

* @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ puff : function(o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ this.clearOpacity(); this.show(); // restore values after effect var r = this.getFxRestore(); var st = this.dom.style; var after = function(){ if(o.useDisplay){ el.setDisplayed(false); }else{ el.hide(); } el.clearOpacity(); el.setPositioning(r.pos); st.width = r.width; st.height = r.height; st.fontSize = ''; el.afterFx(o); }; var width = this.getWidth(); var height = this.getHeight(); arguments.callee.anim = this.fxanim({ width : {to: this.adjustWidth(width * 2)}, height : {to: this.adjustHeight(height * 2)}, points : {by: [-(width * .5), -(height * .5)]}, opacity : {to: 0}, fontSize: {to:200, unit: "%"} }, o, 'motion', .5, "easeOut", after); }); return this; }, /** * Blinks the element as if it was clicked and then collapses on its center (similar to switching off a television). * When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still * take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired. * Usage: *


// default
el.switchOff();

// all config options shown with default values
el.switchOff({
    easing: 'easeIn',
    duration: .3,
    remove: false,
    useDisplay: false
});

* @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ switchOff : function(o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ this.clearOpacity(); this.clip(); // restore values after effect var r = this.getFxRestore(); var st = this.dom.style; var after = function(){ if(o.useDisplay){ el.setDisplayed(false); }else{ el.hide(); } el.clearOpacity(); el.setPositioning(r.pos); st.width = r.width; st.height = r.height; el.afterFx(o); }; this.fxanim({opacity:{to:0.3}}, null, null, .1, null, function(){ this.clearOpacity(); (function(){ this.fxanim({ height:{to:1}, points:{by:[0, this.getHeight() * .5]} }, o, 'motion', 0.3, 'easeIn', after); }).defer(100, this); }); }); return this; }, /** * Highlights the Element by setting a color (applies to the background-color by default, but can be * changed using the "attr" config option) and then fading back to the original color. If no original * color is available, you should provide the "endColor" config option which will be cleared after the animation. * Usage:


// default: highlight background to yellow
el.highlight();

// custom: highlight foreground text to blue for 2 seconds
el.highlight("0000ff", { attr: 'color', duration: 2 });

// common config options shown with default values
el.highlight("ffff9c", {
    attr: "background-color", //can be any valid CSS property (attribute) that supports a color value
    endColor: (current color) or "ffffff",
    easing: 'easeIn',
    duration: 1
});

* @param {String} color (optional) The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c') * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ highlight : function(color, o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ color = color || "ffff9c"; var attr = o.attr || "backgroundColor"; this.clearOpacity(); this.show(); var origColor = this.getColor(attr); var restoreColor = this.dom.style[attr]; var endColor = (o.endColor || origColor) || "ffffff"; var after = function(){ el.dom.style[attr] = restoreColor; el.afterFx(o); }; var a = {}; a[attr] = {from: color, to: endColor}; arguments.callee.anim = this.fxanim(a, o, 'color', 1, 'easeIn', after); }); return this; }, /** * Shows a ripple of exploding, attenuating borders to draw attention to an Element. * Usage:


// default: a single light blue ripple
el.frame();

// custom: 3 red ripples lasting 3 seconds total
el.frame("ff0000", 3, { duration: 3 });

// common config options shown with default values
el.frame("C3DAF9", 1, {
    duration: 1 //duration of entire animation (not each individual ripple)
    // Note: Easing is not configurable and will be ignored if included
});

* @param {String} color (optional) The color of the border. Should be a 6 char hex color without the leading # (defaults to light blue: 'C3DAF9'). * @param {Number} count (optional) The number of ripples to display (defaults to 1) * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ frame : function(color, count, o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ color = color || "#C3DAF9"; if(color.length == 6){ color = "#" + color; } count = count || 1; var duration = o.duration || 1; this.show(); var b = this.getBox(); var animFn = function(){ var proxy = CQ.Ext.getBody().createChild({ style:{ visbility:"hidden", position:"absolute", "z-index":"35000", // yee haw border:"0px solid " + color } }); var scale = CQ.Ext.isBorderBox ? 2 : 1; proxy.animate({ top:{from:b.y, to:b.y - 20}, left:{from:b.x, to:b.x - 20}, borderWidth:{from:0, to:10}, opacity:{from:1, to:0}, height:{from:b.height, to:(b.height + (20*scale))}, width:{from:b.width, to:(b.width + (20*scale))} }, duration, function(){ proxy.remove(); if(--count > 0){ animFn(); }else{ el.afterFx(o); } }); }; animFn.call(this); }); return this; }, /** * Creates a pause before any subsequent queued effects begin. If there are * no effects queued after the pause it will have no effect. * Usage:


el.pause(1);

* @param {Number} seconds The length of time to pause (in seconds) * @return {CQ.Ext.Element} The Element */ pause : function(seconds){ var el = this.getFxEl(); var o = {}; el.queueFx(o, function(){ setTimeout(function(){ el.afterFx(o); }, seconds * 1000); }); return this; }, /** * Fade an element in (from transparent to opaque). The ending opacity can be specified * using the "endOpacity" config option. * Usage:


// default: fade in from opacity 0 to 100%
el.fadeIn();

// custom: fade in from opacity 0 to 75% over 2 seconds
el.fadeIn({ endOpacity: .75, duration: 2});

// common config options shown with default values
el.fadeIn({
    endOpacity: 1, //can be any value between 0 and 1 (e.g. .5)
    easing: 'easeOut',
    duration: .5
});

* @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ fadeIn : function(o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ this.setOpacity(0); this.fixDisplay(); this.dom.style.visibility = 'visible'; var to = o.endOpacity || 1; arguments.callee.anim = this.fxanim({opacity:{to:to}}, o, null, .5, "easeOut", function(){ if(to == 1){ this.clearOpacity(); } el.afterFx(o); }); }); return this; }, /** * Fade an element out (from opaque to transparent). The ending opacity can be specified * using the "endOpacity" config option. Note that IE may require useDisplay:true in order * to redisplay correctly. * Usage:


// default: fade out from the element's current opacity to 0
el.fadeOut();

// custom: fade out from the element's current opacity to 25% over 2 seconds
el.fadeOut({ endOpacity: .25, duration: 2});

// common config options shown with default values
el.fadeOut({
    endOpacity: 0, //can be any value between 0 and 1 (e.g. .5)
    easing: 'easeOut',
    duration: .5,
    remove: false,
    useDisplay: false
});

* @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ fadeOut : function(o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ arguments.callee.anim = this.fxanim({opacity:{to:o.endOpacity || 0}}, o, null, .5, "easeOut", function(){ if(this.visibilityMode == CQ.Ext.Element.DISPLAY || o.useDisplay){ this.dom.style.display = "none"; }else{ this.dom.style.visibility = "hidden"; } this.clearOpacity(); el.afterFx(o); }); }); return this; }, /** * Animates the transition of an element's dimensions from a starting height/width * to an ending height/width. * Usage:


// change height and width to 100x100 pixels
el.scale(100, 100);

// common config options shown with default values.  The height and width will default to
// the element's existing values if passed as null.
el.scale(
    [element's width],
    [element's height], {
	    easing: 'easeOut',
	    duration: .35
	}
);

* @param {Number} width The new width (pass undefined to keep the original width) * @param {Number} height The new height (pass undefined to keep the original height) * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ scale : function(w, h, o){ this.shift(CQ.Ext.apply({}, o, { width: w, height: h })); return this; }, /** * Animates the transition of any combination of an element's dimensions, xy position and/or opacity. * Any of these properties not specified in the config object will not be changed. This effect * requires that at least one new dimension, position or opacity setting must be passed in on * the config object in order for the function to have any effect. * Usage:


// slide the element horizontally to x position 200 while changing the height and opacity
el.shift({ x: 200, height: 50, opacity: .8 });

// common config options shown with default values.
el.shift({
    width: [element's width],
    height: [element's height],
    x: [element's x position],
    y: [element's y position],
    opacity: [element's opacity],
    easing: 'easeOut',
    duration: .35
});

* @param {Object} options Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ shift : function(o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ var a = {}, w = o.width, h = o.height, x = o.x, y = o.y, op = o.opacity; if(w !== undefined){ a.width = {to: this.adjustWidth(w)}; } if(h !== undefined){ a.height = {to: this.adjustHeight(h)}; } if(o.left !== undefined){ a.left = {to: o.left}; } if(o.top !== undefined){ a.top = {to: o.top}; } if(o.right !== undefined){ a.right = {to: o.right}; } if(o.bottom !== undefined){ a.bottom = {to: o.bottom}; } if(x !== undefined || y !== undefined){ a.points = {to: [ x !== undefined ? x : this.getX(), y !== undefined ? y : this.getY() ]}; } if(op !== undefined){ a.opacity = {to: op}; } if(o.xy !== undefined){ a.points = {to: o.xy}; } arguments.callee.anim = this.fxanim(a, o, 'motion', .35, "easeOut", function(){ el.afterFx(o); }); }); return this; }, /** * Slides the element while fading it out of view. An anchor point can be optionally passed to set the * ending point of the effect. * Usage: *


// default: slide the element downward while fading out
el.ghost();

// custom: slide the element out to the right with a 2-second duration
el.ghost('r', { duration: 2 });

// common config options shown with default values
el.ghost('b', {
    easing: 'easeOut',
    duration: .5,
    remove: false,
    useDisplay: false
});

* @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to bottom: 'b') * @param {Object} options (optional) Object literal with any of the Fx config options * @return {CQ.Ext.Element} The Element */ ghost : function(anchor, o){ var el = this.getFxEl(); o = o || {}; el.queueFx(o, function(){ anchor = anchor || "b"; // restore values after effect var r = this.getFxRestore(); var w = this.getWidth(), h = this.getHeight(); var st = this.dom.style; var after = function(){ if(o.useDisplay){ el.setDisplayed(false); }else{ el.hide(); } el.clearOpacity(); el.setPositioning(r.pos); st.width = r.width; st.height = r.height; el.afterFx(o); }; var a = {opacity: {to: 0}, points: {}}, pt = a.points; switch(anchor.toLowerCase()){ case "t": pt.by = [0, -h]; break; case "l": pt.by = [-w, 0]; break; case "r": pt.by = [w, 0]; break; case "b": pt.by = [0, h]; break; case "tl": pt.by = [-w, -h]; break; case "bl": pt.by = [-w, h]; break; case "br": pt.by = [w, h]; break; case "tr": pt.by = [w, -h]; break; } arguments.callee.anim = this.fxanim(a, o, 'motion', .5, "easeOut", after); }); return this; }, /** * Ensures that all effects queued after syncFx is called on the element are * run concurrently. This is the opposite of {@link #sequenceFx}. * @return {CQ.Ext.Element} The Element */ syncFx : function(){ this.fxDefaults = CQ.Ext.apply(this.fxDefaults || {}, { block : false, concurrent : true, stopFx : false }); return this; }, /** * Ensures that all effects queued after sequenceFx is called on the element are * run in sequence. This is the opposite of {@link #syncFx}. * @return {CQ.Ext.Element} The Element */ sequenceFx : function(){ this.fxDefaults = CQ.Ext.apply(this.fxDefaults || {}, { block : false, concurrent : false, stopFx : false }); return this; }, /* @private */ nextFx : function(){ var ef = this.fxQueue[0]; if(ef){ ef.call(this); } }, /** * Returns true if the element has any effects actively running or queued, else returns false. * @return {Boolean} True if element has active effects, else false */ hasActiveFx : function(){ return this.fxQueue && this.fxQueue[0]; }, /** * Stops any running effects and clears the element's internal effects queue if it contains * any additional effects that haven't started yet. * @return {CQ.Ext.Element} The Element */ stopFx : function(){ if(this.hasActiveFx()){ var cur = this.fxQueue[0]; if(cur && cur.anim && cur.anim.isAnimated()){ this.fxQueue = [cur]; // clear out others cur.anim.stop(true); } } return this; }, /* @private */ beforeFx : function(o){ if(this.hasActiveFx() && !o.concurrent){ if(o.stopFx){ this.stopFx(); return true; } return false; } return true; }, /** * Returns true if the element is currently blocking so that no other effect can be queued * until this effect is finished, else returns false if blocking is not set. This is commonly * used to ensure that an effect initiated by a user action runs to completion prior to the * same effect being restarted (e.g., firing only one effect even if the user clicks several times). * @return {Boolean} True if blocking, else false */ hasFxBlock : function(){ var q = this.fxQueue; return q && q[0] && q[0].block; }, /* @private */ queueFx : function(o, fn){ if(!this.fxQueue){ this.fxQueue = []; } if(!this.hasFxBlock()){ CQ.Ext.applyIf(o, this.fxDefaults); if(!o.concurrent){ var run = this.beforeFx(o); fn.block = o.block; this.fxQueue.push(fn); if(run){ this.nextFx(); } }else{ fn.call(this); } } return this; }, /* @private */ fxWrap : function(pos, o, vis){ var wrap; if(!o.wrap || !(wrap = CQ.Ext.get(o.wrap))){ var wrapXY; if(o.fixPosition){ wrapXY = this.getXY(); } var div = document.createElement("div"); div.style.visibility = vis; wrap = CQ.Ext.get(this.dom.parentNode.insertBefore(div, this.dom)); wrap.setPositioning(pos); if(wrap.getStyle("position") == "static"){ wrap.position("relative"); } this.clearPositioning('auto'); wrap.clip(); wrap.dom.appendChild(this.dom); if(wrapXY){ wrap.setXY(wrapXY); } } return wrap; }, /* @private */ fxUnwrap : function(wrap, pos, o){ this.clearPositioning(); this.setPositioning(pos); if(!o.wrap){ wrap.dom.parentNode.insertBefore(this.dom, wrap.dom); wrap.remove(); } }, /* @private */ getFxRestore : function(){ var st = this.dom.style; return {pos: this.getPositioning(), width: st.width, height : st.height}; }, /* @private */ afterFx : function(o){ if(o.afterStyle){ this.applyStyles(o.afterStyle); } if(o.afterCls){ this.addClass(o.afterCls); } if(o.remove === true){ this.remove(); } CQ.Ext.callback(o.callback, o.scope, [this]); if(!o.concurrent){ this.fxQueue.shift(); this.nextFx(); } }, /* @private */ getFxEl : function(){ // support for composite element fx return CQ.Ext.get(this.dom); }, /* @private */ fxanim : function(args, opt, animType, defaultDur, defaultEase, cb){ animType = animType || 'run'; opt = opt || {}; var anim = CQ.Ext.lib.Anim[animType]( this.dom, args, (opt.duration || defaultDur) || .35, (opt.easing || defaultEase) || 'easeOut', function(){ CQ.Ext.callback(cb, this); }, this ); opt.anim = anim; return anim; } }; // backwords compat CQ.Ext.Fx.resize = CQ.Ext.Fx.scale; //When included, CQ.Ext.Fx is automatically applied to Element so that all basic //effects are available directly via the Element API CQ.Ext.apply(CQ.Ext.Element.prototype, CQ.Ext.Fx); /* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class CQ.Ext.CompositeElement * Standard composite class. Creates a CQ.Ext.Element for every element in the collection. *

* NOTE: Although they are not listed, this class supports all of the set/update methods of CQ.Ext.Element. All CQ.Ext.Element * actions will be performed on all the elements in this collection. *

* All methods return this and can be chained.


 var els = CQ.Ext.select("#some-el div.some-class", true);
 // or select directly from an existing element
 var el = CQ.Ext.get('some-el');
 el.select('div.some-class', true);

 els.setWidth(100); // all elements become 100 width
 els.hide(true); // all elements fade out and hide
 // or
 els.setWidth(100).hide(true);

*/ CQ.Ext.CompositeElement = function(els){ this.elements = []; this.addElements(els); }; CQ.Ext.CompositeElement.prototype = { isComposite: true, addElements : function(els){ if(!els) return this; if(typeof els == "string"){ els = CQ.Ext.Element.selectorFunction(els); } var yels = this.elements; var index = yels.length-1; for(var i = 0, len = els.length; i < len; i++) { yels[++index] = CQ.Ext.get(els[i]); } return this; }, /** * Clears this composite and adds the elements returned by the passed selector. * @param {String/Array} els A string CSS selector, an array of elements or an element * @return {CompositeElement} this */ fill : function(els){ this.elements = []; this.add(els); return this; }, /** * Filters this composite to only elements that match the passed selector. * @param {String} selector A string CSS selector * @return {CompositeElement} this */ filter : function(selector){ var els = []; this.each(function(el){ if(el.is(selector)){ els[els.length] = el.dom; } }); this.fill(els); return this; }, invoke : function(fn, args){ var els = this.elements; for(var i = 0, len = els.length; i < len; i++) { CQ.Ext.Element.prototype[fn].apply(els[i], args); } return this; }, /** * Adds elements to this composite. * @param {String/Array} els A string CSS selector, an array of elements or an element * @return {CompositeElement} this */ add : function(els){ if(typeof els == "string"){ this.addElements(CQ.Ext.Element.selectorFunction(els)); }else if(els.length !== undefined){ this.addElements(els); }else{ this.addElements([els]); } return this; }, /** * Calls the passed function passing (el, this, index) for each element in this composite. * @param {Function} fn The function to call * @param {Object} scope (optional) The this object (defaults to the element) * @return {CompositeElement} this */ each : function(fn, scope){ var els = this.elements; for(var i = 0, len = els.length; i < len; i++){ if(fn.call(scope || els[i], els[i], this, i) === false) { break; } } return this; }, /** * Returns the Element object at the specified index * @param {Number} index * @return {CQ.Ext.Element} */ item : function(index){ return this.elements[index] || null; }, /** * Returns the first Element * @return {CQ.Ext.Element} */ first : function(){ return this.item(0); }, /** * Returns the last Element * @return {CQ.Ext.Element} */ last : function(){ return this.item(this.elements.length-1); }, /** * Returns the number of elements in this composite * @return Number */ getCount : function(){ return this.elements.length; }, /** * Returns true if this composite contains the passed element * @param el {Mixed} The id of an element, or an CQ.Ext.Element, or an HtmlElement to find within the composite collection. * @return Boolean */ contains : function(el){ return this.indexOf(el) !== -1; }, /** * Find the index of the passed element within the composite collection. * @param el {Mixed} The id of an element, or an CQ.Ext.Element, or an HtmlElement to find within the composite collection. * @return Number The index of the passed CQ.Ext.Element in the composite collection, or -1 if not found. */ indexOf : function(el){ return this.elements.indexOf(CQ.Ext.get(el)); }, /** * Removes the specified element(s). * @param {Mixed} el The id of an element, the Element itself, the index of the element in this composite * or an array of any of those. * @param {Boolean} removeDom (optional) True to also remove the element from the document * @return {CompositeElement} this */ removeElement : function(el, removeDom){ if(CQ.Ext.isArray(el)){ for(var i = 0, len = el.length; i < len; i++){ this.removeElement(el[i]); } return this; } var index = typeof el == 'number' ? el : this.indexOf(el); if(index !== -1 && this.elements[index]){ if(removeDom){ var d = this.elements[index]; if(d.dom){ d.remove(); }else{ CQ.Ext.removeNode(d); } } this.elements.splice(index, 1); } return this; }, /** * Replaces the specified element with the passed element. * @param {Mixed} el The id of an element, the Element itself, the index of the element in this composite * to replace. * @param {Mixed} replacement The id of an element or the Element itself. * @param {Boolean} domReplace (Optional) True to remove and replace the element in the document too. * @return {CompositeElement} this */ replaceElement : function(el, replacement, domReplace){ var index = typeof el == 'number' ? el : this.indexOf(el); if(index !== -1){ if(domReplace){ this.elements[index].replaceWith(replacement); }else{ this.elements.splice(index, 1, CQ.Ext.get(replacement)) } } return this; }, /** * Removes all elements. */ clear : function(){ this.elements = []; } }; (function(){ CQ.Ext.CompositeElement.createCall = function(proto, fnName){ if(!proto[fnName]){ proto[fnName] = function(){ return this.invoke(fnName, arguments); }; } }; for(var fnName in CQ.Ext.Element.prototype){ if(typeof CQ.Ext.Element.prototype[fnName] == "function"){ CQ.Ext.CompositeElement.createCall(CQ.Ext.CompositeElement.prototype, fnName); } }; })(); /** * @class CQ.Ext.CompositeElementLite * @extends CQ.Ext.CompositeElement * Flyweight composite class. Reuses the same CQ.Ext.Element for element operations.


 var els = CQ.Ext.select("#some-el div.some-class");
 // or select directly from an existing element
 var el = CQ.Ext.get('some-el');
 el.select('div.some-class');

 els.setWidth(100); // all elements become 100 width
 els.hide(true); // all elements fade out and hide
 // or
 els.setWidth(100).hide(true);

* NOTE: Although they are not listed, this class supports all of the set/update methods of CQ.Ext.Element. All CQ.Ext.Element * actions will be performed on all the elements in this collection. */ CQ.Ext.CompositeElementLite = function(els){ CQ.Ext.CompositeElementLite.superclass.constructor.call(this, els); this.el = new CQ.Ext.Element.Flyweight(); }; CQ.Ext.extend(CQ.Ext.CompositeElementLite, CQ.Ext.CompositeElement, { addElements : function(els){ if(els){ if(CQ.Ext.isArray(els)){ this.elements = this.elements.concat(els); }else{ var yels = this.elements; var index = yels.length-1; for(var i = 0, len = els.length; i < len; i++) { yels[++index] = els[i]; } } } return this; }, invoke : function(fn, args){ var els = this.elements; var el = this.el; for(var i = 0, len = els.length; i < len; i++) { el.dom = els[i]; CQ.Ext.Element.prototype[fn].apply(el, args); } return this; }, /** * Returns a flyweight Element of the dom element object at the specified index * @param {Number} index * @return {CQ.Ext.Element} */ item : function(index){ if(!this.elements[index]){ return null; } this.el.dom = this.elements[index]; return this.el; }, // fixes scope with flyweight addListener : function(eventName, handler, scope, opt){ var els = this.elements; for(var i = 0, len = els.length; i < len; i++) { CQ.Ext.EventManager.on(els[i], eventName, handler, scope || els[i], opt); } return this; }, /** * Calls the passed function passing (el, this, index) for each element in this composite. The element * passed is the flyweight (shared) CQ.Ext.Element instance, so if you require a * a reference to the dom node, use el.dom. * @param {Function} fn The function to call * @param {Object} scope (optional) The this object (defaults to the element) * @return {CompositeElement} this */ each : function(fn, scope){ var els = this.elements; var el = this.el; for(var i = 0, len = els.length; i < len; i++){ el.dom = els[i]; if(fn.call(scope || el, el, this, i) === false){ break; } } return this; }, indexOf : function(el){ return this.elements.indexOf(CQ.Ext.getDom(el)); }, replaceElement : function(el, replacement, domReplace){ var index = typeof el == 'number' ? el : this.indexOf(el); if(index !== -1){ replacement = CQ.Ext.getDom(replacement); if(domReplace){ var d = this.elements[index]; d.parentNode.insertBefore(replacement, d); CQ.Ext.removeNode(d); } this.elements.splice(index, 1, replacement); } return this; } }); CQ.Ext.CompositeElementLite.prototype.on = CQ.Ext.CompositeElementLite.prototype.addListener; if(CQ.Ext.DomQuery){ CQ.Ext.Element.selectorFunction = CQ.Ext.DomQuery.select; } CQ.Ext.Element.select = function(selector, unique, root){ var els; if(typeof selector == "string"){ els = CQ.Ext.Element.selectorFunction(selector, root); }else if(selector.length !== undefined){ els = selector; }else{ throw "Invalid selector"; } if(unique === true){ return new CQ.Ext.CompositeElement(els); }else{ return new CQ.Ext.CompositeElementLite(els); } }; /** * Selects elements based on the passed CSS selector to enable working on them as 1. * @param {String/Array} selector The CSS selector or an array of elements * @param {Boolean} unique (optional) true to create a unique CQ.Ext.Element for each element (defaults to a shared flyweight object) * @param {HTMLElement/String} root (optional) The root element of the query or id of the root * @return {CompositeElementLite/CompositeElement} * @member CQ.Ext * @method select */ CQ.Ext.select = CQ.Ext.Element.select;/* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class CQ.Ext.data.Connection * @extends CQ.Ext.util.Observable *

The class encapsulates a connection to the page's originating domain, allowing requests to be made * either to a configured URL, or to a URL specified at request time.

Requests made by this class are asynchronous, and will return immediately. No data from * the server will be available to the statement immediately following the {@link #request} call. * To process returned data, use a {@link #request-option-success callback} in the request options object, * or an {@link #requestcomplete event listener}.

{@link #request-option-isUpload File uploads} are not performed using normal "Ajax" techniques, that * is they are not performed using XMLHttpRequests. Instead the form is submitted in the standard * manner with the DOM <form> element temporarily modified to have its * target set to refer * to a dynamically generated, hidden <iframe> which is inserted into the document * but removed after the return data has been gathered.

The server response is parsed by the browser to create the document for the IFRAME. If the * server is using JSON to send the return object, then the * Content-Type header * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.

The response text is retrieved from the document, and a fake XMLHttpRequest object * is created containing a responseText property in order to conform to the * requirements of event handlers and callbacks.

Be aware that file upload packets are sent with the content type multipart/form * and some server technologies (notably JEE) may require some custom processing in order to * retrieve parameter names and parameter values from the packet content.

* @constructor * @param {Object} config a configuration object. */ CQ.Ext.data.Connection = function(config){ CQ.Ext.apply(this, config); this.addEvents( /** * @event beforerequest * Fires before a network request is made to retrieve a data object. * @param {Connection} conn This Connection object. * @param {Object} options The options config object passed to the {@link #request} method. */ "beforerequest", /** * @event requestcomplete * Fires if the request was successfully completed. * @param {Connection} conn This Connection object. * @param {Object} response The XHR object containing the response data. * See The XMLHttpRequest Object * for details. * @param {Object} options The options config object passed to the {@link #request} method. */ "requestcomplete", /** * @event requestexception * Fires if an error HTTP status was returned from the server. * See HTTP Status Code Definitions * for details of HTTP status codes. * @param {Connection} conn This Connection object. * @param {Object} response The XHR object containing the response data. * See The XMLHttpRequest Object * for details. * @param {Object} options The options config object passed to the {@link #request} method. */ "requestexception" ); CQ.Ext.data.Connection.superclass.constructor.call(this); }; CQ.Ext.extend(CQ.Ext.data.Connection, CQ.Ext.util.Observable, { /** * @cfg {String} url (Optional) The default URL to be used for requests to the server. (defaults to undefined) */ /** * @cfg {Object} extraParams (Optional) An object containing properties which are used as * extra parameters to each request made by this object. (defaults to undefined) */ /** * @cfg {Object} defaultHeaders (Optional) An object containing request headers which are added * to each request made by this object. (defaults to undefined) */ /** * @cfg {String} method (Optional) The default HTTP method to be used for requests. * (defaults to undefined; if not set, but {@link #request} params are present, POST will be used; * otherwise, GET will be used.) */ /** * @cfg {Number} timeout (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000) */ timeout : 30000, /** * @cfg {Boolean} autoAbort (Optional) Whether this request should abort any pending requests. (defaults to false) * @type Boolean */ autoAbort:false, /** * @cfg {Boolean} disableCaching (Optional) True to add a unique cache-buster param to GET requests. (defaults to true) * @type Boolean */ disableCaching: true, /** * @cfg {String} disableCachingParam (Optional) Change the parameter which is sent went disabling caching * through a cache buster. Defaults to '_dc' * @type String */ disableCachingParam: '_dc', /** *

Sends an HTTP request to a remote server.

Important: Ajax server requests are asynchronous, and this call will * return before the response has been received. Process any returned data * in a callback function.

To execute a callback function in the correct scope, use the scope option.

* @param {Object} options An object which may contain the following properties:

url : String/Function (Optional)
The URL to * which to send the request, or a function to call which returns a URL string. The scope of the * function is specified by the scope option. Defaults to configured URL.
params : Object/String/Function (Optional)
* An object containing properties which are used as parameters to the * request, a url encoded string or a function to call to get either. The scope of the function * is specified by the scope option.
method : String (Optional)
The HTTP method to use * for the request. Defaults to the configured method, or if no method was configured, * "GET" if no parameters are being sent, and "POST" if parameters are being sent. Note that * the method name is case-sensitive and should be all caps.
callback : Function (Optional)
The * function to be called upon receipt of the HTTP response. The callback is * called regardless of success or failure and is passed the following * parameters:
- options : Object
  The parameter to the request call.
- success : Boolean
  True if the request succeeded.
- response : Object
  The XMLHttpRequest object containing the response data. * See http://www.w3.org/TR/XMLHttpRequest/ for details about * accessing elements of the response.

success : Function (Optional)
The function * to be called upon success of the request. The callback is passed the following * parameters:
- response : Object
  The XMLHttpRequest object containing the response data.
- options : Object
  The parameter to the request call.
failure : Function (Optional)
The function * to be called upon failure of the request. The callback is passed the * following parameters:
- response : Object
  The XMLHttpRequest object containing the response data.
- options : Object
  The parameter to the request call.
scope : Object (Optional)
The scope in * which to execute the callbacks: The "this" object for the callback function. If the url, or params options were * specified as functions from which to draw values, then this also serves as the scope for those function calls. * Defaults to the browser window.
form : Element/HTMLElement/String (Optional)
The <form> * Element or the id of the <form> to pull parameters from.

isUpload : Boolean (Optional)
True if the form object is a * file upload (will usually be automatically detected). *
File uploads are not performed using normal "Ajax" techniques, that is they are not * performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the * DOM <form> element temporarily modified to have its * target set to refer * to a dynamically generated, hidden <iframe> which is inserted into the document * but removed after the return data has been gathered.
*
The server response is parsed by the browser to create the document for the IFRAME. If the * server is using JSON to send the return object, then the * Content-Type header * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.
*
The response text is retrieved from the document, and a fake XMLHttpRequest object * is created containing a responseText property in order to conform to the * requirements of event handlers and callbacks.
*
Be aware that file upload packets are sent with the content type multipart/form * and some server technologies (notably JEE) may require some custom processing in order to * retrieve parameter names and parameter values from the packet content.
*
headers : Object (Optional)
Request * headers to set for the request.
xmlData : Object (Optional)
XML document * to use for the post. Note: This will be used instead of params for the post * data. Any params will be appended to the URL.
jsonData : Object/String (Optional)
JSON * data to use as the post. Note: This will be used instead of params for the post * data. Any params will be appended to the URL.
disableCaching : Boolean (Optional)
True * to add a unique cache-buster param to GET requests.

The options object may also contain any other property which might be needed to perform * postprocessing in a callback because it is passed to callback functions.

* @return {Number} transactionId The id of the server transaction. This may be used * to cancel the request. */ request : function(o){ if(this.fireEvent("beforerequest", this, o) !== false){ var p = o.params; if(typeof p == "function"){ p = p.call(o.scope||window, o); } if(typeof p == "object"){ p = CQ.Ext.urlEncode(p); } if(this.extraParams){ var extras = CQ.Ext.urlEncode(this.extraParams); p = p ? (p + '&' + extras) : extras; } var url = o.url || this.url; // CQ:START // externalize the URL url = CQ.Util.externalize(url); // CQ:END if(typeof url == 'function'){ url = url.call(o.scope||window, o); } if(o.form){ var form = CQ.Ext.getDom(o.form); url = url || form.action; var enctype = form.getAttribute("enctype"); if(o.isUpload || (enctype && enctype.toLowerCase() == 'multipart/form-data')){ return this.doFormUpload(o, p, url); } var f = CQ.Ext.lib.Ajax.serializeForm(form); p = p ? (p + '&' + f) : f; } var hs = o.headers; if(this.defaultHeaders){ hs = CQ.Ext.apply(hs || {}, this.defaultHeaders); if(!o.headers){ o.headers = hs; } } var cb = { success: this.handleResponse, failure: this.handleFailure, scope: this, argument: {options: o}, timeout : o.timeout || this.timeout }; var method = o.method||this.method||((p || o.xmlData || o.jsonData) ? "POST" : "GET"); if(method == 'GET' && (this.disableCaching && o.disableCaching !== false) || o.disableCaching === true){ var dcp = o.disableCachingParam || this.disableCachingParam; url += (url.indexOf('?') != -1 ? '&' : '?') + dcp + '=' + (new Date().getTime()); } if(typeof o.autoAbort == 'boolean'){ // options gets top priority if(o.autoAbort){ this.abort(); } }else if(this.autoAbort !== false){ this.abort(); } if((method == 'GET' || o.xmlData || o.jsonData) && p){ url += (url.indexOf('?') != -1 ? '&' : '?') + p; p = ''; } this.transId = CQ.Ext.lib.Ajax.request(method, url, cb, p, o); return this.transId; }else{ CQ.Ext.callback(o.callback, o.scope, [o, null, null]); return null; } }, /** * Determine whether this object has a request outstanding. * @param {Number} transactionId (Optional) defaults to the last transaction * @return {Boolean} True if there is an outstanding request. */ isLoading : function(transId){ if(transId){ return CQ.Ext.lib.Ajax.isCallInProgress(transId); }else{ return this.transId ? true : false; } }, /** * Aborts any outstanding request. * @param {Number} transactionId (Optional) defaults to the last transaction */ abort : function(transId){ if(transId || this.isLoading()){ CQ.Ext.lib.Ajax.abort(transId || this.transId); } }, // private handleResponse : function(response){ this.transId = false; var options = response.argument.options; response.argument = options ? options.argument : null; this.fireEvent("requestcomplete", this, response, options); CQ.Ext.callback(options.success, options.scope, [response, options]); CQ.Ext.callback(options.callback, options.scope, [options, true, response]); }, // private handleFailure : function(response, e){ this.transId = false; var options = response.argument.options; response.argument = options ? options.argument : null; this.fireEvent("requestexception", this, response, options, e); CQ.Ext.callback(options.failure, options.scope, [response, options]); CQ.Ext.callback(options.callback, options.scope, [options, false, response]); }, // private doFormUpload : function(o, ps, url){ var id = CQ.Ext.id(); var frame = document.createElement('iframe'); frame.id = id; frame.name = id; frame.className = 'x-hidden'; if(CQ.Ext.isIE){ frame.src = CQ.Ext.SSL_SECURE_URL; } // CQ:START // render all CQ.Ext elements to the CQ root // document.body.appendChild(frame); CQ.Util.getRoot().dom.appendChild(frame); // CQ:END if(CQ.Ext.isIE){ document.frames[id].name = id; } var form = CQ.Ext.getDom(o.form); form.target = id; form.method = 'POST'; form.enctype = form.encoding = 'multipart/form-data'; if(url){ form.action = url; } var hiddens, hd; if(ps){ // add dynamic params hiddens = []; ps = CQ.Ext.urlDecode(ps, false); for(var k in ps){ if(ps.hasOwnProperty(k)){ hd = document.createElement('input'); hd.type = 'hidden'; hd.name = k; hd.value = ps[k]; form.appendChild(hd); hiddens.push(hd); } } } function cb(){ var r = { // bogus response object responseText : '', responseXML : null }; r.argument = o ? o.argument : null; try { // var doc; if(CQ.Ext.isIE){ doc = frame.contentWindow.document; }else { doc = (frame.contentDocument || window.frames[id].document); } if(doc && doc.body){ r.responseText = doc.body.innerHTML; } if(doc && doc.XMLDocument){ r.responseXML = doc.XMLDocument; }else { r.responseXML = doc; } } catch(e) { // ignore } CQ.Ext.EventManager.removeListener(frame, 'load', cb, this); this.fireEvent("requestcomplete", this, r, o); CQ.Ext.callback(o.success, o.scope, [r, o]); CQ.Ext.callback(o.callback, o.scope, [o, true, r]); setTimeout(function(){CQ.Ext.removeNode(frame);}, 100); } CQ.Ext.EventManager.on(frame, 'load', cb, this); form.submit(); if(hiddens){ // remove dynamic params for(var i = 0, len = hiddens.length; i < len; i++){ CQ.Ext.removeNode(hiddens[i]); } } } }); /** * @class CQ.Ext.Ajax * @extends CQ.Ext.data.Connection * Global Ajax request class. Provides a simple way to make Ajax requests with maximum flexibility. Example usage: *


// Basic request
CQ.Ext.Ajax.request({
   url: 'foo.php',
   success: someFn,
   failure: otherFn,
   headers: {
       'my-header': 'foo'
   },
   params: { foo: 'bar' }
});

// Simple ajax form submission
CQ.Ext.Ajax.request({
    form: 'some-form',
    params: 'foo=bar'
});

// Default headers to pass in every request
CQ.Ext.Ajax.defaultHeaders = {
    'Powered-By': 'CQ.Ext'};

// Global Ajax events can be handled on every request!
CQ.Ext.Ajax.on('beforerequest', this.showSpinner, this);

* @singleton */ CQ.Ext.Ajax = new CQ.Ext.data.Connection({ /** * @cfg {String} url @hide */ /** * @cfg {Object} extraParams @hide */ /** * @cfg {Object} defaultHeaders @hide */ /** * @cfg {String} method (Optional) @hide */ /** * @cfg {Number} timeout (Optional) @hide */ /** * @cfg {Boolean} autoAbort (Optional) @hide */ /** * @cfg {Boolean} disableCaching (Optional) @hide */ /** * @property disableCaching * True to add a unique cache-buster param to GET requests. (defaults to true) * @type Boolean */ /** * @property url * The default URL to be used for requests to the server. (defaults to undefined) * @type String */ /** * @property extraParams * An object containing properties which are used as * extra parameters to each request made by this object. (defaults to undefined) * @type Object */ /** * @property defaultHeaders * An object containing request headers which are added to each request made by this object. (defaults to undefined) * @type Object */ /** * @property method * The default HTTP method to be used for requests. Note that this is case-sensitive and should be all caps (defaults * to undefined; if not set but parms are present will use "POST," otherwise "GET.") * @type String */ /** * @property timeout * The timeout in milliseconds to be used for requests. (defaults to 30000) * @type Number */ /** * @property autoAbort * Whether a new request should abort any pending requests. (defaults to false) * @type Boolean */ autoAbort : false, /** * Serialize the passed form into a url encoded string * @param {String/HTMLElement} form * @return {String} */ serializeForm : function(form){ return CQ.Ext.lib.Ajax.serializeForm(form); } });/* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class CQ.Ext.Updater * @extends CQ.Ext.util.Observable * Provides AJAX-style update capabilities for Element objects. Updater can be used to {@link #update} an Element once, * or you can use {@link #startAutoRefresh} to set up an auto-updating Element on a specific interval.

* Usage:
*


 * // Get it from a CQ.Ext.Element object
 * var el = CQ.Ext.get("foo");
 * var mgr = el.getUpdater();
 * mgr.update({
        url: "http://myserver.com/index.php",
        params: {
            param1: "foo",
            param2: "bar"
        }
 * });
 * ...
 * mgr.formUpdate("myFormId", "http://myserver.com/index.php");
 * 

 * // or directly (returns the same Updater instance)
 * var mgr = new CQ.Ext.Updater("myElementId");
 * mgr.startAutoRefresh(60, "http://myserver.com/index.php");
 * mgr.on("update", myFcnNeedsToKnow);
 * 

 * // short handed call directly from the element object
 * CQ.Ext.get("foo").load({
        url: "bar.php",
        scripts: true,
        params: "param1=foo&param2=bar",
        text: "Loading Foo..."
 * });
 *

* @constructor * Create new Updater directly. * @param {Mixed} el The element to update * @param {Boolean} forceNew (optional) By default the constructor checks to see if the passed element already * has an Updater and if it does it returns the same instance. This will skip that check (useful for extending this class). */ CQ.Ext.Updater = CQ.Ext.extend(CQ.Ext.util.Observable, { constructor: function(el, forceNew){ el = CQ.Ext.get(el); if(!forceNew && el.updateManager){ return el.updateManager; } /** * The Element object * @type CQ.Ext.Element */ this.el = el; /** * Cached url to use for refreshes. Overwritten every time update() is called unless "discardUrl" param is set to true. * @type String */ this.defaultUrl = null; this.addEvents( /** * @event beforeupdate * Fired before an update is made, return false from your handler and the update is cancelled. * @param {CQ.Ext.Element} el * @param {String/Object/Function} url * @param {String/Object} params */ "beforeupdate", /** * @event update * Fired after successful update is made. * @param {CQ.Ext.Element} el * @param {Object} oResponseObject The response Object */ "update", /** * @event failure * Fired on update failure. * @param {CQ.Ext.Element} el * @param {Object} oResponseObject The response Object */ "failure" ); var d = CQ.Ext.Updater.defaults; /** * Blank page URL to use with SSL file uploads (defaults to {@link CQ.Ext.Updater.defaults#sslBlankUrl}). * @type String */ this.sslBlankUrl = d.sslBlankUrl; /** * Whether to append unique parameter on get request to disable caching (defaults to {@link CQ.Ext.Updater.defaults#disableCaching}). * @type Boolean */ this.disableCaching = d.disableCaching; /** * Text for loading indicator (defaults to {@link CQ.Ext.Updater.defaults#indicatorText}). * @type String */ this.indicatorText = d.indicatorText; /** * Whether to show indicatorText when loading (defaults to {@link CQ.Ext.Updater.defaults#showLoadIndicator}). * @type String */ this.showLoadIndicator = d.showLoadIndicator; /** * Timeout for requests or form posts in seconds (defaults to {@link CQ.Ext.Updater.defaults#timeout}). * @type Number */ this.timeout = d.timeout; /** * True to process scripts in the output (defaults to {@link CQ.Ext.Updater.defaults#loadScripts}). * @type Boolean */ this.loadScripts = d.loadScripts; /** * Transaction object of the current executing transaction, or null if there is no active transaction. */ this.transaction = null; /** * Delegate for refresh() prebound to "this", use myUpdater.refreshDelegate.createCallback(arg1, arg2) to bind arguments * @type Function */ this.refreshDelegate = this.refresh.createDelegate(this); /** * Delegate for update() prebound to "this", use myUpdater.updateDelegate.createCallback(arg1, arg2) to bind arguments * @type Function */ this.updateDelegate = this.update.createDelegate(this); /** * Delegate for formUpdate() prebound to "this", use myUpdater.formUpdateDelegate.createCallback(arg1, arg2) to bind arguments * @type Function */ this.formUpdateDelegate = this.formUpdate.createDelegate(this); if(!this.renderer){ /** * The renderer for this Updater (defaults to {@link CQ.Ext.Updater.BasicRenderer}). */ this.renderer = this.getDefaultRenderer(); } CQ.Ext.Updater.superclass.constructor.call(this); }, /** * This is an overrideable method which returns a reference to a default * renderer class if none is specified when creating the CQ.Ext.Updater. * Defaults to {@link CQ.Ext.Updater.BasicRenderer} */ getDefaultRenderer: function() { return new CQ.Ext.Updater.BasicRenderer(); }, /** * Get the Element this Updater is bound to * @return {CQ.Ext.Element} The element */ getEl : function(){ return this.el; }, /** * Performs an asynchronous request, updating this element with the response. * If params are specified it uses POST, otherwise it uses GET.

* Note: Due to the asynchronous nature of remote server requests, the Element * will not have been fully updated when the function returns. To post-process the returned * data, use the callback option, or an update event handler. * @param {Object} options A config object containing any of the following options:

url : String/Function
The URL to request or a function which * returns the URL (defaults to the value of {@link CQ.Ext.Ajax#url} if not specified).
method : String
The HTTP method to * use. Defaults to POST if the params argument is present, otherwise GET.
params : String/Object/Function
The * parameters to pass to the server (defaults to none). These may be specified as a url-encoded * string, or as an object containing properties which represent parameters, * or as a function, which returns such an object.
scripts : Boolean
If true * any <script> tags embedded in the response text will be extracted * and executed (defaults to {@link CQ.Ext.Updater.defaults#loadScripts}). If this option is specified, * the callback will be called after the execution of the scripts.
callback : Function
A function to * be called when the response from the server arrives. The following * parameters are passed:
- el : CQ.Ext.Element
  The Element being updated.
- success : Boolean
  True for success, false for failure.
- response : XMLHttpRequest
  The XMLHttpRequest which processed the update.
- options : Object
  The config object passed to the update call.
*
scope : Object
The scope in which * to execute the callback (The callback's this reference.) If the * params argument is a function, this scope is used for that function also.
discardUrl : Boolean
By default, the URL of this request becomes * the default URL for this Updater object, and will be subsequently used in {@link #refresh} * calls. To bypass this behavior, pass discardUrl:true (defaults to false).
timeout : Number
The number of seconds to wait for a response before * timing out (defaults to {@link CQ.Ext.Updater.defaults#timeout}).
text : String
The text to use as the innerHTML of the * {@link CQ.Ext.Updater.defaults#indicatorText} div (defaults to 'Loading...'). To replace the entire div, not * just the text, override {@link CQ.Ext.Updater.defaults#indicatorText} directly.
nocache : Boolean
Only needed for GET * requests, this option causes an extra, auto-generated parameter to be appended to the request * to defeat caching (defaults to {@link CQ.Ext.Updater.defaults#disableCaching}).

* For example:


um.update({
    url: "your-url.php",
    params: {param1: "foo", param2: "bar"}, // or a URL encoded string
    callback: yourFunction,
    scope: yourObject, //(optional scope)
    discardUrl: true,
    nocache: true,
    text: "Loading...",
    timeout: 60,
    scripts: false // Save time by avoiding RegExp execution.
});

*/ update : function(url, params, callback, discardUrl){ if(this.fireEvent("beforeupdate", this.el, url, params) !== false){ var cfg, callerScope; if(typeof url == "object"){ // must be config object cfg = url; url = cfg.url; params = params || cfg.params; callback = callback || cfg.callback; discardUrl = discardUrl || cfg.discardUrl; callerScope = cfg.scope; if(typeof cfg.nocache != "undefined"){this.disableCaching = cfg.nocache;}; if(typeof cfg.text != "undefined"){this.indicatorText = '

'+cfg.text+"

";}; if(typeof cfg.scripts != "undefined"){this.loadScripts = cfg.scripts;}; if(typeof cfg.timeout != "undefined"){this.timeout = cfg.timeout;}; } this.showLoading(); if(!discardUrl){ this.defaultUrl = url; } if(typeof url == "function"){ url = url.call(this); } var o = CQ.Ext.apply({}, { url : url, params: (typeof params == "function" && callerScope) ? params.createDelegate(callerScope) : params, success: this.processSuccess, failure: this.processFailure, scope: this, callback: undefined, timeout: (this.timeout*1000), disableCaching: this.disableCaching, argument: { "options": cfg, "url": url, "form": null, "callback": callback, "scope": callerScope || window, "params": params } }, cfg); this.transaction = CQ.Ext.Ajax.request(o); } }, /** * Performs an async form post, updating this element with the response. If the form has the attribute * enctype="multipart/form-data", it assumes it's a file upload. * Uses this.sslBlankUrl for SSL file uploads to prevent IE security warning. * @param {String/HTMLElement} form The form Id or form element * @param {String} url (optional) The url to pass the form to. If omitted the action attribute on the form will be used. * @param {Boolean} reset (optional) Whether to try to reset the form after the update * @param {Function} callback (optional) Callback when transaction is complete. The following * parameters are passed:

el : CQ.Ext.Element
The Element being updated.
success : Boolean
True for success, false for failure.
response : XMLHttpRequest
The XMLHttpRequest which processed the update.

*/ formUpdate : function(form, url, reset, callback){ if(this.fireEvent("beforeupdate", this.el, form, url) !== false){ if(typeof url == "function"){ url = url.call(this); } form = CQ.Ext.getDom(form) this.transaction = CQ.Ext.Ajax.request({ form: form, url:url, success: this.processSuccess, failure: this.processFailure, scope: this, timeout: (this.timeout*1000), argument: { "url": url, "form": form, "callback": callback, "reset": reset } }); this.showLoading.defer(1, this); } }, /** * Refresh the element with the last used url or defaultUrl. If there is no url, it returns immediately * @param {Function} callback (optional) Callback when transaction is complete - called with signature (oElement, bSuccess) */ refresh : function(callback){ if(this.defaultUrl == null){ return; } this.update(this.defaultUrl, null, callback, true); }, /** * Set this element to auto refresh. Can be canceled by calling {@link #stopAutoRefresh}. * @param {Number} interval How often to update (in seconds). * @param {String/Object/Function} url (optional) The url for this request, a config object in the same format * supported by {@link #load}, or a function to call to get the url (defaults to the last used url). Note that while * the url used in a load call can be reused by this method, other load config options will not be reused and must be * sepcified as part of a config object passed as this paramter if needed. * @param {String/Object} params (optional) The parameters to pass as either a url encoded string * "¶m1=1¶m2=2" or as an object {param1: 1, param2: 2} * @param {Function} callback (optional) Callback when transaction is complete - called with signature (oElement, bSuccess) * @param {Boolean} refreshNow (optional) Whether to execute the refresh now, or wait the interval */ startAutoRefresh : function(interval, url, params, callback, refreshNow){ if(refreshNow){ this.update(url || this.defaultUrl, params, callback, true); } if(this.autoRefreshProcId){ clearInterval(this.autoRefreshProcId); } this.autoRefreshProcId = setInterval(this.update.createDelegate(this, [url || this.defaultUrl, params, callback, true]), interval*1000); }, /** * Stop auto refresh on this element. */ stopAutoRefresh : function(){ if(this.autoRefreshProcId){ clearInterval(this.autoRefreshProcId); delete this.autoRefreshProcId; } }, /** * Returns true if the Updater is currently set to auto refresh its content (see {@link #startAutoRefresh}), otherwise false. */ isAutoRefreshing : function(){ return this.autoRefreshProcId ? true : false; }, /** * Display the element's "loading" state. By default, the element is updated with {@link #indicatorText}. This * method may be overridden to perform a custom action while this Updater is actively updating its contents. */ showLoading : function(){ if(this.showLoadIndicator){ this.el.update(this.indicatorText); } }, // private processSuccess : function(response){ this.transaction = null; if(response.argument.form && response.argument.reset){ try{ // put in try/catch since some older FF releases had problems with this response.argument.form.reset(); }catch(e){} } if(this.loadScripts){ this.renderer.render(this.el, response, this, this.updateComplete.createDelegate(this, [response])); }else{ this.renderer.render(this.el, response, this); this.updateComplete(response); } }, // private updateComplete : function(response){ this.fireEvent("update", this.el, response); if(typeof response.argument.callback == "function"){ response.argument.callback.call(response.argument.scope, this.el, true, response, response.argument.options); } }, // private processFailure : function(response){ this.transaction = null; this.fireEvent("failure", this.el, response); if(typeof response.argument.callback == "function"){ response.argument.callback.call(response.argument.scope, this.el, false, response, response.argument.options); } }, /** * Sets the content renderer for this Updater. See {@link CQ.Ext.Updater.BasicRenderer#render} for more details. * @param {Object} renderer The object implementing the render() method */ setRenderer : function(renderer){ this.renderer = renderer; }, /** * Returns the content renderer for this Updater. See {@link CQ.Ext.Updater.BasicRenderer#render} for more details. * @return {Object} */ getRenderer : function(){ return this.renderer; }, /** * Sets the default URL used for updates. * @param {String/Function} defaultUrl The url or a function to call to get the url */ setDefaultUrl : function(defaultUrl){ this.defaultUrl = defaultUrl; }, /** * Aborts the currently executing transaction, if any. */ abort : function(){ if(this.transaction){ CQ.Ext.Ajax.abort(this.transaction); } }, /** * Returns true if an update is in progress, otherwise false. * @return {Boolean} */ isUpdating : function(){ if(this.transaction){ return CQ.Ext.Ajax.isLoading(this.transaction); } return false; } }); /** * @class CQ.Ext.Updater.defaults * The defaults collection enables customizing the default properties of Updater */ CQ.Ext.Updater.defaults = { /** * Timeout for requests or form posts in seconds (defaults to 30 seconds). * @type Number */ timeout : 30, /** * True to process scripts by default (defaults to false). * @type Boolean */ loadScripts : false, /** * Blank page URL to use with SSL file uploads (defaults to {@link Ext#SSL_SECURE_URL} if set, or "javascript:false"). * @type String */ sslBlankUrl : (CQ.Ext.SSL_SECURE_URL || "javascript:false"), /** * True to append a unique parameter to GET requests to disable caching (defaults to false). * @type Boolean */ disableCaching : false, /** * Whether or not to show {@link #indicatorText} during loading (defaults to true). * @type Boolean */ showLoadIndicator : true, /** * Text for loading indicator (defaults to '<div class="loading-indicator">Loading...</div>'). * @type String */ indicatorText : '

' }; /** * Static convenience method. This method is deprecated in favor of el.load({url:'foo.php', ...}). * Usage: *

CQ.Ext.Updater.updateElement("my-div", "stuff.php");

* @param {Mixed} el The element to update * @param {String} url The url * @param {String/Object} params (optional) Url encoded param string or an object of name/value pairs * @param {Object} options (optional) A config object with any of the Updater properties you want to set - for * example: {disableCaching:true, indicatorText: "Loading data..."} * @static * @deprecated * @member CQ.Ext.Updater */ CQ.Ext.Updater.updateElement = function(el, url, params, options){ var um = CQ.Ext.get(el).getUpdater(); CQ.Ext.apply(um, options); um.update(url, params, options ? options.callback : null); }; /** * @class CQ.Ext.Updater.BasicRenderer * Default Content renderer. Updates the elements innerHTML with the responseText. */ CQ.Ext.Updater.BasicRenderer = function(){}; CQ.Ext.Updater.BasicRenderer.prototype = { /** * This is called when the transaction is completed and it's time to update the element - The BasicRenderer * updates the elements innerHTML with the responseText - To perform a custom render (i.e. XML or JSON processing), * create an object with a "render(el, response)" method and pass it to setRenderer on the Updater. * @param {CQ.Ext.Element} el The element being rendered * @param {Object} response The XMLHttpRequest object * @param {Updater} updateManager The calling update manager * @param {Function} callback A callback that will need to be called if loadScripts is true on the Updater */ render : function(el, response, updateManager, callback){ el.update(response.responseText, updateManager.loadScripts, callback); } }; CQ.Ext.UpdateManager = CQ.Ext.Updater; /* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class Date * * The date parsing and format syntax is a subset of * PHP's date() function, and the formats that are * supported will provide results equivalent to their PHP versions. * * The following is a list of all currently supported formats: *

Format  Description                                                               Example returned values
------  -----------------------------------------------------------------------   -----------------------
  d     Day of the month, 2 digits with leading zeros                             01 to 31
  D     A short textual representation of the day of the week                     Mon to Sun
  j     Day of the month without leading zeros                                    1 to 31
  l     A full textual representation of the day of the week                      Sunday to Saturday
  N     ISO-8601 numeric representation of the day of the week                    1 (for Monday) through 7 (for Sunday)
  S     English ordinal suffix for the day of the month, 2 characters             st, nd, rd or th. Works well with j
  w     Numeric representation of the day of the week                             0 (for Sunday) to 6 (for Saturday)
  z     The day of the year (starting from 0)                                     0 to 364 (365 in leap years)
  W     ISO-8601 week number of year, weeks starting on Monday                    01 to 53
  F     A full textual representation of a month, such as January or March        January to December
  m     Numeric representation of a month, with leading zeros                     01 to 12
  M     A short textual representation of a month                                 Jan to Dec
  n     Numeric representation of a month, without leading zeros                  1 to 12
  t     Number of days in the given month                                         28 to 31
  L     Whether it's a leap year                                                  1 if it is a leap year, 0 otherwise.
  o     ISO-8601 year number (identical to (Y), but if the ISO week number (W)    Examples: 1998 or 2004
        belongs to the previous or next year, that year is used instead)
  Y     A full numeric representation of a year, 4 digits                         Examples: 1999 or 2003
  y     A two digit representation of a year                                      Examples: 99 or 03
  a     Lowercase Ante meridiem and Post meridiem                                 am or pm
  A     Uppercase Ante meridiem and Post meridiem                                 AM or PM
  g     12-hour format of an hour without leading zeros                           1 to 12
  G     24-hour format of an hour without leading zeros                           0 to 23
  h     12-hour format of an hour with leading zeros                              01 to 12
  H     24-hour format of an hour with leading zeros                              00 to 23
  i     Minutes, with leading zeros                                               00 to 59
  s     Seconds, with leading zeros                                               00 to 59
  u     Milliseconds, with leading zeroes (arbitrary number of digits allowed)    Examples:
                                                                                  001 (i.e. 1ms) or
                                                                                  100 (i.e. 100ms) or
                                                                                  999 (i.e. 999ms) or
                                                                                  999876543210 (i.e. 999.876543210ms)
  O     Difference to Greenwich time (GMT) in hours and minutes                   Example: +1030
  P     Difference to Greenwich time (GMT) with colon between hours and minutes   Example: -08:00
  T     Timezone abbreviation of the machine running the code                     Examples: EST, MDT, PDT ...
  Z     Timezone offset in seconds (negative if west of UTC, positive if east)    -43200 to 50400
  c     ISO 8601 date (note: milliseconds, if present, must be specified with     Examples:
        at least 1 digit. There is no limit to how many digits the millisecond    2007-04-17T15:19:21+08:00 or
        value may contain. see http://www.w3.org/TR/NOTE-datetime for more info)  2008-03-16T16:18:22Z or
                                                                                  2009-02-15T17:17:23.9+01:00 or
                                                                                  2010-01-14T18:16:24,999876543-07:00
  U     Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)                1193432466 or -2138434463

* * Example usage (note that you must escape format specifiers with '\\' to render them as character literals): *


// Sample date:
// 'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'

var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
document.write(dt.format('Y-m-d'));                           // 2007-01-10
document.write(dt.format('F j, Y, g:i a'));                   // January 10, 2007, 3:05 pm
document.write(dt.format('l, \\t\\he jS \\of F Y h:i:s A'));  // Wednesday, the 10th of January 2007 03:05:01 PM

* * Here are some standard date/time patterns that you might find helpful. They * are not part of the source of Date.js, but to use them you can simply copy this * block of code into any script that is included after Date.js and they will also become * globally available on the Date object. Feel free to add or remove patterns as needed in your code. *


Date.patterns = {
    ISO8601Long:"Y-m-d H:i:s",
    ISO8601Short:"Y-m-d",
    ShortDate: "n/j/Y",
    LongDate: "l, F d, Y",
    FullDateTime: "l, F d, Y g:i:s A",
    MonthDay: "F d",
    ShortTime: "g:i A",
    LongTime: "g:i:s A",
    SortableDateTime: "Y-m-d\\TH:i:s",
    UniversalSortableDateTime: "Y-m-d H:i:sO",
    YearMonth: "F, Y"
};

* * Example usage: *


var dt = new Date();
document.write(dt.format(Date.patterns.ShortDate));

*/ /* * Most of the date-formatting functions below are the excellent work of Baron Schwartz. * (see http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/) * They generate precompiled functions from format patterns instead of parsing and * processing each pattern every time a date is formatted. These functions are available * on every Date object. */ (function() { // private Date.formatCodeToRegex = function(character, currentGroup) { // Note: currentGroup - position in regex result array (see notes for Date.parseCodes below) var p = Date.parseCodes[character]; if (p) { p = CQ.Ext.type(p) == 'function'? p() : p; Date.parseCodes[character] = p; // reassign function result to prevent repeated execution } return p? CQ.Ext.applyIf({ c: p.c? String.format(p.c, currentGroup || "{0}") : p.c }, p) : { g:0, c:null, s:CQ.Ext.escapeRe(character) // treat unrecognised characters as literals } } // private shorthand for Date.formatCodeToRegex since we'll be using it fairly often var $f = Date.formatCodeToRegex; CQ.Ext.apply(Date, { // private parseFunctions: {count:0}, parseRegexes: [], formatFunctions: {count:0}, daysInMonth : [31,28,31,30,31,30,31,31,30,31,30,31], y2kYear : 50, /** * Date interval constant * @static * @type String */ MILLI : "ms", /** * Date interval constant * @static * @type String */ SECOND : "s", /** * Date interval constant * @static * @type String */ MINUTE : "mi", /** Date interval constant * @static * @type String */ HOUR : "h", /** * Date interval constant * @static * @type String */ DAY : "d", /** * Date interval constant * @static * @type String */ MONTH : "mo", /** * Date interval constant * @static * @type String */ YEAR : "y", /** * An array of textual day names. * Override these values for international dates. * Example: *


    Date.dayNames = [
      'SundayInYourLang',
      'MondayInYourLang',
      ...
    ];

* @type Array * @static */ dayNames : [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ], /** * An array of textual month names. * Override these values for international dates. * Example: *


    Date.monthNames = [
      'JanInYourLang',
      'FebInYourLang',
      ...
    ];

* @type Array * @static */ monthNames : [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ], /** * An object hash of zero-based javascript month numbers (with short month names as keys. note: keys are case-sensitive). * Override these values for international dates. * Example: *


    Date.monthNumbers = {
      'ShortJanNameInYourLang':0,
      'ShortFebNameInYourLang':1,
      ...
    };

* @type Object * @static */ monthNumbers : { Jan:0, Feb:1, Mar:2, Apr:3, May:4, Jun:5, Jul:6, Aug:7, Sep:8, Oct:9, Nov:10, Dec:11 }, /** * Get the short month name for the given month number. * Override this function for international dates. * @param {Number} month A zero-based javascript month number. * @return {String} The short month name. * @static */ getShortMonthName : function(month) { return Date.monthNames[month].substring(0, 3); }, /** * Get the short day name for the given day number. * Override this function for international dates. * @param {Number} day A zero-based javascript day number. * @return {String} The short day name. * @static */ getShortDayName : function(day) { return Date.dayNames[day].substring(0, 3); }, /** * Get the zero-based javascript month number for the given short/full month name. * Override this function for international dates. * @param {String} name The short/full month name. * @return {Number} The zero-based javascript month number. * @static */ getMonthNumber : function(name) { // handle camel casing for english month names (since the keys for the Date.monthNumbers hash are case sensitive) return Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()]; }, /** * The base format-code to formatting-function hashmap used by the {@link #format} method. * Formatting functions are strings (or functions which return strings) which * will return the appropriate value when evaluated in the context of the Date object * from which the {@link #format} method is called. * Add to / override these mappings for custom date formatting. * Note: Date.format() treats characters as literals if an appropriate mapping cannot be found. * Example:


    Date.formatCodes.x = "String.leftPad(this.getDate(), 2, '0')";
    (new Date()).format("X"); // returns the current day of the month

* @type Object * @static */ formatCodes : { d: "String.leftPad(this.getDate(), 2, '0')", D: "Date.getShortDayName(this.getDay())", // get localised short day name j: "this.getDate()", l: "Date.dayNames[this.getDay()]", N: "(this.getDay() ? this.getDay() : 7)", S: "this.getSuffix()", w: "this.getDay()", z: "this.getDayOfYear()", W: "String.leftPad(this.getWeekOfYear(), 2, '0')", F: "Date.monthNames[this.getMonth()]", m: "String.leftPad(this.getMonth() + 1, 2, '0')", M: "Date.getShortMonthName(this.getMonth())", // get localised short month name n: "(this.getMonth() + 1)", t: "this.getDaysInMonth()", L: "(this.isLeapYear() ? 1 : 0)", o: "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))", Y: "this.getFullYear()", y: "('' + this.getFullYear()).substring(2, 4)", a: "(this.getHours() < 12 ? 'am' : 'pm')", A: "(this.getHours() < 12 ? 'AM' : 'PM')", g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)", G: "this.getHours()", h: "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')", H: "String.leftPad(this.getHours(), 2, '0')", i: "String.leftPad(this.getMinutes(), 2, '0')", s: "String.leftPad(this.getSeconds(), 2, '0')", u: "String.leftPad(this.getMilliseconds(), 3, '0')", O: "this.getGMTOffset()", P: "this.getGMTOffset(true)", T: "this.getTimezone()", Z: "(this.getTimezoneOffset() * -60)", c: function() { // ISO-8601 -- GMT format for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) { var e = c.charAt(i); code.push(e == "T" ? "'T'" : Date.getFormatCode(e)); // treat T as a character literal } return code.join(" + "); }, /* c: function() { // ISO-8601 -- UTC format return [ "this.getUTCFullYear()", "'-'", "String.leftPad(this.getUTCMonth() + 1, 2, '0')", "'-'", "String.leftPad(this.getUTCDate(), 2, '0')", "'T'", "String.leftPad(this.getUTCHours(), 2, '0')", "':'", "String.leftPad(this.getUTCMinutes(), 2, '0')", "':'", "String.leftPad(this.getUTCSeconds(), 2, '0')", "'Z'" ].join(" + "); }, */ U: "Math.round(this.getTime() / 1000)" }, /** * Parses the passed string using the specified format. Note that this function expects dates in normal calendar * format, meaning that months are 1-based (1 = January) and not zero-based like in JavaScript dates. Any part of * the date format that is not specified will default to the current date value for that part. Time parts can also * be specified, but default to 0. Keep in mind that the input date string must precisely match the specified format * string or the parse operation will fail. * Example Usage: *


    //dt = Fri May 25 2007 (current date)
    var dt = new Date();

    //dt = Thu May 25 2006 (today's month/day in 2006)
    dt = Date.parseDate("2006", "Y");

    //dt = Sun Jan 15 2006 (all date parts specified)
    dt = Date.parseDate("2006-01-15", "Y-m-d");

    //dt = Sun Jan 15 2006 15:20:01 GMT-0600 (CST)
    dt = Date.parseDate("2006-01-15 3:20:01 PM", "Y-m-d h:i:s A" );

* @param {String} input The unparsed date as a string. * @param {String} format The format the date is in. * @return {Date} The parsed date. * @static */ parseDate : function(input, format) { var p = Date.parseFunctions; if (p[format] == null) { Date.createParser(format); } var func = p[format]; return Date[func](input); }, // private getFormatCode : function(character) { var f = Date.formatCodes[character]; if (f) { f = CQ.Ext.type(f) == 'function'? f() : f; Date.formatCodes[character] = f; // reassign function result to prevent repeated execution } // note: unknown characters are treated as literals return f || ("'" + String.escape(character) + "'"); }, // private createNewFormat : function(format) { var funcName = "format" + Date.formatFunctions.count++; Date.formatFunctions[format] = funcName; var code = "Date.prototype." + funcName + " = function(){return "; var special = false; var ch = ''; for (var i = 0; i < format.length; ++i) { ch = format.charAt(i); if (!special && ch == "\\") { special = true; } else if (special) { special = false; code += "'" + String.escape(ch) + "' + "; } else { code += Date.getFormatCode(ch) + " + "; } } eval(code.substring(0, code.length - 3) + ";}"); }, // private createParser : function(format) { var funcName = "parse" + Date.parseFunctions.count++; var regexNum = Date.parseRegexes.length; var currentGroup = 1; Date.parseFunctions[format] = funcName; var code = "Date." + funcName + " = function(input){\n" + "var y, m, d, h = 0, i = 0, s = 0, ms = 0, o, z, u, v;\n" + "input = String(input);\n" + "d = new Date();\n" + "y = d.getFullYear();\n" + "m = d.getMonth();\n" + "d = d.getDate();\n" + "var results = input.match(Date.parseRegexes[" + regexNum + "]);\n" + "if (results && results.length > 0) {"; var regex = ""; var special = false; var ch = ''; for (var i = 0; i < format.length; ++i) { ch = format.charAt(i); if (!special && ch == "\\") { special = true; } else if (special) { special = false; regex += String.escape(ch); } else { var obj = Date.formatCodeToRegex(ch, currentGroup); currentGroup += obj.g; regex += obj.s; if (obj.g && obj.c) { code += obj.c; } } } code += "if (u){\n" + "v = new Date(u * 1000);\n" // give top priority to UNIX time + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0 && ms >= 0){\n" + "v = new Date(y, m, d, h, i, s, ms);\n" + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0){\n" + "v = new Date(y, m, d, h, i, s);\n" + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0){\n" + "v = new Date(y, m, d, h, i);\n" + "}else if (y >= 0 && m >= 0 && d > 0 && h >= 0){\n" + "v = new Date(y, m, d, h);\n" + "}else if (y >= 0 && m >= 0 && d > 0){\n" + "v = new Date(y, m, d);\n" + "}else if (y >= 0 && m >= 0){\n" + "v = new Date(y, m);\n" + "}else if (y >= 0){\n" + "v = new Date(y);\n" + "}\n}\nreturn (v && (z || o))?" // favour UTC offset over GMT offset + " (CQ.Ext.type(z) == 'number' ? v.add(Date.SECOND, -v.getTimezoneOffset() * 60 - z) :" // reset to UTC, then add offset + " v.add(Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn))) : v;\n" // reset to GMT, then add offset + "}"; Date.parseRegexes[regexNum] = new RegExp("^" + regex + "$", "i"); eval(code); }, // private parseCodes : { /* * Notes: * g = {Number} calculation group (0 or 1. only group 1 contributes to date calculations.) * c = {String} calculation method (required for group 1. null for group 0. {0} = currentGroup - position in regex result array) * s = {String} regex pattern. all matches are stored in results[], and are accessible by the calculation mapped to 'c' */ d: { g:1, c:"d = parseInt(results[{0}], 10);\n", s:"(\\d{2})" // day of month with leading zeroes (01 - 31) }, j: { g:1, c:"d = parseInt(results[{0}], 10);\n", s:"(\\d{1,2})" // day of month without leading zeroes (1 - 31) }, D: function() { for (var a = [], i = 0; i < 7; a.push(Date.getShortDayName(i)), ++i); // get localised short day names return { g:0, c:null, s:"(?:" + a.join("|") +")" } }, l: function() { return { g:0, c:null, s:"(?:" + Date.dayNames.join("|") + ")" } }, N: { g:0, c:null, s:"[1-7]" // ISO-8601 day number (1 (monday) - 7 (sunday)) }, S: { g:0, c:null, s:"(?:st|nd|rd|th)" }, w: { g:0, c:null, s:"[0-6]" // javascript day number (0 (sunday) - 6 (saturday)) }, z: { g:0, c:null, s:"(?:\\d{1,3}" // day of the year (0 - 364 (365 in leap years)) }, W: { g:0, c:null, s:"(?:\\d{2})" // ISO-8601 week number (with leading zero) }, F: function() { return { g:1, c:"m = parseInt(Date.getMonthNumber(results[{0}]), 10);\n", // get localised month number s:"(" + Date.monthNames.join("|") + ")" } }, M: function() { for (var a = [], i = 0; i < 12; a.push(Date.getShortMonthName(i)), ++i); // get localised short month names return CQ.Ext.applyIf({ s:"(" + a.join("|") + ")" }, $f("F")); }, m: { g:1, c:"m = parseInt(results[{0}], 10) - 1;\n", s:"(\\d{2})" // month number with leading zeros (01 - 12) }, n: { g:1, c:"m = parseInt(results[{0}], 10) - 1;\n", s:"(\\d{1,2})" // month number without leading zeros (1 - 12) }, t: { g:0, c:null, s:"(?:\\d{2})" // no. of days in the month (28 - 31) }, L: { g:0, c:null, s:"(?:1|0)" }, o: function() { return $f("Y"); }, Y: { g:1, c:"y = parseInt(results[{0}], 10);\n", s:"(\\d{4})" // 4-digit year }, y: { g:1, c:"var ty = parseInt(results[{0}], 10);\n" + "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n", // 2-digit year s:"(\\d{1,2})" }, a: { g:1, c:"if (results[{0}] == 'am') {\n" + "if (h == 12) { h = 0; }\n" + "} else { if (h < 12) { h += 12; }}", s:"(am|pm)" }, A: { g:1, c:"if (results[{0}] == 'AM') {\n" + "if (h == 12) { h = 0; }\n" + "} else { if (h < 12) { h += 12; }}", s:"(AM|PM)" }, g: function() { return $f("G"); }, G: { g:1, c:"h = parseInt(results[{0}], 10);\n", s:"(\\d{1,2})" // 24-hr format of an hour without leading zeroes (0 - 23) }, h: function() { return $f("H"); }, H: { g:1, c:"h = parseInt(results[{0}], 10);\n", s:"(\\d{2})" // 24-hr format of an hour with leading zeroes (00 - 23) }, i: { g:1, c:"i = parseInt(results[{0}], 10);\n", s:"(\\d{2})" // minutes with leading zeros (00 - 59) }, s: { g:1, c:"s = parseInt(results[{0}], 10);\n", s:"(\\d{2})" // seconds with leading zeros (00 - 59) }, u: { g:1, c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n", s:"(\\d+)" // milliseconds with leading zeroes (arbitrary number of digits allowed) e.g. 001, 100, 999, 999876543210 }, O: { g:1, c:[ "o = results[{0}];", "var sn = o.substring(0,1);", // get + / - sign "var hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60);", // get hours (performs minutes-to-hour conversion also, just in case) "var mn = o.substring(3,5) % 60;", // get minutes "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs ].join("\n"), s: "([+\-]\\d{4})" // GMT offset in hrs and mins }, P: { g:1, c:[ "o = results[{0}];", "var sn = o.substring(0,1);", // get + / - sign "var hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60);", // get hours (performs minutes-to-hour conversion also, just in case) "var mn = o.substring(4,6) % 60;", // get minutes "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + String.leftPad(hr, 2, '0') + String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs ].join("\n"), s: "([+\-]\\d{2}:\\d{2})" // GMT offset in hrs and mins (with colon separator) }, T: { g:0, c:null, s:"[A-Z]{1,4}" // timezone abbrev. may be between 1 - 4 chars }, Z: { g:1, c:"z = results[{0}] * 1;\n" // -43200 <= UTC offset <= 50400 + "z = (-43200 <= z && z <= 50400)? z : null;\n", s:"([+\-]?\\d{1,5})" // leading '+' sign is optional for UTC offset }, c: function() { var calc = []; var arr = [ $f("Y", 1), // year $f("m", 2), // month $f("d", 3), // day $f("h", 4), // hour $f("i", 5), // minute $f("s", 6), // second {c:"ms = (results[7] || '.0').substring(1); ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"}, // millisecond decimal fraction (with leading zeroes + arbitrary no. of digits) {c:"if(results[9] == 'Z'){\no = 0;\n}else{\n" + $f("P", 9).c + "\n}"} // allow both "Z" (i.e. UTC) and "+08:00" (i.e. GMT) time zone delimiters ]; for (var i = 0, l = arr.length; i < l; ++i) { calc.push(arr[i].c); } return { g:1, c:calc.join(""), s:arr[0].s + "-" + arr[1].s + "-" + arr[2].s + "T" + arr[3].s + ":" + arr[4].s + ":" + arr[5].s + "((\.|,)\\d+)?" // ",998465" or ".998465" millisecond decimal fraction + "(" + $f("P", null).s + "|Z)" // "Z" (UTC) or "GMT+08:00" (GMT offset) } }, U: { g:1, c:"u = parseInt(results[{0}], 10);\n", s:"(-?\\d+)" // leading minus sign indicates seconds before UNIX epoch } } }); }()); CQ.Ext.override(Date, { // private dateFormat : function(format) { if (Date.formatFunctions[format] == null) { Date.createNewFormat(format); } var func = Date.formatFunctions[format]; return this[func](); }, /** * Get the timezone abbreviation of the current date (equivalent to the format specifier 'T'). * * Note: The date string returned by the javascript Date object's toString() method varies * between browsers (e.g. FF vs IE) and system region settings (e.g. IE in Asia vs IE in America). * For a given date string e.g. "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)", * getTimezone() first tries to get the timezone abbreviation from between a pair of parentheses * (which may or may not be present), failing which it proceeds to get the timezone abbreviation * from the GMT offset portion of the date string. * @return {String} The abbreviated timezone name (e.g. 'CST', 'PDT', 'EDT', 'MPST' ...). */ getTimezone : function() { // the following list shows the differences between date strings from different browsers on a WinXP SP2 machine from an Asian locale: // // Opera : "Thu, 25 Oct 2007 22:53:45 GMT+0800" -- shortest (weirdest) date string of the lot // Safari : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone (same as FF) // FF : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone // IE : "Thu Oct 25 22:54:35 UTC+0800 2007" -- (Asian system setting) look for 3-4 letter timezone abbrev // IE : "Thu Oct 25 17:06:37 PDT 2007" -- (American system setting) look for 3-4 letter timezone abbrev // // this crazy regex attempts to guess the correct timezone abbreviation despite these differences. // step 1: (?:$(.*)$ -- find timezone in parentheses // step 2: ([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?) -- if nothing was found in step 1, find timezone from timezone offset portion of date string // step 3: remove all non uppercase characters found in step 1 and 2 return this.toString().replace(/^.* (?:$(.*)$|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, ""); }, /** * Get the offset from GMT of the current date (equivalent to the format specifier 'O'). * @param {Boolean} colon true to separate the hours and minutes with a colon (defaults to false). * @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600'). */ getGMTOffset : function(colon) { return (this.getTimezoneOffset() > 0 ? "-" : "+") + String.leftPad(Math.abs(Math.floor(this.getTimezoneOffset() / 60)), 2, "0") + (colon ? ":" : "") + String.leftPad(Math.abs(this.getTimezoneOffset() % 60), 2, "0"); }, /** * Get the numeric day number of the year, adjusted for leap year. * @return {Number} 0 to 364 (365 in leap years). */ getDayOfYear : function() { var num = 0; Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28; for (var i = 0; i < this.getMonth(); ++i) { num += Date.daysInMonth[i]; } return num + this.getDate() - 1; }, /** * Get the numeric ISO-8601 week number of the year. * (equivalent to the format specifier 'W', but without a leading zero). * @return {Number} 1 to 53 */ getWeekOfYear : function() { // adapted from http://www.merlyn.demon.co.uk/weekcalc.htm var ms1d = 864e5; // milliseconds in a day var ms7d = 7 * ms1d; // milliseconds in a week var DC3 = Date.UTC(this.getFullYear(), this.getMonth(), this.getDate() + 3) / ms1d; // an Absolute Day Number var AWN = Math.floor(DC3 / 7); // an Absolute Week Number var Wyr = new Date(AWN * ms7d).getUTCFullYear(); return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1; }, /** * Whether or not the current date is in a leap year. * @return {Boolean} True if the current date is in a leap year, else false. */ isLeapYear : function() { var year = this.getFullYear(); return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year))); }, /** * Get the first day of the current month, adjusted for leap year. The returned value * is the numeric day index within the week (0-6) which can be used in conjunction with * the {@link #monthNames} array to retrieve the textual day name. * Example: *


    var dt = new Date('1/10/2007');
    document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: 'Monday'

* @return {Number} The day number (0-6). */ getFirstDayOfMonth : function() { var day = (this.getDay() - (this.getDate() - 1)) % 7; return (day < 0) ? (day + 7) : day; }, /** * Get the last day of the current month, adjusted for leap year. The returned value * is the numeric day index within the week (0-6) which can be used in conjunction with * the {@link #monthNames} array to retrieve the textual day name. * Example: *


    var dt = new Date('1/10/2007');
    document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: 'Wednesday'

* @return {Number} The day number (0-6). */ getLastDayOfMonth : function() { var day = (this.getDay() + (Date.daysInMonth[this.getMonth()] - this.getDate())) % 7; return (day < 0) ? (day + 7) : day; }, /** * Get the date of the first day of the month in which this date resides. * @return {Date} */ getFirstDateOfMonth : function() { return new Date(this.getFullYear(), this.getMonth(), 1); }, /** * Get the date of the last day of the month in which this date resides. * @return {Date} */ getLastDateOfMonth : function() { return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth()); }, /** * Get the number of days in the current month, adjusted for leap year. * @return {Number} The number of days in the month. */ getDaysInMonth : function() { Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28; return Date.daysInMonth[this.getMonth()]; }, /** * Get the English ordinal suffix of the current day (equivalent to the format specifier 'S'). * @return {String} 'st, 'nd', 'rd' or 'th'. */ getSuffix : function() { switch (this.getDate()) { case 1: case 21: case 31: return "st"; case 2: case 22: return "nd"; case 3: case 23: return "rd"; default: return "th"; } }, /** * Creates and returns a new Date instance with the exact same date value as the called instance. * Dates are copied and passed by reference, so if a copied date variable is modified later, the original * variable will also be changed. When the intention is to create a new variable that will not * modify the original instance, you should create a clone. * * Example of correctly cloning a date: *


    //wrong way:
    var orig = new Date('10/1/2006');
    var copy = orig;
    copy.setDate(5);
    document.write(orig);  //returns 'Thu Oct 05 2006'!

    //correct way:
    var orig = new Date('10/1/2006');
    var copy = orig.clone();
    copy.setDate(5);
    document.write(orig);  //returns 'Thu Oct 01 2006'

* @return {Date} The new Date instance. */ clone : function() { return new Date(this.getTime()); }, /** * Clears any time information from this date. @param {Boolean} clone true to create a clone of this date, clear the time and return it (defaults to false). @return {Date} this or the clone. */ clearTime : function(clone){ if(clone){ return this.clone().clearTime(); } this.setHours(0); this.setMinutes(0); this.setSeconds(0); this.setMilliseconds(0); return this; }, /** * Provides a convenient method of performing basic date arithmetic. This method * does not modify the Date instance being called - it creates and returns * a new Date instance containing the resulting date value. * * Examples: *


    //Basic usage:
    var dt = new Date('10/29/2006').add(Date.DAY, 5);
    document.write(dt); //returns 'Fri Oct 06 2006 00:00:00'

    //Negative values will subtract correctly:
    var dt2 = new Date('10/1/2006').add(Date.DAY, -5);
    document.write(dt2); //returns 'Tue Sep 26 2006 00:00:00'

    //You can even chain several calls together in one line!
    var dt3 = new Date('10/1/2006').add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
    document.write(dt3); //returns 'Fri Oct 06 2006 07:30:00'

* * @param {String} interval A valid date interval enum value. * @param {Number} value The amount to add to the current date. * @return {Date} The new Date instance. */ add : function(interval, value){ var d = this.clone(); if (!interval || value === 0) return d; switch(interval.toLowerCase()){ case Date.MILLI: d.setMilliseconds(this.getMilliseconds() + value); break; case Date.SECOND: d.setSeconds(this.getSeconds() + value); break; case Date.MINUTE: d.setMinutes(this.getMinutes() + value); break; case Date.HOUR: d.setHours(this.getHours() + value); break; case Date.DAY: d.setDate(this.getDate() + value); break; case Date.MONTH: var day = this.getDate(); if(day > 28){ day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate()); } d.setDate(day); d.setMonth(this.getMonth() + value); break; case Date.YEAR: d.setFullYear(this.getFullYear() + value); break; } return d; }, /** * Checks if this date falls on or between the given start and end dates. * @param {Date} start Start date * @param {Date} end End date * @return {Boolean} true if this date falls on or between the given start and end dates. */ between : function(start, end){ var t = this.getTime(); return start.getTime() <= t && t <= end.getTime(); } }); /** * Formats a date given the supplied format string. * @param {String} format The format string. * @return {String} The formatted date. * @method format */ Date.prototype.format = Date.prototype.dateFormat; // private // safari setMonth is broken if(CQ.Ext.isSafari){ Date.brokenSetMonth = Date.prototype.setMonth; Date.prototype.setMonth = function(num){ if(num <= -1){ var n = Math.ceil(-num); var back_year = Math.ceil(n/12); var month = (n % 12) ? 12 - n % 12 : 0 ; this.setFullYear(this.getFullYear() - back_year); return Date.brokenSetMonth.call(this, month); } else { return Date.brokenSetMonth.apply(this, arguments); } }; }/* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class CQ.Ext.util.DelayedTask * Provides a convenient method of performing setTimeout where a new * timeout cancels the old timeout. An example would be performing validation on a keypress. * You can use this class to buffer * the keypress events for a certain number of milliseconds, and perform only if they stop * for that amount of time. * @constructor The parameters to this constructor serve as defaults and are not required. * @param {Function} fn (optional) The default function to timeout * @param {Object} scope (optional) The default scope of that timeout * @param {Array} args (optional) The default Array of arguments */ CQ.Ext.util.DelayedTask = function(fn, scope, args){ var id = null, d, t; var call = function(){ var now = new Date().getTime(); if(now - t >= d){ clearInterval(id); id = null; fn.apply(scope, args || []); } }; /** * Cancels any pending timeout and queues a new one * @param {Number} delay The milliseconds to delay * @param {Function} newFn (optional) Overrides function passed to constructor * @param {Object} newScope (optional) Overrides scope passed to constructor * @param {Array} newArgs (optional) Overrides args passed to constructor */ this.delay = function(delay, newFn, newScope, newArgs){ if(id && delay != d){ this.cancel(); } d = delay; t = new Date().getTime(); fn = newFn || fn; scope = newScope || scope; args = newArgs || args; if(!id){ id = setInterval(call, d); } }; /** * Cancel the last queued timeout */ this.cancel = function(){ if(id){ clearInterval(id); id = null; } }; };/* * Ext JS Library 2.2 * Copyright(c) 2006-2008, Ext JS, LLC. * licensing@extjs.com * * http://extjs.com/license */ /** * @class CQ.Ext.util.TaskRunner * Provides the ability to execute one or more arbitrary tasks in a multithreaded manner. Generally, you can use * the singleton {@link CQ.Ext.TaskMgr} instead, but if needed, you can create separate instances of TaskRunner. Any * number of separate tasks can be started at any time and will run independently of each other. Example usage: *


// Start a simple clock task that updates a div once per second
var task = {
    run: function(){
        CQ.Ext.fly('clock').update(new Date().format('g:i:s A'));
    },
    interval: 1000 //1 second
}
var runner = new CQ.Ext.util.TaskRunner();
runner.start(task);

* @constructor * @param {Number} interval (optional) The minimum precision in milliseconds supported by this TaskRunner instance * (defaults to 10) */ CQ.Ext.util.TaskRunner = function(interval){ interval = interval || 10; var tasks = [], removeQueue = []; var id = 0; var running = false; // private var stopThread = function(){ running = false; clearInterval(id); id = 0; }; // private var startThread = function(){ if(!running){ running = true; id = setInterval(runTasks, interval); } }; // private var removeTask = function(t){ removeQueue.push(t); if(t.onStop){ t.onStop.apply(t.scope || t); } }; // private var runTasks = function(){ if(removeQueue.length > 0){ for(var i = 0, len = removeQueue.length; i < len; i++){ tasks.remove(removeQueue[i]); } removeQueue = []; if(tasks.length < 1){ stopThread(); return; } } var now = new Date().getTime(); for(var i = 0, len = tasks.length; i < len; ++i){ var t = tasks[i]; var itime = now - t.taskRunTime; if(t.interval <= itime){ var rt = t.run.apply(t.scope || t, t.args || [++t.taskRunCount]); t.taskRunTime = now; if(rt === false || t.taskRunCount === t.repeat){ removeTask(t); return; } } if(t.duration && t.duration <= (now - t.taskStartTime)){ removeTask(t); } } }; /** * Starts a new task. * @param {Object} task A config object that supports the following properties:

run : Function
The function to execute each time the task is run. The * function will be called at each interval and passed the args argument if specified. If a * particular scope is required, be sure to specify it using the scope argument.


     * interval : NumberThe frequency in milliseconds with which the task
     * should be executed.
     * args : Array(optional) An array of arguments to be passed to the function
     * specified by run.
     * scope : Object(optional) The scope in which to execute the
     * run function.
     * duration : Number(optional) The length of time in milliseconds to execute
     * the task before stopping automatically (defaults to indefinite).
     * repeat : Number(optional) The number of times to execute the task before
     * stopping automatically (defaults to indefinite).
     *


     * @return {Object} The task
     */
    this.start = function(task){
        tasks.push(task);
        task.taskStartTime = new Date().getTime();
        task.taskRunTime = 0;
        task.taskRunCount = 0;
        startThread();
        return task;
    };

    /**
     * Stops an existing running task.
     * @param {Object} task The task to stop
     * @return {Object} The task
     */
    this.stop = function(task){
        removeTask(task);
        return task;
    };

    /**
     * Stops all tasks that are currently running.
     */
    this.stopAll = function(){
        stopThread();
        for(var i = 0, len = tasks.length; i < len; i++){
            if(tasks[i].onStop){
                tasks[i].onStop();
            }
        }
        tasks = [];
        removeQueue = [];
    };
};

/**
 * @class CQ.Ext.TaskMgr
 * A static {@link CQ.Ext.util.TaskRunner} instance that can be used to start and stop arbitrary tasks.  See
 * {@link CQ.Ext.util.TaskRunner} for supported methods and task config properties.
 * 
// Start a simple clock task that updates a div once per second
var task = {
    run: function(){
        CQ.Ext.fly('clock').update(new Date().format('g:i:s A'));
    },
    interval: 1000 //1 second
}
CQ.Ext.TaskMgr.start(task);

 * @singleton
 */
CQ.Ext.TaskMgr = new CQ.Ext.util.TaskRunner();/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.util.MixedCollection
 * @extends CQ.Ext.util.Observable
 * A Collection class that maintains both numeric indexes and keys and exposes events.
 * @constructor
 * @param {Boolean} allowFunctions True if the addAll function should add function references to the
 * collection (defaults to false)
 * @param {Function} keyFn A function that can accept an item of the type(s) stored in this MixedCollection
 * and return the key value for that item.  This is used when available to look up the key on items that
 * were passed without an explicit key parameter to a MixedCollection method.  Passing this parameter is
 * equivalent to providing an implementation for the {@link #getKey} method.
 */
CQ.Ext.util.MixedCollection = function(allowFunctions, keyFn){
    this.items = [];
    this.map = {};
    this.keys = [];
    this.length = 0;
    this.addEvents(
        /**
         * @event clear
         * Fires when the collection is cleared.
         */
        "clear",
        /**
         * @event add
         * Fires when an item is added to the collection.
         * @param {Number} index The index at which the item was added.
         * @param {Object} o The item added.
         * @param {String} key The key associated with the added item.
         */
        "add",
        /**
         * @event replace
         * Fires when an item is replaced in the collection.
         * @param {String} key he key associated with the new added.
         * @param {Object} old The item being replaced.
         * @param {Object} new The new item.
         */
        "replace",
        /**
         * @event remove
         * Fires when an item is removed from the collection.
         * @param {Object} o The item being removed.
         * @param {String} key (optional) The key associated with the removed item.
         */
        "remove",
        "sort"
    );
    this.allowFunctions = allowFunctions === true;
    if(keyFn){
        this.getKey = keyFn;
    }
    CQ.Ext.util.MixedCollection.superclass.constructor.call(this);
};

CQ.Ext.extend(CQ.Ext.util.MixedCollection, CQ.Ext.util.Observable, {
    allowFunctions : false,

/**
 * Adds an item to the collection. Fires the {@link #add} event when complete.
 * @param {String} key The key to associate with the item, or the new item.
 * If you supplied a {@link #getKey} implementation for this MixedCollection, or if the key
 * of your stored items is in a property called id, then the MixedCollection
 * will be able to derive the key for the new item. In this case just pass the new item in
 * this parameter.
 * @param {Object} o The item to add.
 * @return {Object} The item added.
 */
    add : function(key, o){
        if(arguments.length == 1){
            o = arguments[0];
            key = this.getKey(o);
        }
        if(typeof key == "undefined" || key === null){
            this.length++;
            this.items.push(o);
            this.keys.push(null);
        }else{
            var old = this.map[key];
            if(old){
                return this.replace(key, o);
            }
            this.length++;
            this.items.push(o);
            this.map[key] = o;
            this.keys.push(key);
        }
        this.fireEvent("add", this.length-1, o, key);
        return o;
    },

/**
  * MixedCollection has a generic way to fetch keys if you implement getKey.  The default implementation
  * simply returns item.id but you can provide your own implementation
  * to return a different value as in the following examples:

// normal way
var mc = new CQ.Ext.util.MixedCollection();
mc.add(someEl.dom.id, someEl);
mc.add(otherEl.dom.id, otherEl);
//and so on

// using getKey
var mc = new CQ.Ext.util.MixedCollection();
mc.getKey = function(el){
   return el.dom.id;
};
mc.add(someEl);
mc.add(otherEl);

// or via the constructor
var mc = new CQ.Ext.util.MixedCollection(false, function(el){
   return el.dom.id;
});
mc.add(someEl);
mc.add(otherEl);

 * @param {Object} item The item for which to find the key.
 * @return {Object} The key for the passed item.
 */
    getKey : function(o){
         return o.id;
    },

/**
 * Replaces an item in the collection. Fires the {@link #replace} event when complete.
 * @param {String} key The key associated with the item to replace, or the replacement item.
 * If you supplied a {@link #getKey} implementation for this MixedCollection, or if the key
 * of your stored items is in a property called id, then the MixedCollection
 * will be able to derive the key of the replacement item. If you want to replace an item
 * with one having the same key value, then just pass the replacement item in this parameter.
 * @param o {Object} o (optional) If the first parameter passed was a key, the item to associate
 * with that key.
 * @return {Object}  The new item.
 */
    replace : function(key, o){
        if(arguments.length == 1){
            o = arguments[0];
            key = this.getKey(o);
        }
        var old = this.item(key);
        if(typeof key == "undefined" || key === null || typeof old == "undefined"){
             return this.add(key, o);
        }
        var index = this.indexOfKey(key);
        this.items[index] = o;
        this.map[key] = o;
        this.fireEvent("replace", key, old, o);
        return o;
    },

/**
 * Adds all elements of an Array or an Object to the collection.
 * @param {Object/Array} objs An Object containing properties which will be added to the collection, or
 * an Array of values, each of which are added to the collection.
 */
    addAll : function(objs){
        if(arguments.length > 1 || CQ.Ext.isArray(objs)){
            var args = arguments.length > 1 ? arguments : objs;
            for(var i = 0, len = args.length; i < len; i++){
                this.add(args[i]);
            }
        }else{
            for(var key in objs){
                if(this.allowFunctions || typeof objs[key] != "function"){
                    this.add(key, objs[key]);
                }
            }
        }
    },

/**
 * Executes the specified function once for every item in the collection, passing the following arguments:
 * 
 * item : MixedThe collection item
 * index : NumberThe item's index
 * length : NumberThe total number of items in the collection
 * 
 * The function should return a boolean value. Returning false from the function will stop the iteration.
 * @param {Function} fn The function to execute for each item.
 * @param {Object} scope (optional) The scope in which to execute the function.
 */
    each : function(fn, scope){
        var items = [].concat(this.items); // each safe for removal
        for(var i = 0, len = items.length; i < len; i++){
            if(fn.call(scope || items[i], items[i], i, len) === false){
                break;
            }
        }
    },

/**
 * Executes the specified function once for every key in the collection, passing each
 * key, and its associated item as the first two parameters.
 * @param {Function} fn The function to execute for each item.
 * @param {Object} scope (optional) The scope in which to execute the function.
 */
    eachKey : function(fn, scope){
        for(var i = 0, len = this.keys.length; i < len; i++){
            fn.call(scope || window, this.keys[i], this.items[i], i, len);
        }
    },

    /**
     * Returns the first item in the collection which elicits a true return value from the
     * passed selection function.
     * @param {Function} fn The selection function to execute for each item.
     * @param {Object} scope (optional) The scope in which to execute the function.
     * @return {Object} The first item in the collection which returned true from the selection function.
     */
    find : function(fn, scope){
        for(var i = 0, len = this.items.length; i < len; i++){
            if(fn.call(scope || window, this.items[i], this.keys[i])){
                return this.items[i];
            }
        }
        return null;
    },

/**
 * Inserts an item at the specified index in the collection. Fires the {@link #add} event when complete.
 * @param {Number} index The index to insert the item at.
 * @param {String} key The key to associate with the new item, or the item itself.
 * @param {Object} o (optional) If the second parameter was a key, the new item.
 * @return {Object} The item inserted.
 */
    insert : function(index, key, o){
        if(arguments.length == 2){
            o = arguments[1];
            key = this.getKey(o);
        }
        if(index >= this.length){
            return this.add(key, o);
        }
        this.length++;
        this.items.splice(index, 0, o);
        if(typeof key != "undefined" && key != null){
            this.map[key] = o;
        }
        this.keys.splice(index, 0, key);
        this.fireEvent("add", index, o, key);
        return o;
    },

/**
 * Remove an item from the collection.
 * @param {Object} o The item to remove.
 * @return {Object} The item removed or false if no item was removed.
 */
    remove : function(o){
        return this.removeAt(this.indexOf(o));
    },

/**
 * Remove an item from a specified index in the collection. Fires the {@link #remove} event when complete.
 * @param {Number} index The index within the collection of the item to remove.
 * @return {Object} The item removed or false if no item was removed.
 */
    removeAt : function(index){
        if(index < this.length && index >= 0){
            this.length--;
            var o = this.items[index];
            this.items.splice(index, 1);
            var key = this.keys[index];
            if(typeof key != "undefined"){
                delete this.map[key];
            }
            this.keys.splice(index, 1);
            this.fireEvent("remove", o, key);
            return o;
        }
        return false;
    },

/**
 * Removed an item associated with the passed key fom the collection.
 * @param {String} key The key of the item to remove.
 * @return {Object} The item removed or false if no item was removed.
 */
    removeKey : function(key){
        return this.removeAt(this.indexOfKey(key));
    },

/**
 * Returns the number of items in the collection.
 * @return {Number} the number of items in the collection.
 */
    getCount : function(){
        return this.length;
    },

/**
 * Returns index within the collection of the passed Object.
 * @param {Object} o The item to find the index of.
 * @return {Number} index of the item.
 */
    indexOf : function(o){
        return this.items.indexOf(o);
    },

/**
 * Returns index within the collection of the passed key.
 * @param {String} key The key to find the index of.
 * @return {Number} index of the key.
 */
    indexOfKey : function(key){
        return this.keys.indexOf(key);
    },

/**
 * Returns the item associated with the passed key OR index. Key has priority over index.  This is the equivalent
 * of calling {@link #key} first, then if nothing matched calling {@link #itemAt}.
 * @param {String/Number} key The key or index of the item.
 * @return {Object} The item associated with the passed key.
 */
    item : function(key){
        var item = typeof this.map[key] != "undefined" ? this.map[key] : this.items[key];
        return typeof item != 'function' || this.allowFunctions ? item : null; // for prototype!
    },

/**
 * Returns the item at the specified index.
 * @param {Number} index The index of the item.
 * @return {Object} The item at the specified index.
 */
    itemAt : function(index){
        return this.items[index];
    },

/**
 * Returns the item associated with the passed key.
 * @param {String/Number} key The key of the item.
 * @return {Object} The item associated with the passed key.
 */
    key : function(key){
        return this.map[key];
    },

/**
 * Returns true if the collection contains the passed Object as an item.
 * @param {Object} o  The Object to look for in the collection.
 * @return {Boolean} True if the collection contains the Object as an item.
 */
    contains : function(o){
        return this.indexOf(o) != -1;
    },

/**
 * Returns true if the collection contains the passed Object as a key.
 * @param {String} key The key to look for in the collection.
 * @return {Boolean} True if the collection contains the Object as a key.
 */
    containsKey : function(key){
        return typeof this.map[key] != "undefined";
    },

/**
 * Removes all items from the collection.  Fires the {@link #clear} event when complete.
 */
    clear : function(){
        this.length = 0;
        this.items = [];
        this.keys = [];
        this.map = {};
        this.fireEvent("clear");
    },

/**
 * Returns the first item in the collection.
 * @return {Object} the first item in the collection..
 */
    first : function(){
        return this.items[0];
    },

/**
 * Returns the last item in the collection.
 * @return {Object} the last item in the collection..
 */
    last : function(){
        return this.items[this.length-1];
    },

    // private
    _sort : function(property, dir, fn){
        var dsc = String(dir).toUpperCase() == "DESC" ? -1 : 1;
        fn = fn || function(a, b){
            return a-b;
        };
        var c = [], k = this.keys, items = this.items;
        for(var i = 0, len = items.length; i < len; i++){
            c[c.length] = {key: k[i], value: items[i], index: i};
        }
        c.sort(function(a, b){
            var v = fn(a[property], b[property]) * dsc;
            if(v == 0){
                v = (a.index < b.index ? -1 : 1);
            }
            return v;
        });
        for(var i = 0, len = c.length; i < len; i++){
            items[i] = c[i].value;
            k[i] = c[i].key;
        }
        this.fireEvent("sort", this);
    },

    /**
     * Sorts this collection with the passed comparison function
     * @param {String} direction (optional) "ASC" or "DESC"
     * @param {Function} fn (optional) comparison function
     */
    sort : function(dir, fn){
        this._sort("value", dir, fn);
    },

    /**
     * Sorts this collection by keys
     * @param {String} direction (optional) "ASC" or "DESC"
     * @param {Function} fn (optional) a comparison function (defaults to case insensitive string)
     */
    keySort : function(dir, fn){
        this._sort("key", dir, fn || function(a, b){
            return String(a).toUpperCase()-String(b).toUpperCase();
        });
    },

    /**
     * Returns a range of items in this collection
     * @param {Number} startIndex (optional) defaults to 0
     * @param {Number} endIndex (optional) default to the last item
     * @return {Array} An array of items
     */
    getRange : function(start, end){
        var items = this.items;
        if(items.length < 1){
            return [];
        }
        start = start || 0;
        end = Math.min(typeof end == "undefined" ? this.length-1 : end, this.length-1);
        var r = [];
        if(start <= end){
            for(var i = start; i <= end; i++) {
        	    r[r.length] = items[i];
            }
        }else{
            for(var i = start; i >= end; i--) {
        	    r[r.length] = items[i];
            }
        }
        return r;
    },

    /**
     * Filter the objects in this collection by a specific property.
     * Returns a new collection that has been filtered.
     * @param {String} property A property on your objects
     * @param {String/RegExp} value Either string that the property values
     * should start with or a RegExp to test against the property
     * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning
     * @param {Boolean} caseSensitive (optional) True for case sensitive comparison (defaults to False).
     * @return {MixedCollection} The new filtered collection
     */
    filter : function(property, value, anyMatch, caseSensitive){
        if(CQ.Ext.isEmpty(value, false)){
            return this.clone();
        }
        value = this.createValueMatcher(value, anyMatch, caseSensitive);
        return this.filterBy(function(o){
            return o && value.test(o[property]);
        });
	},

    /**
     * Filter by a function. Returns a new collection that has been filtered.
     * The passed function will be called with each object in the collection.
     * If the function returns true, the value is included otherwise it is filtered.
     * @param {Function} fn The function to be called, it will receive the args o (the object), k (the key)
     * @param {Object} scope (optional) The scope of the function (defaults to this)
     * @return {MixedCollection} The new filtered collection
     */
    filterBy : function(fn, scope){
        var r = new CQ.Ext.util.MixedCollection();
        r.getKey = this.getKey;
        var k = this.keys, it = this.items;
        for(var i = 0, len = it.length; i < len; i++){
            if(fn.call(scope||this, it[i], k[i])){
				r.add(k[i], it[i]);
			}
        }
        return r;
    },

    /**
     * Finds the index of the first matching object in this collection by a specific property/value.
     * @param {String} property The name of a property on your objects.
     * @param {String/RegExp} value A string that the property values
     * should start with or a RegExp to test against the property.
     * @param {Number} start (optional) The index to start searching at (defaults to 0).
     * @param {Boolean} anyMatch (optional) True to match any part of the string, not just the beginning.
     * @param {Boolean} caseSensitive (optional) True for case sensitive comparison.
     * @return {Number} The matched index or -1
     */
    findIndex : function(property, value, start, anyMatch, caseSensitive){
        if(CQ.Ext.isEmpty(value, false)){
            return -1;
        }
        value = this.createValueMatcher(value, anyMatch, caseSensitive);
        return this.findIndexBy(function(o){
            return o && value.test(o[property]);
        }, null, start);
	},

    /**
     * Find the index of the first matching object in this collection by a function.
     * If the function returns true it is considered a match.
     * @param {Function} fn The function to be called, it will receive the args o (the object), k (the key).
     * @param {Object} scope (optional) The scope of the function (defaults to this).
     * @param {Number} start (optional) The index to start searching at (defaults to 0).
     * @return {Number} The matched index or -1
     */
    findIndexBy : function(fn, scope, start){
        var k = this.keys, it = this.items;
        for(var i = (start||0), len = it.length; i < len; i++){
            if(fn.call(scope||this, it[i], k[i])){
				return i;
            }
        }
        if(typeof start == 'number' && start > 0){
            for(var i = 0; i < start; i++){
                if(fn.call(scope||this, it[i], k[i])){
                    return i;
                }
            }
        }
        return -1;
    },

    // private
    createValueMatcher : function(value, anyMatch, caseSensitive){
        if(!value.exec){ // not a regex
            value = String(value);
            value = new RegExp((anyMatch === true ? '' : '^') + CQ.Ext.escapeRe(value), caseSensitive ? '' : 'i');
        }
        return value;
    },

    /**
     * Creates a duplicate of this collection
     * @return {MixedCollection}
     */
    clone : function(){
        var r = new CQ.Ext.util.MixedCollection();
        var k = this.keys, it = this.items;
        for(var i = 0, len = it.length; i < len; i++){
            r.add(k[i], it[i]);
        }
        r.getKey = this.getKey;
        return r;
    }
});
/**
 * Returns the item associated with the passed key or index.
 * @method
 * @param {String/Number} key The key or index of the item.
 * @return {Object} The item associated with the passed key.
 */
CQ.Ext.util.MixedCollection.prototype.get = CQ.Ext.util.MixedCollection.prototype.item;/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.util.JSON
 * Modified version of Douglas Crockford"s json.js that doesn"t
 * mess with the Object prototype
 * http://www.json.org/js.html
 * @singleton
 */
CQ.Ext.util.JSON = new (function(){
    var useHasOwn = !!{}.hasOwnProperty;

    // crashes Safari in some instances
    //var validRE = /^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/;

    var pad = function(n) {
        return n < 10 ? "0" + n : n;
    };

    var m = {
        "\b": '\\b',
        "\t": '\\t',
        "\n": '\\n',
        "\f": '\\f',
        "\r": '\\r',
        '"' : '\\"',
        "\\": '\\\\'
    };

    var encodeString = function(s){
        if (/["\\\x00-\x1f]/.test(s)) {
            return '"' + s.replace(/([\x00-\x1f\\"])/g, function(a, b) {
                var c = m[b];
                if(c){
                    return c;
                }
                c = b.charCodeAt();
                return "\\u00" +
                    Math.floor(c / 16).toString(16) +
                    (c % 16).toString(16);
            }) + '"';
        }
        return '"' + s + '"';
    };

    var encodeArray = function(o){
        var a = ["["], b, i, l = o.length, v;
            for (i = 0; i < l; i += 1) {
                v = o[i];
                switch (typeof v) {
                    case "undefined":
                    case "function":
                    case "unknown":
                        break;
                    default:
                        if (b) {
                            a.push(',');
                        }
                        a.push(v === null ? "null" : CQ.Ext.util.JSON.encode(v));
                        b = true;
                }
            }
            a.push("]");
            return a.join("");
    };

    this.encodeDate = function(o){
        return '"' + o.getFullYear() + "-" +
                pad(o.getMonth() + 1) + "-" +
                pad(o.getDate()) + "T" +
                pad(o.getHours()) + ":" +
                pad(o.getMinutes()) + ":" +
                pad(o.getSeconds()) + '"';
    };

    /**
     * Encodes an Object, Array or other value
     * @param {Mixed} o The variable to encode
     * @return {String} The JSON string
     */
    this.encode = function(o){
        if(typeof o == "undefined" || o === null){
            return "null";
        }else if(CQ.Ext.isArray(o)){
            return encodeArray(o);
        }else if(CQ.Ext.isDate(o)){
            return CQ.Ext.util.JSON.encodeDate(o);
        }else if(typeof o == "string"){
            return encodeString(o);
        }else if(typeof o == "number"){
            return isFinite(o) ? String(o) : "null";
        }else if(typeof o == "boolean"){
            return String(o);
        }else {
            var a = ["{"], b, i, v;
            for (i in o) {
                if(!useHasOwn || o.hasOwnProperty(i)) {
                    v = o[i];
                    switch (typeof v) {
                    case "undefined":
                    case "function":
                    case "unknown":
                        break;
                    default:
                        if(b){
                            a.push(',');
                        }
                        a.push(this.encode(i), ":",
                                v === null ? "null" : this.encode(v));
                        b = true;
                    }
                }
            }
            a.push("}");
            return a.join("");
        }
    };

    /**
     * Decodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError.
     * @param {String} json The JSON string
     * @return {Object} The resulting object
     */
    this.decode = function(json){
        return eval("(" + json + ')');
    };
})();
/**
 * Shorthand for {@link CQ.Ext.util.JSON#encode}
 * @param {Mixed} o The variable to encode
 * @return {String} The JSON string
 * @member CQ.Ext
 * @method encode
 */
CQ.Ext.encode = CQ.Ext.util.JSON.encode;
/**
 * Shorthand for {@link CQ.Ext.util.JSON#decode}
 * @param {String} json The JSON string
 * @return {Object} The resulting object
 * @member CQ.Ext
 * @method decode
 */
CQ.Ext.decode = CQ.Ext.util.JSON.decode;
/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.util.Format
 * Reusable data formatting functions
 * @singleton
 */
CQ.Ext.util.Format = function(){
    var trimRe = /^\s+|\s+$/g;
    return {
        /**
         * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
         * @param {String} value The string to truncate
         * @param {Number} length The maximum length to allow before truncating
         * @return {String} The converted text
         */
        ellipsis : function(value, len){
            if(value && value.length > len){
                return value.substr(0, len-3)+"...";
            }
            return value;
        },

        /**
         * Checks a reference and converts it to empty string if it is undefined
         * @param {Mixed} value Reference to check
         * @return {Mixed} Empty string if converted, otherwise the original value
         */
        undef : function(value){
            return value !== undefined ? value : "";
        },

        /**
         * Checks a reference and converts it to the default value if it's empty
         * @param {Mixed} value Reference to check
         * @param {String} defaultValue The value to insert of it's undefined (defaults to "")
         * @return {String}
         */
        defaultValue : function(value, defaultValue){
            return value !== undefined && value !== '' ? value : defaultValue;
        },

        /**
         * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
         * @param {String} value The string to encode
         * @return {String} The encoded text
         */
        htmlEncode : function(value){
            return !value ? value : String(value).replace(/&/g, "&").replace(/>/g, ">").replace(/, and ') from their HTML character equivalents.
         * @param {String} value The string to decode
         * @return {String} The decoded text
         */
        htmlDecode : function(value){
            return !value ? value : String(value).replace(/>/g, ">").replace(/</g, "<").replace(/"/g, '"').replace(/&/g, "&");
        },

        /**
         * Trims any whitespace from either side of a string
         * @param {String} value The text to trim
         * @return {String} The trimmed text
         */
        trim : function(value){
            return String(value).replace(trimRe, "");
        },

        /**
         * Returns a substring from within an original string
         * @param {String} value The original text
         * @param {Number} start The start index of the substring
         * @param {Number} length The length of the substring
         * @return {String} The substring
         */
        substr : function(value, start, length){
            return String(value).substr(start, length);
        },

        /**
         * Converts a string to all lower case letters
         * @param {String} value The text to convert
         * @return {String} The converted text
         */
        lowercase : function(value){
            return String(value).toLowerCase();
        },

        /**
         * Converts a string to all upper case letters
         * @param {String} value The text to convert
         * @return {String} The converted text
         */
        uppercase : function(value){
            return String(value).toUpperCase();
        },

        /**
         * Converts the first character only of a string to upper case
         * @param {String} value The text to convert
         * @return {String} The converted text
         */
        capitalize : function(value){
            return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
        },

        // private
        call : function(value, fn){
            if(arguments.length > 2){
                var args = Array.prototype.slice.call(arguments, 2);
                args.unshift(value);
                return eval(fn).apply(window, args);
            }else{
                return eval(fn).call(window, value);
            }
        },

        /**
         * Format a number as US currency
         * @param {Number/String} value The numeric value to format
         * @return {String} The formatted currency string
         */
        usMoney : function(v){
            v = (Math.round((v-0)*100))/100;
            v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
            v = String(v);
            var ps = v.split('.');
            var whole = ps[0];
            var sub = ps[1] ? '.'+ ps[1] : '.00';
            var r = /(\d+)(\d{3})/;
            while (r.test(whole)) {
                whole = whole.replace(r, '$1' + ',' + '$2');
            }
            v = whole + sub;
            if(v.charAt(0) == '-'){
                return '-$' + v.substr(1);
            }
            return "$" +  v;
        },

        /**
         * Parse a value into a formatted date using the specified format pattern.
         * @param {String/Date} value The value to format (Strings must conform to the format expected by the javascript Date object's parse() method)
         * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
         * @return {String} The formatted date string
         */
        date : function(v, format){
            if(!v){
                return "";
            }
            if(!CQ.Ext.isDate(v)){
                v = new Date(Date.parse(v));
            }
            return v.dateFormat(format || "m/d/Y");
        },

        /**
         * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
         * @param {String} format Any valid date format string
         * @return {Function} The date formatting function
         */
        dateRenderer : function(format){
            return function(v){
                return CQ.Ext.util.Format.date(v, format);
            };
        },

        // private
        stripTagsRE : /<\/?[^>]+>/gi,

        /**
         * Strips all HTML tags
         * @param {Mixed} value The text from which to strip tags
         * @return {String} The stripped text
         */
        stripTags : function(v){
            return !v ? v : String(v).replace(this.stripTagsRE, "");
        },

        stripScriptsRe : /(?:)((\n|\r|.)*?)(?:<\/script>)/ig,

        /**
         * Strips all script tags
         * @param {Mixed} value The text from which to strip script tags
         * @return {String} The stripped text
         */
        stripScripts : function(v){
            return !v ? v : String(v).replace(this.stripScriptsRe, "");
        },

        /**
         * Simple format for a file size (xxx bytes, xxx KB, xxx MB)
         * @param {Number/String} size The numeric value to format
         * @return {String} The formatted file size
         */
        fileSize : function(size){
            if(size < 1024) {
                return size + " bytes";
            } else if(size < 1048576) {
                return (Math.round(((size*10) / 1024))/10) + " KB";
            } else {
                return (Math.round(((size*10) / 1048576))/10) + " MB";
            }
        },

        math : function(){
            var fns = {};
            return function(v, a){
                if(!fns[a]){
                    fns[a] = new Function('v', 'return v ' + a + ';');
                }
                return fns[a](v);
            }
        }(),

        nl2br : function(v){
            return v === undefined || v === null ? '' : v.replace(/\n/g, '
');
        }
    };
}();/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
* @class CQ.Ext.XTemplate
* @extends CQ.Ext.Template
* A template class that supports advanced functionality like autofilling arrays, conditional processing with
* basic comparison operators, sub-templates, basic math function support, special built-in template variables,
* inline code execution and more.  XTemplate also provides the templating mechanism built into {@link CQ.Ext.DataView}.
* XTemplate supports many special tags and built-in operators that aren't defined as part of the API, but are
* supported in the templates that can be created.  The following examples demonstrate all of the supported features.
* This is the data object used for reference in each code example:
* 
var data = {
    name: 'Jack Slocum',
    title: 'Lead Developer',
    company: 'Ext JS, LLC',
    email: 'jack@extjs.com',
    address: '4 Red Bulls Drive',
    city: 'Cleveland',
    state: 'Ohio',
    zip: '44102',
    drinks: ['Red Bull', 'Coffee', 'Water'],
    kids: [{
        name: 'Sara Grace',
        age:3
    },{
        name: 'Zachary',
        age:2
    },{
        name: 'John James',
        age:0
    }]
};

* Auto filling of arrays and scope switching
Using the tpl tag and the for operator,
* you can switch to the scope of the object specified by for and access its members to populate the template.
* If the variable in for is an array, it will auto-fill, repeating the template block inside the tpl
* tag for each item in the array:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Title: {title}</p>',
    '<p>Company: {company}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
        '<p>{name}</p>',
    '</tpl></p>'
);
tpl.overwrite(panel.body, data);

* Access to parent object from within sub-template scope
When processing a sub-template, for example while
* looping through a child array, you can access the parent object's members via the parent object:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
        '<tpl if="age &gt; 1">',  // <-- Note that the > is encoded
            '<p>{name}</p>',
            '<p>Dad: {parent.name}</p>',
        '</tpl>',
    '</tpl></p>'
);
tpl.overwrite(panel.body, data);

* Array item index and basic math support 
While processing an array, the special variable {#}
* will provide the current array index + 1 (starts at 1, not 0). Templates also support the basic math operators
* + - * and / that can be applied directly on numeric data values:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
        '<tpl if="age &gt; 1">',  // <-- Note that the > is encoded
            '<p>{#}: {name}</p>',  // <-- Auto-number each item
            '<p>In 5 Years: {age+5}</p>',  // <-- Basic math
            '<p>Dad: {parent.name}</p>',
        '</tpl>',
    '</tpl></p>'
);
tpl.overwrite(panel.body, data);

* Auto-rendering of flat arrays 
Flat arrays that contain values (and not objects) can be auto-rendered
* using the special {.} variable inside a loop.  This variable will represent the value of
* the array at the current index:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>{name}\'s favorite beverages:</p>',
    '<tpl for="drinks">',
       '<div> - {.}</div>',
    '</tpl>'
);
tpl.overwrite(panel.body, data);

* Basic conditional logic 
Using the tpl tag and the if
* operator you can provide conditional checks for deciding whether or not to render specific parts of the template.
* Note that there is no else operator — if needed, you should use two opposite if statements.
* Properly-encoded attributes are required as seen in the following example:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
        '<tpl if="age &gt; 1">',  // <-- Note that the > is encoded
            '<p>{name}</p>',
        '</tpl>',
    '</tpl></p>'
);
tpl.overwrite(panel.body, data);

* Ability to execute arbitrary inline code 
In an XTemplate, anything between {[ ... ]}  is considered
* code to be executed in the scope of the template. There are some special variables available in that code:
* 

* values: The values in the current scope. If you are using scope changing sub-templates, you
* can change what values is.
* parent: The scope (values) of the ancestor template.
* xindex: If you are in a looping template, the index of the loop you are in (1-based).
* xcount: If you are in a looping template, the total length of the array you are looping.
* fm: An alias for CQ.Ext.util.Format.
* 
* This example demonstrates basic row striping using an inline code block and the xindex variable:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
       '<div class="{[xindex % 2 === 0 ? "even" : "odd"]}">',
        '{name}',
        '</div>',
    '</tpl></p>'
);
tpl.overwrite(panel.body, data);

* Template member functions 
One or more member functions can be defined directly on the config
* object passed into the XTemplate constructor for more complex processing:
* 
var tpl = new CQ.Ext.XTemplate(
    '<p>Name: {name}</p>',
    '<p>Kids: ',
    '<tpl for="kids">',
        '<tpl if="this.isGirl(name)">',
            '<p>Girl: {name} - {age}</p>',
        '</tpl>',
        '<tpl if="this.isGirl(name) == false">',
            '<p>Boy: {name} - {age}</p>',
        '</tpl>',
        '<tpl if="this.isBaby(age)">',
            '<p>{name} is a baby!</p>',
        '</tpl>',
    '</tpl></p>', {
     isGirl: function(name){
         return name == 'Sara Grace';
     },
     isBaby: function(age){
        return age < 1;
     }
});
tpl.overwrite(panel.body, data);

* @constructor
* @param {String/Array/Object} parts The HTML fragment or an array of fragments to join(""), or multiple arguments
* to join("") that can also include a config object
*/
CQ.Ext.XTemplate = function(){
    CQ.Ext.XTemplate.superclass.constructor.apply(this, arguments);
    var s = this.html;

    s = ['', s, ''].join('');

    var re = /]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/;

    var nameRe = /^]*?for="(.*?)"/;
    var ifRe = /^]*?if="(.*?)"/;
    var execRe = /^]*?exec="(.*?)"/;
    var m, id = 0;
    var tpls = [];

    while(m = s.match(re)){
       var m2 = m[0].match(nameRe);
       var m3 = m[0].match(ifRe);
       var m4 = m[0].match(execRe);
       var exp = null, fn = null, exec = null;
       var name = m2 && m2[1] ? m2[1] : '';
       if(m3){
           exp = m3 && m3[1] ? m3[1] : null;
           if(exp){
               fn = new Function('values', 'parent', 'xindex', 'xcount', 'with(values){ return '+(CQ.Ext.util.Format.htmlDecode(exp))+'; }');
           }
       }
       if(m4){
           exp = m4 && m4[1] ? m4[1] : null;
           if(exp){
               exec = new Function('values', 'parent', 'xindex', 'xcount', 'with(values){ '+(CQ.Ext.util.Format.htmlDecode(exp))+'; }');
           }
       }
       if(name){
           switch(name){
               case '.': name = new Function('values', 'parent', 'with(values){ return values; }'); break;
               case '..': name = new Function('values', 'parent', 'with(values){ return parent; }'); break;
               default: name = new Function('values', 'parent', 'with(values){ return '+name+'; }');
           }
       }
       tpls.push({
            id: id,
            target: name,
            exec: exec,
            test: fn,
            body: m[1]||''
        });
       s = s.replace(m[0], '{xtpl'+ id + '}');
       ++id;
    }
    for(var i = tpls.length-1; i >= 0; --i){
        this.compileTpl(tpls[i]);
    }
    this.master = tpls[tpls.length-1];
    this.tpls = tpls;
};
CQ.Ext.extend(CQ.Ext.XTemplate, CQ.Ext.Template, {
    // private
    re : /\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\\]\s?[\d\.\+\-\*\\\(\)]+)?\}/g,
    // private
    codeRe : /\{\[((?:\\\]|.|\n)*?)\]\}/g,

    // private
    applySubTemplate : function(id, values, parent, xindex, xcount){
        var t = this.tpls[id];
        if(t.test && !t.test.call(this, values, parent, xindex, xcount)){
            return '';
        }
        if(t.exec && t.exec.call(this, values, parent, xindex, xcount)){
            return '';
        }
        var vs = t.target ? t.target.call(this, values, parent) : values;
        parent = t.target ? values : parent;
        if(t.target && CQ.Ext.isArray(vs)){
            var buf = [];
            for(var i = 0, len = vs.length; i < len; i++){
                buf[buf.length] = t.compiled.call(this, vs[i], parent, i+1, len);
            }
            return buf.join('');
        }
        return t.compiled.call(this, vs, parent, xindex, xcount);
    },

    // private
    compileTpl : function(tpl){
        var fm = CQ.Ext.util.Format;
        var useF = this.disableFormats !== true;
        var sep = CQ.Ext.isGecko ? "+" : ",";
        var fn = function(m, name, format, args, math){
            if(name.substr(0, 4) == 'xtpl'){
                return "'"+ sep +'this.applySubTemplate('+name.substr(4)+', values, parent, xindex, xcount)'+sep+"'";
            }
            var v;
            if(name === '.'){
                v = 'values';
            }else if(name === '#'){
                v = 'xindex';
            }else if(name.indexOf('.') != -1){
                v = name;
            }else{
                v = "values['" + name + "']";
            }
            if(math){
                v = '(' + v + math + ')';
            }
            if(format && useF){
                args = args ? ',' + args : "";
                if(format.substr(0, 5) != "this."){
                    format = "fm." + format + '(';
                }else{
                    format = 'this.call("'+ format.substr(5) + '", ';
                    args = ", values";
                }
            }else{
                args= ''; format = "("+v+" === undefined ? '' : ";
            }
            return "'"+ sep + format + v + args + ")"+sep+"'";
        };
        var codeFn = function(m, code){
            return "'"+ sep +'('+code+')'+sep+"'";
        };

        var body;
        // branched to use + in gecko and [].join() in others
        if(CQ.Ext.isGecko){
            body = "tpl.compiled = function(values, parent, xindex, xcount){ return '" +
                   tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn) +
                    "';};";
        }else{
            body = ["tpl.compiled = function(values, parent, xindex, xcount){ return ['"];
            body.push(tpl.body.replace(/(\r\n|\n)/g, '\\n').replace(/'/g, "\\'").replace(this.re, fn).replace(this.codeRe, codeFn));
            body.push("'].join('');};");
            body = body.join('');
        }
        eval(body);
        return this;
    },

    /**
     * Returns an HTML fragment of this template with the specified values applied.
     * @param {Object} values The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})
     * @return {String} The HTML fragment
     */
    applyTemplate : function(values){
        return this.master.compiled.call(this, values, {}, 1, 1);
    },

    /**
     * Compile the template to a function for optimized performance.  Recommended if the template will be used frequently.
     * @return {Function} The compiled function
     */
    compile : function(){return this;}

    /**
     * @property re
     * @hide
     */
    /**
     * @property disableFormats
     * @hide
     */
    /**
     * @method set
     * @hide
     */

});
/**
 * Alias for {@link #applyTemplate}
 * Returns an HTML fragment of this template with the specified values applied.
 * @param {Object/Array} values The template values. Can be an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})
 * @return {String} The HTML fragment
 * @member CQ.Ext.XTemplate
 * @method apply
 */
CQ.Ext.XTemplate.prototype.apply = CQ.Ext.XTemplate.prototype.applyTemplate;

/**
 * Creates a template from the passed element's value (display:none textarea, preferred) or innerHTML.
 * @param {String/HTMLElement} el A DOM element or its id
 * @return {CQ.Ext.Template} The created template
 * @static
 */
CQ.Ext.XTemplate.from = function(el){
    el = CQ.Ext.getDom(el);
    return new CQ.Ext.XTemplate(el.value || el.innerHTML);
};/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.util.CSS
 * Utility class for manipulating CSS rules
 * @singleton
 */
CQ.Ext.util.CSS = function(){
	var rules = null;
   	var doc = document;

    var camelRe = /(-[a-z])/gi;
    var camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };

   return {
   /**
    * Creates a stylesheet from a text blob of rules.
    * These rules will be wrapped in a STYLE tag and appended to the HEAD of the document.
    * @param {String} cssText The text containing the css rules
    * @param {String} id An id to add to the stylesheet for later removal
    * @return {StyleSheet}
    */
   createStyleSheet : function(cssText, id){
       var ss;
       var head = doc.getElementsByTagName("head")[0];
       var rules = doc.createElement("style");
       rules.setAttribute("type", "text/css");
       if(id){
           rules.setAttribute("id", id);
       }
       if(CQ.Ext.isIE){
           head.appendChild(rules);
           ss = rules.styleSheet;
           ss.cssText = cssText;
       }else{
           try{
                rules.appendChild(doc.createTextNode(cssText));
           }catch(e){
               rules.cssText = cssText;
           }
           head.appendChild(rules);
           ss = rules.styleSheet ? rules.styleSheet : (rules.sheet || doc.styleSheets[doc.styleSheets.length-1]);
       }
       this.cacheStyleSheet(ss);
       return ss;
   },

   /**
    * Removes a style or link tag by id
    * @param {String} id The id of the tag
    */
   removeStyleSheet : function(id){
       var existing = doc.getElementById(id);
       if(existing){
           existing.parentNode.removeChild(existing);
       }
   },

   /**
    * Dynamically swaps an existing stylesheet reference for a new one
    * @param {String} id The id of an existing link tag to remove
    * @param {String} url The href of the new stylesheet to include
    */
   swapStyleSheet : function(id, url){
       this.removeStyleSheet(id);
       var ss = doc.createElement("link");
       ss.setAttribute("rel", "stylesheet");
       ss.setAttribute("type", "text/css");
       ss.setAttribute("id", id);
       ss.setAttribute("href", url);
       doc.getElementsByTagName("head")[0].appendChild(ss);
   },

   /**
    * Refresh the rule cache if you have dynamically added stylesheets
    * @return {Object} An object (hash) of rules indexed by selector
    */
   refreshCache : function(){
       return this.getRules(true);
   },

   // private
   cacheStyleSheet : function(ss){
       if(!rules){
           rules = {};
       }
       try{// try catch for cross domain access issue
           var ssRules = ss.cssRules || ss.rules;
           for(var j = ssRules.length-1; j >= 0; --j){
               rules[ssRules[j].selectorText] = ssRules[j];
           }
       }catch(e){}
   },

   /**
    * Gets all css rules for the document
    * @param {Boolean} refreshCache true to refresh the internal cache
    * @return {Object} An object (hash) of rules indexed by selector
    */
   getRules : function(refreshCache){
   		if(rules == null || refreshCache){
   			rules = {};
   			var ds = doc.styleSheets;
   			for(var i =0, len = ds.length; i < len; i++){
   			    try{
    		        this.cacheStyleSheet(ds[i]);
    		    }catch(e){}
	        }
   		}
   		return rules;
   	},

   	/**
    * Gets an an individual CSS rule by selector(s)
    * @param {String/Array} selector The CSS selector or an array of selectors to try. The first selector that is found is returned.
    * @param {Boolean} refreshCache true to refresh the internal cache if you have recently updated any rules or added styles dynamically
    * @return {CSSRule} The CSS rule or null if one is not found
    */
   getRule : function(selector, refreshCache){
   		var rs = this.getRules(refreshCache);
   		if(!CQ.Ext.isArray(selector)){
   		    return rs[selector];
   		}
   		for(var i = 0; i < selector.length; i++){
			if(rs[selector[i]]){
				return rs[selector[i]];
			}
		}
		return null;
   	},


   	/**
    * Updates a rule property
    * @param {String/Array} selector If it's an array it tries each selector until it finds one. Stops immediately once one is found.
    * @param {String} property The css property
    * @param {String} value The new value for the property
    * @return {Boolean} true If a rule was found and updated
    */
   updateRule : function(selector, property, value){
   		if(!CQ.Ext.isArray(selector)){
   			var rule = this.getRule(selector);
   			if(rule){
   				rule.style[property.replace(camelRe, camelFn)] = value;
   				return true;
   			}
   		}else{
   			for(var i = 0; i < selector.length; i++){
   				if(this.updateRule(selector[i], property, value)){
   					return true;
   				}
   			}
   		}
   		return false;
   	}
   };
}();/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 @class CQ.Ext.util.ClickRepeater
 @extends CQ.Ext.util.Observable

 A wrapper class which can be applied to any element. Fires a "click" event while the
 mouse is pressed. The interval between firings may be specified in the config but
 defaults to 20 milliseconds.

 Optionally, a CSS class may be applied to the element during the time it is pressed.

 @cfg {Mixed} el The element to act as a button.
 @cfg {Number} delay The initial delay before the repeating event begins firing.
 Similar to an autorepeat key delay.
 @cfg {Number} interval The interval between firings of the "click" event. Default 20 ms.
 @cfg {String} pressClass A CSS class name to be applied to the element while pressed.
 @cfg {Boolean} accelerate True if autorepeating should start slowly and accelerate.
           "interval" and "delay" are ignored.
 @cfg {Boolean} preventDefault True to prevent the default click event
 @cfg {Boolean} stopDefault True to stop the default click event

 @history
    2007-02-02 jvs Original code contributed by Nige "Animal" White
    2007-02-02 jvs Renamed to ClickRepeater
    2007-02-03 jvs Modifications for FF Mac and Safari

 @constructor
 @param {Mixed} el The element to listen on
 @param {Object} config
 */
CQ.Ext.util.ClickRepeater = function(el, config)
{
    this.el = CQ.Ext.get(el);
    this.el.unselectable();

    CQ.Ext.apply(this, config);

    this.addEvents(
    /**
     * @event mousedown
     * Fires when the mouse button is depressed.
     * @param {CQ.Ext.util.ClickRepeater} this
     */
        "mousedown",
    /**
     * @event click
     * Fires on a specified interval during the time the element is pressed.
     * @param {CQ.Ext.util.ClickRepeater} this
     */
        "click",
    /**
     * @event mouseup
     * Fires when the mouse key is released.
     * @param {CQ.Ext.util.ClickRepeater} this
     */
        "mouseup"
    );

    this.el.on("mousedown", this.handleMouseDown, this);
    if(this.preventDefault || this.stopDefault){
        this.el.on("click", function(e){
            if(this.preventDefault){
                e.preventDefault();
            }
            if(this.stopDefault){
                e.stopEvent();
            }
        }, this);
    }

    // allow inline handler
    if(this.handler){
        this.on("click", this.handler,  this.scope || this);
    }

    CQ.Ext.util.ClickRepeater.superclass.constructor.call(this);
};

CQ.Ext.extend(CQ.Ext.util.ClickRepeater, CQ.Ext.util.Observable, {
    interval : 20,
    delay: 250,
    preventDefault : true,
    stopDefault : false,
    timer : 0,

    // private
    handleMouseDown : function(){
        clearTimeout(this.timer);
        this.el.blur();
        if(this.pressClass){
            this.el.addClass(this.pressClass);
        }
        this.mousedownTime = new Date();

        CQ.Ext.getDoc().on("mouseup", this.handleMouseUp, this);
        this.el.on("mouseout", this.handleMouseOut, this);

        this.fireEvent("mousedown", this);
        this.fireEvent("click", this);

//      Do not honor delay or interval if acceleration wanted.
        if (this.accelerate) {
            this.delay = 400;
	    }
        this.timer = this.click.defer(this.delay || this.interval, this);
    },

    // private
    click : function(){
        this.fireEvent("click", this);
        this.timer = this.click.defer(this.accelerate ?
            this.easeOutExpo(this.mousedownTime.getElapsed(),
                400,
                -390,
                12000) :
            this.interval, this);
    },

    easeOutExpo : function (t, b, c, d) {
        return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
    },

    // private
    handleMouseOut : function(){
        clearTimeout(this.timer);
        if(this.pressClass){
            this.el.removeClass(this.pressClass);
        }
        this.el.on("mouseover", this.handleMouseReturn, this);
    },

    // private
    handleMouseReturn : function(){
        this.el.un("mouseover", this.handleMouseReturn, this);
        if(this.pressClass){
            this.el.addClass(this.pressClass);
        }
        this.click();
    },

    // private
    handleMouseUp : function(){
        clearTimeout(this.timer);
        this.el.un("mouseover", this.handleMouseReturn, this);
        this.el.un("mouseout", this.handleMouseOut, this);
        CQ.Ext.getDoc().un("mouseup", this.handleMouseUp, this);
        this.el.removeClass(this.pressClass);
        this.fireEvent("mouseup", this);
    }
});/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.KeyNav
 * Provides a convenient wrapper for normalized keyboard navigation.  KeyNav allows you to bind
 * navigation keys to function calls that will get called when the keys are pressed, providing an easy
 * way to implement custom navigation schemes for any UI component.
 * The following are all of the possible keys that can be implemented: enter, left, right, up, down, tab, esc,
 * pageUp, pageDown, del, home, end.  Usage:
 
var nav = new CQ.Ext.KeyNav("my-element", {
    "left" : function(e){
        this.moveLeft(e.ctrlKey);
    },
    "right" : function(e){
        this.moveRight(e.ctrlKey);
    },
    "enter" : function(e){
        this.save();
    },
    scope : this
});

 * @constructor
 * @param {Mixed} el The element to bind to
 * @param {Object} config The config
 */
CQ.Ext.KeyNav = function(el, config){
    this.el = CQ.Ext.get(el);
    CQ.Ext.apply(this, config);
    if(!this.disabled){
        this.disabled = true;
        this.enable();
    }
};

CQ.Ext.KeyNav.prototype = {
    /**
     * @cfg {Boolean} disabled
     * True to disable this KeyNav instance (defaults to false)
     */
    disabled : false,
    /**
     * @cfg {String} defaultEventAction
     * The method to call on the {@link CQ.Ext.EventObject} after this KeyNav intercepts a key.  Valid values are
     * {@link CQ.Ext.EventObject#stopEvent}, {@link CQ.Ext.EventObject#preventDefault} and
     * {@link CQ.Ext.EventObject#stopPropagation} (defaults to 'stopEvent')
     */
    defaultEventAction: "stopEvent",
    /**
     * @cfg {Boolean} forceKeyDown
     * Handle the keydown event instead of keypress (defaults to false).  KeyNav automatically does this for IE since
     * IE does not propagate special keys on keypress, but setting this to true will force other browsers to also
     * handle keydown instead of keypress.
     */
    forceKeyDown : false,

    // private
    prepareEvent : function(e){
        var k = e.getKey();
        var h = this.keyToHandler[k];
        //if(h && this[h]){
        //    e.stopPropagation();
        //}
        if(CQ.Ext.isSafari2 && h && k >= 37 && k <= 40){
            e.stopEvent();
        }
    },

    // private
    relay : function(e){
        var k = e.getKey();
        var h = this.keyToHandler[k];
        if(h && this[h]){
            if(this.doRelay(e, this[h], h) !== true){
                e[this.defaultEventAction]();
            }
        }
    },

    // private
    doRelay : function(e, h, hname){
        return h.call(this.scope || this, e);
    },

    // possible handlers
    enter : false,
    left : false,
    right : false,
    up : false,
    down : false,
    tab : false,
    esc : false,
    pageUp : false,
    pageDown : false,
    del : false,
    home : false,
    end : false,

    // quick lookup hash
    keyToHandler : {
        37 : "left",
        39 : "right",
        38 : "up",
        40 : "down",
        33 : "pageUp",
        34 : "pageDown",
        46 : "del",
        36 : "home",
        35 : "end",
        13 : "enter",
        27 : "esc",
        9  : "tab"
    },

	/**
	 * Enable this KeyNav
	 */
	enable: function(){
		if(this.disabled){
            if(this.forceKeyDown || CQ.Ext.isIE || CQ.Ext.isSafari3 || CQ.Ext.isAir){
                this.el.on("keydown", this.relay,  this);
            }else{
                this.el.on("keydown", this.prepareEvent,  this);
                this.el.on("keypress", this.relay,  this);
            }
		    this.disabled = false;
		}
	},

	/**
	 * Disable this KeyNav
	 */
	disable: function(){
		if(!this.disabled){
		    if(this.forceKeyDown || CQ.Ext.isIE || CQ.Ext.isSafari3 || CQ.Ext.isAir){
                this.el.un("keydown", this.relay);
            }else{
                this.el.un("keydown", this.prepareEvent);
                this.el.un("keypress", this.relay);
            }
		    this.disabled = true;
		}
	}
};/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.KeyMap
 * Handles mapping keys to actions for an element. One key map can be used for multiple actions.
 * The constructor accepts the same config object as defined by {@link #addBinding}.
 * If you bind a callback function to a KeyMap, anytime the KeyMap handles an expected key
 * combination it will call the function with this signature (if the match is a multi-key
 * combination the callback will still be called only once): (String key, CQ.Ext.EventObject e)
 * A KeyMap can also handle a string representation of keys.

 * Usage:
 
// map one key by key code
var map = new CQ.Ext.KeyMap("my-element", {
    key: 13, // or CQ.Ext.EventObject.ENTER
    fn: myHandler,
    scope: myObject
});

// map multiple keys to one action by string
var map = new CQ.Ext.KeyMap("my-element", {
    key: "a\r\n\t",
    fn: myHandler,
    scope: myObject
});

// map multiple keys to multiple actions by strings and array of codes
var map = new CQ.Ext.KeyMap("my-element", [
    {
        key: [10,13],
        fn: function(){ alert("Return was pressed"); }
    }, {
        key: "abc",
        fn: function(){ alert('a, b or c was pressed'); }
    }, {
        key: "\t",
        ctrl:true,
        shift:true,
        fn: function(){ alert('Control + shift + tab was pressed.'); }
    }
]);

 * Note: A KeyMap starts enabled
 * @constructor
 * @param {Mixed} el The element to bind to
 * @param {Object} config The config (see {@link #addBinding})
 * @param {String} eventName (optional) The event to bind to (defaults to "keydown")
 */
CQ.Ext.KeyMap = function(el, config, eventName){
    this.el  = CQ.Ext.get(el);
    this.eventName = eventName || "keydown";
    this.bindings = [];
    if(config){
        this.addBinding(config);
    }
    this.enable();
};

CQ.Ext.KeyMap.prototype = {
    /**
     * True to stop the event from bubbling and prevent the default browser action if the
     * key was handled by the KeyMap (defaults to false)
     * @type Boolean
     */
    stopEvent : false,

    /**
     * Add a new binding to this KeyMap. The following config object properties are supported:
     * Property    Type             Description
----------  ---------------  ----------------------------------------------------------------------
key         String/Array     A single keycode or an array of keycodes to handle
shift       Boolean          True to handle key only when shift is pressed (defaults to false)
ctrl        Boolean          True to handle key only when ctrl is pressed (defaults to false)
alt         Boolean          True to handle key only when alt is pressed (defaults to false)
handler     Function         The function to call when KeyMap finds the expected key combination
fn          Function         Alias of handler (for backwards-compatibility)
scope       Object           The scope of the callback function
stopEvent   Boolean          True to stop the event

     *
     * Usage:
     * 
// Create a KeyMap
var map = new CQ.Ext.KeyMap(document, {
    key: CQ.Ext.EventObject.ENTER,
    fn: handleKey,
    scope: this
});

//Add a new binding to the existing KeyMap later
map.addBinding({
    key: 'abc',
    shift: true,
    fn: handleKey,
    scope: this
});

     * @param {Object/Array} config A single KeyMap config or an array of configs
     */
	addBinding : function(config){
        if(CQ.Ext.isArray(config)){
            for(var i = 0, len = config.length; i < len; i++){
                this.addBinding(config[i]);
            }
            return;
        }
        var keyCode = config.key,
            shift = config.shift,
            ctrl = config.ctrl,
            alt = config.alt,
            fn = config.fn || config.handler,
            scope = config.scope;

	if (config.stopEvent) {
	    this.stopEvent = config.stopEvent;
	}

        if(typeof keyCode == "string"){
            var ks = [];
            var keyString = keyCode.toUpperCase();
            for(var j = 0, len = keyString.length; j < len; j++){
                ks.push(keyString.charCodeAt(j));
            }
            keyCode = ks;
        }
        var keyArray = CQ.Ext.isArray(keyCode);

        var handler = function(e){
            if((!shift || e.shiftKey) && (!ctrl || e.ctrlKey) &&  (!alt || e.altKey)){
                var k = e.getKey();
                if(keyArray){
                    for(var i = 0, len = keyCode.length; i < len; i++){
                        if(keyCode[i] == k){
                          if(this.stopEvent){
                              e.stopEvent();
                          }
                          fn.call(scope || window, k, e);
                          return;
                        }
                    }
                }else{
                    if(k == keyCode){
                        if(this.stopEvent){
                           e.stopEvent();
                        }
                        fn.call(scope || window, k, e);
                    }
                }
            }
        };
        this.bindings.push(handler);
	},

    /**
     * Shorthand for adding a single key listener
     * @param {Number/Array/Object} key Either the numeric key code, array of key codes or an object with the
     * following options:
     * {key: (number or array), shift: (true/false), ctrl: (true/false), alt: (true/false)}
     * @param {Function} fn The function to call
     * @param {Object} scope (optional) The scope of the function
     */
    on : function(key, fn, scope){
        var keyCode, shift, ctrl, alt;
        if(typeof key == "object" && !CQ.Ext.isArray(key)){
            keyCode = key.key;
            shift = key.shift;
            ctrl = key.ctrl;
            alt = key.alt;
        }else{
            keyCode = key;
        }
        this.addBinding({
            key: keyCode,
            shift: shift,
            ctrl: ctrl,
            alt: alt,
            fn: fn,
            scope: scope
        })
    },

    // private
    handleKeyDown : function(e){
	    if(this.enabled){ //just in case
    	    var b = this.bindings;
    	    for(var i = 0, len = b.length; i < len; i++){
    	        b[i].call(this, e);
    	    }
	    }
	},

	/**
	 * Returns true if this KeyMap is enabled
	 * @return {Boolean}
	 */
	isEnabled : function(){
	    return this.enabled;
	},

	/**
	 * Enables this KeyMap
	 */
	enable: function(){
		if(!this.enabled){
		    this.el.on(this.eventName, this.handleKeyDown, this);
		    this.enabled = true;
		}
	},

	/**
	 * Disable this KeyMap
	 */
	disable: function(){
		if(this.enabled){
		    this.el.removeListener(this.eventName, this.handleKeyDown, this);
		    this.enabled = false;
		}
	}
};/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/**
 * @class CQ.Ext.util.TextMetrics
 * Provides precise pixel measurements for blocks of text so that you can determine exactly how high and
 * wide, in pixels, a given block of text will be.
 * @singleton
 */
CQ.Ext.util.TextMetrics = function(){
    var shared;
    return {
        /**
         * Measures the size of the specified text
         * @param {String/HTMLElement} el The element, dom node or id from which to copy existing CSS styles
         * that can affect the size of the rendered text
         * @param {String} text The text to measure
         * @param {Number} fixedWidth (optional) If the text will be multiline, you have to set a fixed width
         * in order to accurately measure the text height
         * @return {Object} An object containing the text's size {width: (width), height: (height)}
         */
        measure : function(el, text, fixedWidth){
            if(!shared){
                shared = CQ.Ext.util.TextMetrics.Instance(el, fixedWidth);
            }
            shared.bind(el);
            shared.setFixedWidth(fixedWidth || 'auto');
            return shared.getSize(text);
        },

        /**
         * Return a unique TextMetrics instance that can be bound directly to an element and reused.  This reduces
         * the overhead of multiple calls to initialize the style properties on each measurement.
         * @param {String/HTMLElement} el The element, dom node or id that the instance will be bound to
         * @param {Number} fixedWidth (optional) If the text will be multiline, you have to set a fixed width
         * in order to accurately measure the text height
         * @return {CQ.Ext.util.TextMetrics.Instance} instance The new instance
         */
        createInstance : function(el, fixedWidth){
            return CQ.Ext.util.TextMetrics.Instance(el, fixedWidth);
        }
    };
}();

CQ.Ext.util.TextMetrics.Instance = function(bindTo, fixedWidth){
    var ml = new CQ.Ext.Element(document.createElement('div'));
    // CQ:START
    // render all CQ.Ext elements to the CQ root
//    document.body.appendChild(ml.dom);
    CQ.Util.getRoot().appendChild(ml.dom);
    // CQ:END

    ml.position('absolute');
    ml.setLeftTop(-1000, -1000);
    ml.hide();

    if(fixedWidth){
        ml.setWidth(fixedWidth);
    }

    var instance = {
        /**
         * Returns the size of the specified text based on the internal element's style and width properties
         * @param {String} text The text to measure
         * @return {Object} An object containing the text's size {width: (width), height: (height)}
         */
        getSize : function(text){
            ml.update(text);
            var s = ml.getSize();
            ml.update('');
            return s;
        },

        /**
         * Binds this TextMetrics instance to an element from which to copy existing CSS styles
         * that can affect the size of the rendered text
         * @param {String/HTMLElement} el The element, dom node or id
         */
        bind : function(el){
            ml.setStyle(
                CQ.Ext.fly(el).getStyles('font-size','font-style', 'font-weight', 'font-family','line-height', 'text-transform', 'letter-spacing')
            );
        },

        /**
         * Sets a fixed width on the internal measurement element.  If the text will be multiline, you have
         * to set a fixed width in order to accurately measure the text height.
         * @param {Number} width The width to set on the element
         */
        setFixedWidth : function(width){
            ml.setWidth(width);
        },

        /**
         * Returns the measured width of the specified text
         * @param {String} text The text to measure
         * @return {Number} width The width in pixels
         */
        getWidth : function(text){
            ml.dom.style.width = 'auto';
            return this.getSize(text).width;
        },

        /**
         * Returns the measured height of the specified text.  For multiline text, be sure to call
         * {@link #setFixedWidth} if necessary.
         * @param {String} text The text to measure
         * @return {Number} height The height in pixels
         */
        getHeight : function(text){
            return this.getSize(text).height;
        }
    };

    instance.bind(bindTo);

    return instance;
};

// backwards compat
CQ.Ext.Element.measureText = CQ.Ext.util.TextMetrics.measure;/*
 * Ext JS Library 2.2
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * licensing@extjs.com
 *
 * http://extjs.com/license
 */

/*
 * These classes are derivatives of the similarly named classes in the YUI Library.
 * The original license:
 * Copyright (c) 2006, Yahoo! Inc. All rights reserved.
 * Code licensed under the BSD License:
 * http://developer.yahoo.net/yui/license.txt
 */

(function() {

var Event=CQ.Ext.EventManager;
var Dom=CQ.Ext.lib.Dom;

/**
 * @class CQ.Ext.dd.DragDrop
 * Defines the interface and base operation of items that that can be
 * dragged or can be drop targets.  It was designed to be extended, overriding
 * the event handlers for startDrag, onDrag, onDragOver and onDragOut.
 * Up to three html elements can be associated with a DragDrop instance:
 * 
 * linked element: the element that is passed into the constructor.
 * This is the element which defines the boundaries for interaction with
 * other DragDrop objects.
 * handle element(s): The drag operation only occurs if the element that
 * was clicked matches a handle element.  By default this is the linked
 * element, but there are times that you will want only a portion of the
 * linked element to initiate the drag operation, and the setHandleElId()
 * method provides a way to define this.
 * drag element: this represents the element that would be moved along
 * with the cursor during a drag operation.  By default, this is the linked
 * element itself as in {@link CQ.Ext.dd.DD}.  setDragElId() lets you define
 * a separate element that would be moved, as in {@link CQ.Ext.dd.DDProxy}.
 * 
 * 
 * This class should not be instantiated until the onload event to ensure that
 * the associated elements are available.
 * The following would define a DragDrop obj that would interact with any
 * other DragDrop obj in the "group1" group:
 *  *  dd = new CQ.Ext.dd.DragDrop("div1", "group1");
 * 
 * Since none of the event handlers have been implemented, nothing would
 * actually happen if you were to run the code above.  Normally you would
 * override this class or one of the default implementations, but you can
 * also override the methods you want on an instance of the class...
 *  *  dd.onDragDrop = function(e, id) {
 *    alert("dd was dropped on " + id);
 *  }
 * 
 * @constructor
 * @param {String} id of the element that is linked to this instance
 * @param {String} sGroup the group of related DragDrop objects
 * @param {object} config an object containing configurable attributes
 *                Valid properties for DragDrop:
 *                    padding, isTarget, maintainOffset, primaryButtonOnly
 */
CQ.Ext.dd.DragDrop = function(id, sGroup, config) {
    if(id) {
        this.init(id, sGroup, config);
    }
};

CQ.Ext.dd.DragDrop.prototype = {

    /**
     * The id of the element associated with this object.  This is what we
     * refer to as the "linked element" because the size and position of
     * this element is used to determine when the drag and drop objects have
     * interacted.
     * @property id
     * @type String
     */
    id: null,

    /**
     * Configuration attributes passed into the constructor
     * @property config
     * @type object
     */
    config: null,

    /**
     * The id of the element that will be dragged.  By default this is same
     * as the linked element , but could be changed to another element. Ex:
     * CQ.Ext.dd.DDProxy
     * @property dragElId
     * @type String
     * @private
     */
    dragElId: null,

    /**
     * The ID of the element that initiates the drag operation.  By default
     * this is the linked element, but could be changed to be a child of this
     * element.  This lets us do things like only starting the drag when the
     * header element within the linked html element is clicked.
     * @property handleElId
     * @type String
     * @private
     */
    handleElId: null,

    /**
     * An object who's property names identify HTML tags to be considered invalid as drag handles.
     * A non-null property value identifies the tag as invalid. Defaults to the
     * following value which prevents drag operations from being initiated by <a> elements:
{
    A: "A"
}
     * @property invalidHandleTypes
     * @type Object
     */
    invalidHandleTypes: null,

    /**
     * An object who's property names identify the IDs of elements to be considered invalid as drag handles.
     * A non-null property value identifies the ID as invalid. For example, to prevent
     * dragging from being initiated on element ID "foo", use:
{
    foo: true
}
     * @property invalidHandleIds
     * @type Object
     */
    invalidHandleIds: null,

    /**
     * An Array of CSS class names for elements to be considered in valid as drag handles.
     * @property invalidHandleClasses
     * @type Array
     */
    invalidHandleClasses: null,

    /**
     * The linked element's absolute X position at the time the drag was
     * started
     * @property startPageX
     * @type int
     * @private
     */
    startPageX: 0,

    /**
     * The linked element's absolute X position at the time the drag was
     * started
     * @property startPageY
     * @type int
     * @private
     */
    startPageY: 0,

    /**
     * The group defines a logical collection of DragDrop objects that are
     * related.  Instances only get events when interacting with other
     * DragDrop object in the same group.  This lets us define multiple
     * groups using a single DragDrop subclass if we want.
     * @property groups
     * @type object An object in the format {'group1':true, 'group2':true}
     */
    groups: null,

    /**
     * Individual drag/drop instances can be locked.  This will prevent
     * onmousedown start drag.
     * @property locked
     * @type boolean
     * @private
     */
    locked: false,

    /**
     * Lock this instance
     * @method lock
     */
    lock: function() { this.locked = true; },

    /**
     * Unlock this instace
     * @method unlock
     */
    unlock: function() { this.locked = false; },

    /**
     * By default, all insances can be a drop target.  This can be disabled by
     * setting isTarget to false.
     * @property isTarget
     * @type boolean
     */
    isTarget: true,

    /**
     * The padding configured for this drag and drop object for calculating
     * the drop zone intersection with this object.
     * @property padding
     * @type int[] An array containing the 4 padding values: [top, right, bottom, left]
     */
    padding: null,

    /**
     * Cached reference to the linked element
     * @property _domRef
     * @private
     */
    _domRef: null,

    /**
     * Internal typeof flag
     * @property __ygDragDrop
     * @private
     */
    __ygDragDrop: true,

    /**
     * Set to true when horizontal contraints are applied
     * @property constrainX
     * @type boolean
     * @private
     */
    constrainX: false,

    /**
     * Set to true when vertical contraints are applied
     * @property constrainY
     * @type boolean
     * @private
     */
    constrainY: false,

    /**
     * The left constraint
     * @property minX
     * @type int
     * @private
     */
    minX: 0,

    /**
     * The right constraint
     * @property maxX
     * @type int
     * @private
     */
    maxX: 0,

    /**
     * The up constraint
     * @property minY
     * @type int
     * @type int
     * @private
     */
    minY: 0,

    /**
     * The down constraint
     * @property maxY
     * @type int
     * @private
     */
    maxY: 0,

    /**
     * Maintain offsets when we resetconstraints.  Set to true when you want
     * the position of the element relative to its parent to stay the same
     * when the page changes
     *
     * @property maintainOffset
     * @type boolean
     */
    maintainOffset: false,

    /**
     * Array of pixel locations the element will snap to if we specified a
     * horizontal graduation/interval.  This array is generated automatically
     * when you define a tick interval.
     * @property xTicks
     * @type int[]
     */
    xTicks: null,

    /**
     * Array of pixel locations the element will snap to if we specified a
     * vertical graduation/interval.  This array is generated automatically
     * when you define a tick interval.
     * @property yTicks
     * @type int[]
     */
    yTicks: null,

    /**
     * By default the drag and drop instance will only respond to the primary
     * button click (left button for a right-handed mouse).  Set to true to
     * allow drag and drop to start with any mouse click that is propogated
     * by the browser
     * @property primaryButtonOnly
     * @type boolean
     */
    primaryButtonOnly: true,

    /**
     * The availabe property is false until the linked dom element is accessible.
     * @property available
     * @type boolean
     */
    available: false,

    /**
     * By default, drags can only be initiated if the mousedown occurs in the
     * region the linked element is.  This is done in part to work around a
     * bug in some browsers that mis-report the mousedown if the previous
     * mouseup happened outside of the window.  This property is set to true
     * if outer handles are defined.
     *
     * @property hasOuterHandles
     * @type boolean
     * @default false
     */
    hasOuterHandles: false,

    /**
     * Code that executes immediately before the startDrag event
     * @method b4StartDrag
     * @private
     */
    b4StartDrag: function(x, y) { },

    /**
     * Abstract method called after a drag/drop object is clicked
     * and the drag or mousedown time thresholds have beeen met.
     * @method startDrag
     * @param {int} X click location
     * @param {int} Y click location
     */
    startDrag: function(x, y) { /* override this */ },

    /**
     * Code that executes immediately before the onDrag event
     * @method b4Drag
     * @private
     */
    b4Drag: function(e) { },

    /**
     * Abstract method called during the onMouseMove event while dragging an
     * object.
     * @method onDrag
     * @param {Event} e the mousemove event
     */
    onDrag: function(e) { /* override this */ },

    /**
     * Abstract method called when this element fist begins hovering over
     * another DragDrop obj
     * @method onDragEnter
     * @param {Event} e the mousemove event
     * @param {String|DragDrop[]} id In POINT mode, the element
     * id this is hovering over.  In INTERSECT mode, an array of one or more
     * dragdrop items being hovered over.
     */
    onDragEnter: function(e, id) { /* override this */ },

    /**
     * Code that executes immediately before the onDragOver event
     * @method b4DragOver
     * @private
     */
    b4DragOver: function(e) { },

    /**
     * Abstract method called when this element is hovering over another
     * DragDrop obj
     * @method onDragOver
     * @param {Event} e the mousemove event
     * @param {String|DragDrop[]} id In POINT mode, the element
     * id this is hovering over.  In INTERSECT mode, an array of dd items
     * being hovered over.
     */
    onDragOver: function(e, id) { /* override this */ },

    /**
     * Code that executes immediately before the onDragOut event
     * @method b4DragOut
     * @private
     */
    b4DragOut: function(e) { },

    /**
     * Abstract method called when we are no longer hovering over an element
     * @method onDragOut
     * @param {Event} e the mousemove event
     * @param {String|DragDrop[]} id In POINT mode, the element
     * id this was hovering over.  In INTERSECT mode, an array of dd items
     * that the mouse is no longer over.
     */
    onDragOut: function(e, id) { /* override this */ },

    /**
     * Code that executes immediately before the onDragDrop event
     * @method b4DragDrop
     * @private
     */
    b4DragDrop: function(e) { },

    /**
     * Abstract method called when this item is dropped on another DragDrop
     * obj
     * @method onDragDrop
     * @param {Event} e the mouseup event
     * @param {String|DragDrop[]} id In POINT mode, the element
     * id this was dropped on.  In INTERSECT mode, an array of dd items this
     * was dropped on.
     */
    onDragDrop: function(e, id) { /* override this */ },

    /**
     * Abstract method called when this item is dropped on an area with no
     * drop target
     * @method onInvalidDrop
     * @param {Event} e the mouseup event
     */
    onInvalidDrop: function(e) { /* override this */ },

    /**
     * Code that executes immediately before the endDrag event
     * @method b4EndDrag
     * @private
     */
    b4EndDrag: function(e) { },

    /**
     * Fired when we are done dragging the object
     * @method endDrag
     * @param {Event} e the mouseup event
     */
    endDrag: function(e) { /* override this */ },

    /**
     * Code executed immediately before the onMouseDown event
     * @method b4MouseDown
     * @param {Event} e the mousedown event
     * @private
     */
    b4MouseDown: function(e) {  },

    /**
     * Event handler that fires when a drag/drop obj gets a mousedown
     * @method onMouseDown
     * @param {Event} e the mousedown event
     */
    onMouseDown: function(e) { /* override this */ },

    /**
     * Event handler that fires when a drag/drop obj gets a mouseup
     * @method onMouseUp
     * @param {Event} e the mouseup event
     */
    onMouseUp: function(e) { /* override this */ },

    /**
     * Override the onAvailable method to do what is needed after the initial
     * position was determined.
     * @method onAvailable
     */
    onAvailable: function () {
    },

    /**
     * Provides default constraint padding to "constrainTo" elements (defaults to {left: 0, right:0, top:0, bottom:0}).
     * @type Object
     */
    defaultPadding : {left:0, right:0, top:0, bottom:0},

    /**
     * Initializes the drag drop object's constraints to restrict movement to a certain element.
 *
 * Usage:
 
 var dd = new CQ.Ext.dd.DDProxy("dragDiv1", "proxytest",
                { dragElId: "existingProxyDiv" });
 dd.startDrag = function(){
     this.constrainTo("parent-id");
 };
 
 * Or you can initalize it using the {@link CQ.Ext.Element} object:
 
 CQ.Ext.get("dragDiv1").initDDProxy("proxytest", {dragElId: "existingProxyDiv"}, {
     startDrag : function(){
         this.constrainTo("parent-id");
     }
 });
 
     * @param {Mixed} constrainTo The element to constrain to.
     * @param {Object/Number} pad (optional) Pad provides a way to specify "padding" of the constraints,
     * and can be either a number for symmetrical padding (4 would be equal to {left:4, right:4, top:4, bottom:4}) or
     * an object containing the sides to pad. For example: {right:10, bottom:10}
     * @param {Boolean} inContent (optional) Constrain the draggable in the content box of the element (inside padding and borders)
     */
    constrainTo : function(constrainTo, pad, inContent){
        if(typeof pad == "number"){
            pad = {left: pad, right:pad, top:pad, bottom:pad};
        }
        pad = pad || this.defaultPadding;
        var b = CQ.Ext.get(this.getEl()).getBox();
        var ce = CQ.Ext.get(constrainTo);
        var s = ce.getScroll();
        var c, cd = ce.dom;
        if(cd == document.body){
            c = { x: s.left, y: s.top, width: CQ.Ext.lib.Dom.getViewWidth(), height: CQ.Ext.lib.Dom.getViewHeight()};
        }else{
            var xy = ce.getXY();
            c = {x : xy[0]+s.left, y: xy[1]+s.top, width: cd.clientWidth, height: cd.clientHeight};
        }


        var topSpace = b.y - c.y;
        var leftSpace = b.x - c.x;

        this.resetConstraints();
        this.setXConstraint(leftSpace - (pad.left||0), // left
                c.width - leftSpace - b.width - (pad.right||0), //right
				this.xTickSize
        );
        this.setYConstraint(topSpace - (pad.top||0), //top
                c.height - topSpace - b.height - (pad.bottom||0), //bottom
				this.yTickSize
        );
    },

    /**
     * Returns a reference to the linked element
     * @method getEl
     * @return {HTMLElement} the html element
     */
    getEl: function() {
        if (!this._domRef) {
            this._domRef = CQ.Ext.getDom(this.id);
        }

        return this._domRef;
    },

    /**
     * Returns a reference to the actual element to drag.  By default this is
     * the same as the html element, but it can be assigned to another
     * element. An example of this can be found in CQ.Ext.dd.DDProxy
     * @method getDragEl
     * @return {HTMLElement} the html element
     */
    getDragEl: function() {
        return CQ.Ext.getDom(this.dragElId);
    },

    /**
     * Sets up the DragDrop object.  Must be called in the constructor of any
     * CQ.Ext.dd.DragDrop subclass
     * @method init
     * @param id the id of the linked element
     * @param {String} sGroup the group of related items
     * @param {object} config configuration attributes
     */
    init: function(id, sGroup, config) {
        this.initTarget(id, sGroup, config);
        Event.on(this.id, "mousedown", this.handleMouseDown, this);
        // Event.on(this.id, "selectstart", Event.preventDefault);
    },

    /**
     * Initializes Targeting functionality only... the object does not
     * get a mousedown handler.
     * @method initTarget
     * @param id the id of the linked element
     * @param {String} sGroup the group of related items
     * @param {object} config configuration attributes
     */
    initTarget: function(id, sGroup, config) {

        // configuration attributes
        this.config = config || {};

        // create a local reference to the drag and drop manager
        this.DDM = CQ.Ext.dd.DDM;
        // initialize the groups array
        this.groups = {};

        // assume that we have an element reference instead of an id if the
        // parameter is not a string
        if (typeof id !== "string") {
            id = CQ.Ext.id(id);
        }

        // set the id
        this.id = id;

        // add to an interaction group
        this.addToGroup((sGroup) ? sGroup : "default");

        // We don't want to register this as the handle with the manager
        // so we just set the id rather than calling the setter.
        this.handleElId = id;

        // the linked element is the element that gets dragged by default
        this.setDragElId(id);

        // by default, clicked anchors will not start drag operations.
        this.invalidHandleTypes = { A: "A" };
        this.invalidHandleIds = {};
        this.invalidHandleClasses = [];

        this.applyConfig();

        this.handleOnAvailable();
    },

    /**
     * Applies the configuration parameters that were passed into the constructor.
     * This is supposed to happen at each level through the inheritance chain.  So
     * a DDProxy implentation will execute apply config on DDProxy, DD, and
     * DragDrop in order to get all of the parameters that are available in
     * each object.
     * @method applyConfig
     */
    applyConfig: function() {

        // configurable properties:
        //    padding, isTarget, maintainOffset, primaryButtonOnly
        this.padding           = this.config.padding || [0, 0, 0, 0];
        this.isTarget          = (this.config.isTarget !== false);
        this.maintainOffset    = (this.config.maintainOffset);
        this.primaryButtonOnly = (this.config.primaryButtonOnly !== false);

    },

    /**
     * Executed when the linked element is available
     * @method handleOnAvailable
     * @private
     */
    handleOnAvailable: function() {
        this.available = true;
        this.resetConstraints();
        this.onAvailable();
    },

     /**
     * Configures the padding for the target zone in px.  Effectively expands
     * (or reduces) the virtual object size for targeting calculations.
     * Supports css-style shorthand; if only one parameter is passed, all sides
     * will have that padding, and if only two are passed, the top and bottom
     * will have the first param, the left and right the second.
     * @method setPadding
     * @param {int} iTop    Top pad
     * @param {int} iRight  Right pad
     * @param {int} iBot    Bot pad
     * @param {int} iLeft   Left pad
     */
    setPadding: function(iTop, iRight, iBot, iLeft) {
        // this.padding = [iLeft, iRight, iTop, iBot];
        if (!iRight && 0 !== iRight) {
            this.padding = [iTop, iTop, iTop, iTop];
        } else if (!iBot && 0 !== iBot) {
            this.padding = [iTop, iRight, iTop, iRight];
        } else {
            this.padding = [iTop, iRight, iBot, iLeft];
        }
    },

    /**
     * Stores the initial placement of the linked element.
     * @method setInitialPosition
     * @param {int} diffX   the X offset, default 0
     * @param {int} diffY   the Y offset, default 0
     */
    setInitPosition: function(diffX, diffY) {
        var el = this.getEl();

        if (!this.DDM.verifyEl(el)) {
            return;
        }

        var dx = diffX || 0;
        var dy = diffY || 0;

        var p = Dom.getXY( el );

        this.initPageX = p[0] - dx;
        this.initPageY = p[1] - dy;

        this.lastPageX = p[0];
        this.lastPageY = p[1];


        this.setStartPosition(p);
    },

    /**
     * Sets the start position of the element.  This is set when the obj
     * is initialized, the reset when a drag is started.
     * @method setStartPosition
     * @param pos current position (from previous lookup)
     * @private
     */
    setStartPosition: function(pos) {
        var p = pos || Dom.getXY( this.getEl() );
        this.deltaSetXY = null;

        this.startPageX = p[0];
        this.startPageY = p[1];
    },

    /**
     * Add this instance to a group of related drag/drop objects.  All
     * instances belong to at least one group, and can belong to as many
     * groups as needed.
     * @method addToGroup
     * @param sGroup {string} the name of the group
     */
    addToGroup: function(sGroup) {
        this.groups[sGroup] = true;
        this.DDM.regDragDrop(this, sGroup);
    },

    /**
     * Remove's this instance from the supplied interaction group
     * @method removeFromGroup
     * @param {string}  sGroup  The group to drop
     */
    removeFromGroup: function(sGroup) {
        if (this.groups[sGroup]) {
            delete this.groups[sGroup];
        }

        this.DDM.removeDDFromGroup(this, sGroup);
    },

    /**
     * Allows you to specify that an element other than the linked element
     * will be moved with the cursor during a drag
     * @method setDragElId
     * @param id {string} the id of the element that will be used to initiate the drag
     */
    setDragElId: function(id) {
        this.dragElId = id;
    },

    /**
     * Allows you to specify a child of the linked element that should be
     * used to initiate the drag operation.  An example of this would be if
     * you have a content div with text and links.  Clicking anywhere in the
     * content area would normally start the drag operation.  Use this method
     * to specify that an element inside of the content div is the element
     * that starts the drag operation.
     * @method setHandleElId
     * @param id {string} the id of the element that will be used to
     * initiate the drag.
     */
    setHandleElId: function(id) {
        if (typeof id !== "string") {
            id = CQ.Ext.id(id);
        }
        this.handleElId = id;
        this.DDM.regHandle(this.id, id);
    },

    /**
     * Allows you to set an element outside of the linked element as a drag
     * handle
     * @method setOuterHandleElId
     * @param id the id of the element that will be used to initiate the drag
     */
    setOuterHandleElId: function(id) {
        if (typeof id !== "string") {
            id = CQ.Ext.id(id);
        }
        Event.on(id, "mousedown",
                this.handleMouseDown, this);
        this.setHandleElId(id);

        this.hasOuterHandles = true;
    },

    /**
     * Remove all drag and drop hooks for this element
     * @method unreg
     */
    unreg: function() {
        Event.un(this.id, "mousedown",
                this.handleMouseDown);
        this._domRef = null;
        this.DDM._remove(this);
    },

    destroy : function(){
        this.unreg();
    },

    /**
     * Returns true if this instance is locked, or the drag drop mgr is locked
     * (meaning that all drag/drop is disabled on the page.)
     * @method isLocked
     * @return {boolean} true if this obj or all drag/drop is locked, else
     * false
     */
    isLocked: function() {
        return (this.DDM.isLocked() || this.locked);
    },

    /**
     * Fired when this object is clicked
     * @method handleMouseDown
     * @param {Event} e
     * @param {CQ.Ext.dd.DragDrop} oDD the clicked dd object (this dd obj)
     * @private
     */
    handleMouseDown: function(e, oDD){
        if (this.primaryButtonOnly && e.button != 0) {
            return;
        }

        if (this.isLocked()) {
            return;
        }

        this.DDM.refreshCache(this.groups);

        var pt = new CQ.Ext.lib.Point(CQ.Ext.lib.Event.getPageX(e), CQ.Ext.lib.Event.getPageY(e));
        if (!this.hasOuterHandles && !this.DDM.isOverTarget(pt, this) )  {
        } else {
            if (this.clickValidator(e)) {

                // set the initial element position
                this.setStartPosition();


                this.b4MouseDown(e);
                this.onMouseDown(e);

                this.DDM.handleMouseDown(e, this);

                this.DDM.stopEvent(e);
            } else {


            }
        }
    },

    clickValidator: function(e) {
        var target = e.getTarget();
        return ( this.isValidHandleChild(target) &&
                    (this.id == this.handleElId ||
                        this.DDM.handleWasClicked(target, this.id)) );
    },

    /**
     * Allows you to specify a tag name that should not start a drag operation
     * when clicked.  This is designed to facilitate embedding links within a
     * drag handle that do something other than start the drag.
     * @method addInvalidHandleType
     * @param {string} tagName the type of element to exclude
     */
    addInvalidHandleType: function(tagName) {
        var type = tagName.toUpperCase();
        this.invalidHandleTypes[type] = type;
    },

    /**
     * Lets you to specify an element id for a child of a drag handle
     * that should not initiate a drag
     * @method addInvalidHandleId
     * @param {string} id the element id of the element you wish to ignore
     */
    addInvalidHandleId: function(id) {
        if (typeof id !== "string") {
            id = CQ.Ext.id(id);
        }
        this.invalidHandleIds[id] = id;
    },

    /**
     * Lets you specify a css class of elements that will not initiate a drag
     * @method addInvalidHandleClass
     * @param {string} cssClass the class of the elements you wish to ignore
     */
    addInvalidHandleClass: function(cssClass) {
        this.invalidHandleClasses.push(cssClass);
    },

    /**
     * Unsets an excluded tag name set by addInvalidHandleType
     * @method removeInvalidHandleType
     * @param {string} tagName the type of element to unexclude
     */
    removeInvalidHandleType: function(tagName) {
        var type = tagName.toUpperCase();
        // this.invalidHandleTypes[type] = null;
        delete this.invalidHandleTypes[type];
    },

    /**
     * Unsets an invalid handle id
     * @method removeInvalidHandleId
     * @param {string} id the id of the element to re-enable
     */
    removeInvalidHandleId: function(id) {
        if (typeof id !== "string") {
            id = CQ.Ext.id(id);
        }
        delete this.invalidHandleIds[id];
    },

    /**
     * Unsets an invalid css class
     * @method removeInvalidHandleClass
     * @param {string} cssClass the class of the element(s) you wish to
     * re-enable
     */
    removeInvalidHandleClass: function(cssClass) {
        for (var i=0, len=this.invalidHandleClasses.length; i= this.minX; i = i - iTickSize) {
            if (!tickMap[i]) {
                this.xTicks[this.xTicks.length] = i;
                tickMap[i] = true;
            }
        }

        for (i = this.initPageX; i <= this.maxX; i = i + iTickSize) {
            if (!tickMap[i]) {
                this.xTicks[this.xTicks.length] = i;
                tickMap[i] = true;
            }
        }

        this.xTicks.sort(this.DDM.numericSort) ;
    },

    /**
     * Create the array of vertical tick marks if an interval was specified in
     * setYConstraint().
     * @method setYTicks
     * @private
     */
    setYTicks: function(iStartY, iTickSize) {
        this.yTicks = [];
        this.yTickSize = iTickSize;

        var tickMap = {};

        for (var i = this.initPageY; i >= this.minY; i = i - iTickSize) {
            if (!tickMap[i]) {
                this.yTicks[this.yTicks.length] = i;
                tickMap[i] = true;
            }
        }

        for (i = this.initPageY; i <= this.maxY; i = i + iTickSize) {
            if (!tickMap[i]) {
                this.yTicks[this.yTicks.length] = i;
                tickMap[i] = true;
            }
        }

        this.yTicks.sort(this.DDM.numericSort) ;
    },

    /**
     * By default, the element can be dragged any place on the screen.  Use
     * this method to limit the horizontal travel of the element.  Pass in
     * 0,0 for the parameters if you want to lock the drag to the y axis.
     * @method setXConstraint
     * @param {int} iLeft the number of pixels the element can move to the left
     * @param {int} iRight the number of pixels the element can move to the
     * right
     * @param {int} iTickSize optional parameter for specifying that the
     * element
     * should move iTickSize pixels at a time.
     */
    setXConstraint: function(iLeft, iRight, iTickSize) {
        this.leftConstraint = iLeft;
        this.rightConstraint = iRight;

        this.minX = this.initPageX - iLeft;
        this.maxX = this.initPageX + iRight;
        if (iTickSize) { this.setXTicks(this.initPageX, iTickSize); }

        this.constrainX = true;
    },

    /**
     * Clears any constraints applied to this instance.  Also clears ticks
     * since they can't exist independent of a constraint at this time.
     * @method clearConstraints
     */
    clearConstraints: function() {
        this.constrainX = false;
        this.constrainY = false;
        this.clearTicks();
    },

    /**
     * Clears any tick interval defined for this instance
     * @method clearTicks
     */
    clearTicks: function() {
        this.xTicks = null;
        this.yTicks = null;
        this.xTickSize = 0;
        this.yTickSize = 0;
    },

    /**
     * By default, the element can be dragged any place on the screen.  Set
     * this to limit the vertical travel of the element.  Pass in 0,0 for the
     * parameters if you want to lock the drag to the x axis.
     * @method setYConstraint
     * @param {int} iUp the number of pixels the element can move up
     * @param {int} iDown the number of pixels the element can move down
     * @param {int} iTickSize optional parameter for specifying that the
     * element should move iTickSize pixels at a time.
     */
    setYConstraint: function(iUp, iDown, iTickSize) {
        this.topConstraint = iUp;
        this.bottomConstraint = iDown;

        this.minY = this.initPageY - iUp;
        this.maxY = this.initPageY + iDown;
        if (iTickSize) { this.setYTicks(this.initPageY, iTickSize); }

        this.constrainY = true;

    },

    /**
     * resetConstraints must be called if you manually reposition a dd element.
     * @method resetConstraints
     * @param {boolean} maintainOffset
     */
    resetConstraints: function() {


        // Maintain offsets if necessary
        if (this.initPageX || this.initPageX === 0) {
            // figure out how much this thing has moved
            var dx = (this.maintainOffset) ? this.lastPageX - this.initPageX : 0;
            var dy = (this.maintainOffset) ? this.lastPageY - this.initPageY : 0;

            this.setInitPosition(dx, dy);

        // This is the first time we have detected the element's position
        } else {
            this.setInitPosition();
        }

        if (this.constrainX) {
            this.setXConstraint( this.leftConstraint,
                                 this.rightConstraint,
                                 this.xTickSize        );
        }

        if (this.constrainY) {
            this.setYConstraint( this.topConstraint,
                                 this.bottomConstraint,
                                 this.yTickSize         );
        }
    },

    /**
     * Normally the drag element is moved pixel by pixel, but we can specify
     * that it move a number of pixels at a time.  This method resolves the
     * location when we have it set up like this.
     * @method getTick
     * @param {int} val where we want to place the object
     * @param {int[]} tickArray sorted array of valid points
     * @return {int} the closest tick
     * @private
     */
    getTick: function(val, tickArray) {

        if (!tickArray) {
            // If tick interval is not defined, it is effectively 1 pixel,
            // so we return the value passed to us.
            return val;
        } else if (tickArray[0] >= val) {
            // The value is lower than the first tick, so we return the first
            // tick.
            return tickArray[0];
        } else {
            for (var i=0, len=tickArray.length; i= val) {
                    var diff1 = val - tickArray[i];
                    var diff2 = tickArray[next] - val;
                    return (diff2 > diff1) ? tickArray[i] : tickArray[next];
                }
            }

            // The value is larger than the last tick, so we return the last
            // tick.
            return tickArray[tickArray.length - 1];
        }
    },

    /**
     * toString method
     * @method toString
     * @return {string} string representation of the dd obj
     */
    toString: function() {
        return ("DragDrop " + this.id);
    }

};

})();
/**
 * The drag and drop utility provides a framework for building drag and drop
 * applications.  In addition to enabling drag and drop for specific elements,
 * the drag and drop elements are tracked by the manager class, and the
 * interactions between the various elements are tracked during the drag and
 * the implementing code is notified about these important moments.
 */

// Only load the library once.  Rewriting the manager class would orphan
// existing drag and drop instances.
if (!CQ.Ext.dd.DragDropMgr) {

/**
 * @class CQ.Ext.dd.DragDropMgr
 * DragDropMgr is a singleton that tracks the element interaction for
 * all DragDrop items in the window.  Generally, you will not call
 * this class directly, but it does have helper methods that could
 * be useful in your DragDrop implementations.
 * @singleton
 */
CQ.Ext.dd.DragDropMgr = function() {

    var Event = CQ.Ext.EventManager;

    return {

        /**
         * Two dimensional Array of registered DragDrop objects.  The first
         * dimension is the DragDrop item group, the second the DragDrop
         * object.
         * @property ids
         * @type {string: string}
         * @private
         * @static
         */
        ids: {},

        /**
         * Array of element ids defined as drag handles.  Used to determine
         * if the element that generated the mousedown event is actually the
         * handle and not the html element itself.
         * @property handleIds
         * @type {string: string}
         * @private
         * @static
         */
        handleIds: {},

        /**
         * the DragDrop object that is currently being dragged
         * @property dragCurrent
         * @type DragDrop
         * @private
         * @static
         **/
        dragCurrent: null,

        /**
         * the DragDrop object(s) that are being hovered over
         * @property dragOvers
         * @type Array
         * @private
         * @static
         */
        dragOvers: {},

        /**
         * the X distance between the cursor and the object being dragged
         * @property deltaX
         * @type int
         * @private
         * @static
         */
        deltaX: 0,

        /**
         * the Y distance between the cursor and the object being dragged
         * @property deltaY
         * @type int
         * @private
         * @static
         */
        deltaY: 0,

        /**
         * Flag to determine if we should prevent the default behavior of the
         * events we define. By default this is true, but this can be set to
         * false if you need the default behavior (not recommended)
         * @property preventDefault
         * @type boolean
         * @static
         */
        preventDefault: true,

        /**
         * Flag to determine if we should stop the propagation of the events
         * we generate. This is true by default but you may want to set it to
         * false if the html element contains other features that require the
         * mouse click.
         * @property stopPropagation
         * @type boolean
         * @static
         */
        stopPropagation: true,

        /**
         * Internal flag that is set to true when drag and drop has been
         * intialized
         * @property initialized
         * @private
         * @static
         */
        initialized: false,

        /**
         * All drag and drop can be disabled.
         * @property locked
         * @private
         * @static
         */
        locked: false,

        /**
         * Called the first time an element is registered.
         * @method init
         * @private
         * @static
         */
        init: function() {
            this.initialized = true;
        },

        /**
         * In point mode, drag and drop interaction is defined by the
         * location of the cursor during the drag/drop
         * @property POINT
         * @type int
         * @static
         */
        POINT: 0,

        /**
         * In intersect mode, drag and drop interaction is defined by the
         * overlap of two or more drag and drop objects.
         * @property INTERSECT
         * @type int
         * @static
         */
        INTERSECT: 1,

        /**
         * The current drag and drop mode.  Default: POINT
         * @property mode
         * @type int
         * @static
         */
        mode: 0,

        /**
         * Runs method on all drag and drop objects
         * @method _execOnAll
         * @private
         * @static
         */
        _execOnAll: function(sMethod, args) {
            for (var i in this.ids) {
                for (var j in this.ids[i]) {
                    var oDD = this.ids[i][j];
                    if (! this.isTypeOfDD(oDD)) {
                        continue;
                    }
                    oDD[sMethod].apply(oDD, args);
                }
            }
        },

        /**
         * Drag and drop initialization.  Sets up the global event handlers
         * @method _onLoad
         * @private
         * @static
         */
        _onLoad: function() {

            this.init();


            Event.on(document, "mouseup",   this.handleMouseUp, this, true);
            Event.on(document, "mousemove", this.handleMouseMove, this, true);
            Event.on(window,   "unload",    this._onUnload, this, true);
            Event.on(window,   "resize",    this._onResize, this, true);
            // Event.on(window,   "mouseout",    this._test);

        },

        /**
         * Reset constraints on all drag and drop objs
         * @method _onResize
         * @private
         * @static
         */
        _onResize: function(e) {
            this._execOnAll("resetConstraints", []);
        },

        /**
         * Lock all drag and drop functionality
         * @method lock
         * @static
         */
        lock: function() { this.locked = true; },

        /**
         * Unlock all drag and drop functionality
         * @method unlock
         * @static
         */
        unlock: function() { this.locked = false; },

        /**
         * Is drag and drop locked?
         * @method isLocked
         * @return {boolean} True if drag and drop is locked, false otherwise.
         * @static
         */
        isLocked: function() { return this.locked; },

        /**
         * Location cache that is set for all drag drop objects when a drag is
         * initiated, cleared when the drag is finished.
         * @property locationCache
         * @private
         * @static
         */
        locationCache: {},

        /**
         * Set useCache to false if you want to force object the lookup of each
         * drag and drop linked element constantly during a drag.
         * @property useCache
         * @type boolean
         * @static
         */
        useCache: true,

        /**
         * The number of pixels that the mouse needs to move after the
         * mousedown before the drag is initiated.  Default=3;
         * @property clickPixelThresh
         * @type int
         * @static
         */
        clickPixelThresh: 3,

        /**
         * The number of milliseconds after the mousedown event to initiate the
         * drag if we don't get a mouseup event. Default=1000
         * @property clickTimeThresh
         * @type int
         * @static
         */
        clickTimeThresh: 350,

        /**
         * Flag that indicates that either the drag pixel threshold or the
         * mousdown time threshold has been met
         * @property dragThreshMet
         * @type boolean
         * @private
         * @static
         */
        dragThreshMet: false,

        /**
         * Timeout used for the click time threshold
         * @property clickTimeout
         * @type Object
         * @private
         * @static
         */
        clickTimeout: null,

        /**
         * The X position of the mousedown event stored for later use when a
         * drag threshold is met.
         * @property startX
         * @type int
         * @private
         * @static
         */
        startX: 0,

        /**
         * The Y position of the mousedown event stored for later use when a
         * drag threshold is met.
         * @property startY
         * @type int
         * @private
         * @static
         */
        startY: 0,

        /**
         * Each DragDrop instance must be registered with the DragDropMgr.
         * This is executed in DragDrop.init()
         * @method regDragDrop
         * @param {DragDrop} oDD the DragDrop object to register
         * @param {String} sGroup the name of the group this element belongs to
         * @static
         */
        regDragDrop: function(oDD, sGroup) {
            if (!this.initialized) { this.init(); }

            if (!this.ids[sGroup]) {
                this.ids[sGroup] = {};
            }
            this.ids[sGroup][oDD.id] = oDD;
        },

        /**
         * Removes the supplied dd instance from the supplied group. Executed
         * by DragDrop.removeFromGroup, so don't call this function directly.
         * @method removeDDFromGroup
         * @private
         * @static
         */
        removeDDFromGroup: function(oDD, sGroup) {
            if (!this.ids[sGroup]) {
                this.ids[sGroup] = {};
            }

            var obj = this.ids[sGroup];
            if (obj && obj[oDD.id]) {
                delete obj[oDD.id];
            }
        },

        /**
         * Unregisters a drag and drop item.  This is executed in
         * DragDrop.unreg, use that method instead of calling this directly.
         * @method _remove
         * @private
         * @static
         */
        _remove: function(oDD) {
            for (var g in oDD.groups) {
                if (g && this.ids[g][oDD.id]) {
                    delete this.ids[g][oDD.id];
                }
            }
            delete this.handleIds[oDD.id];
        },

        /**
         * Each DragDrop handle element must be registered.  This is done
         * automatically when executing DragDrop.setHandleElId()
         * @method regHandle
         * @param {String} sDDId the DragDrop id this element is a handle for
         * @param {String} sHandleId the id of the element that is the drag
         * handle
         * @static
         */
        regHandle: function(sDDId, sHandleId) {
            if (!this.handleIds[sDDId]) {
                this.handleIds[sDDId] = {};
            }
            this.handleIds[sDDId][sHandleId] = sHandleId;
        },

        /**
         * Utility function to determine if a given element has been
         * registered as a drag drop item.
         * @method isDragDrop
         * @param {String} id the element id to check
         * @return {boolean} true if this element is a DragDrop item,
         * false otherwise
         * @static
         */
        isDragDrop: function(id) {
            return ( this.getDDById(id) ) ? true : false;
        },

        /**
         * Returns the drag and drop instances that are in all groups the
         * passed in instance belongs to.
         * @method getRelated
         * @param {DragDrop} p_oDD the obj to get related data for
         * @param {boolean} bTargetsOnly if true, only return targetable objs
         * @return {DragDrop[]} the related instances
         * @static
         */
        getRelated: function(p_oDD, bTargetsOnly) {
            var oDDs = [];
            for (var i in p_oDD.groups) {
                for (j in this.ids[i]) {
                    var dd = this.ids[i][j];
                    if (! this.isTypeOfDD(dd)) {
                        continue;
                    }
                    if (!bTargetsOnly || dd.isTarget) {
                        oDDs[oDDs.length] = dd;
                    }
                }
            }

            return oDDs;
        },

        /**
         * Returns true if the specified dd target is a legal target for
         * the specifice drag obj
         * @method isLegalTarget
         * @param {DragDrop} the drag obj
         * @param {DragDrop} the target
         * @return {boolean} true if the target is a legal target for the
         * dd obj
         * @static
         */
        isLegalTarget: function (oDD, oTargetDD) {
            var targets = this.getRelated(oDD, true);
            for (var i=0, len=targets.length;i this.clickPixelThresh ||
                            diffY > this.clickPixelThresh) {
                    this.startDrag(this.startX, this.startY);
                }
            }

            if (this.dragThreshMet) {
                this.dragCurrent.b4Drag(e);
                this.dragCurrent.onDrag(e);
                if(!this.dragCurrent.moveOnly){
                    this.fireEvents(e, false);
                }
            }

            this.stopEvent(e);

            retur