An object hash in which each property is a date parsing function. The property name is the + * format string which that function parses.

This object is automatically populated with date parsing functions as + * date formats are requested for Ext standard formatting strings.

Custom parsing functions may be inserted into this object, keyed by a name which from then on + * may be used as a format string to {@link #parseDate}.

A parsing function should return a Date object, and is passed the following parameters:

date : String
The date string to parse.
strict : Boolean
True to validate date strings while parsing + * (i.e. prevent javascript Date "rollover") (The default must be false). + * Invalid date strings should return null when parsed.

To enable Dates to also be formatted according to that format, a corresponding + * formatting function must be placed into the {@link #formatFunctions} property. + * @property parseFunctions + * @static + * @type Object + */ + parseFunctions: { + "M$": function(input, strict) { + // note: the timezone offset is ignored since the M$ Ajax server sends + // a UTC milliseconds-since-Unix-epoch value (negative values are allowed) + var re = new RegExp('\\/Date\$([-+])?(\\d+)(?:[+-]\\d{4})?\$\\/'); + var r = (input || '').match(re); + return r? new Date(((r[1] || '') + r[2]) * 1) : null; } - eval(body); - return this; }, + parseRegexes: [], /** - * 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 + *

An object hash in which each property is a date formatting function. The property name is the + * format string which corresponds to the produced formatted date string.

This object is automatically populated with date formatting functions as + * date formats are requested for Ext standard formatting strings.

Custom formatting functions may be inserted into this object, keyed by a name which from then on + * may be used as a format string to {@link #format}. Example:

A formatting function should return a string representation of the passed Date object, and is passed the following parameters:

date : Date
The Date to format.

To enable date strings to also be parsed according to that format, a corresponding + * parsing function must be placed into the {@link #parseFunctions} property. + * @property formatFunctions + * @static + * @type Object */ - applyTemplate : function(values){ - return this.master.compiled.call(this, values, {}, 1, 1); + formatFunctions: { + "M$": function() { + // UTC milliseconds since Unix epoch (M$-AJAX serialized date format (MRSF)) + return '\\/Date(' + this.getTime() + ')\\/'; + } }, + y2kYear : 50, + /** - * Compile the template to a function for optimized performance. Recommended if the template will be used frequently. - * @return {Function} The compiled function + * Date interval constant + * @static + * @type String */ - compile : function(){return this;} + MILLI : "ms", /** - * @property re - * @hide + * Date interval constant + * @static + * @type String */ + SECOND : "s", + /** - * @property disableFormats - * @hide + * Date interval constant + * @static + * @type String */ - /** - * @method set - * @hide + MINUTE : "mi", + + /** Date interval constant + * @static + * @type String */ + HOUR : "h", -}); -/** - * 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 Ext.XTemplate - * @method apply - */ -Ext.XTemplate.prototype.apply = Ext.XTemplate.prototype.applyTemplate; + /** + * Date interval constant + * @static + * @type String + */ + DAY : "d", -/** - * 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 {Ext.Template} The created template - * @static - */ -Ext.XTemplate.from = function(el){ - el = Ext.getDom(el); - return new Ext.XTemplate(el.value || el.innerHTML); -};/** - * @class Ext.util.CSS - * Utility class for manipulating CSS rules - * @singleton - */ -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(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.toLowerCase()] = 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(!Ext.isArray(selector)){ - return rs[selector.toLowerCase()]; - } - for(var i = 0; i < selector.length; i++){ - if(rs[selector[i]]){ - return rs[selector[i].toLowerCase()]; - } - } - 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(!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; - } - }; -}();/** - @class Ext.util.ClickRepeater - @extends 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 + /** + * Date interval constant + * @static + * @type String + */ + MONTH : "mo", - @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 + /** + * Date interval constant + * @static + * @type String + */ + YEAR : "y", - @constructor - @param {Mixed} el The element to listen on - @param {Object} config - */ -Ext.util.ClickRepeater = function(el, config) -{ - this.el = Ext.get(el); - this.el.unselectable(); + /** + *

y : Number
The default year value. (defaults to undefined)
m : Number
The default 1-based month value. (defaults to undefined)
d : Number
The default day value. (defaults to undefined)
h : Number
The default hour value. (defaults to undefined)
i : Number
The default minute value. (defaults to undefined)
s : Number
The default second value. (defaults to undefined)
ms : Number
The default millisecond value. (defaults to undefined)

Override these properties to customize the default date values used by the {@link #parseDate} method.

Note: In countries which experience Daylight Saving Time (i.e. DST), the h, i, s + * and ms properties may coincide with the exact time in which DST takes effect. + * It is the responsiblity of the developer to account for this.

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:

Only available on the instance returned from {@link #createInstance}, not on the singleton.

A base error class. Future implementations are intended to provide more - * robust error handling throughout the framework (in the debug build only) - * to check for common errors and problems. The messages issued by this class - * will aid error checking. Error checks will be automatically removed in the - * production build so that performance is not negatively impacted.

Provides a registry of all Components (instances of {@link Ext.Component} or any subclass - * thereof) on a page so that they can be easily accessed by {@link Ext.Component component} - * {@link Ext.Component#id id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).

This object also provides a registry of available Component classes - * indexed by a mnemonic code known as the Component's {@link Ext.Component#xtype xtype}. - * The {@link Ext.Component#xtype xtype} provides a way to avoid instantiating child Components - * when creating a full, nested config object for a complete Ext page.

A child Component may be specified simply as a config object - * as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component - * needs rendering, the correct type can be looked up for lazy instantiation.

For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.

Registers a new Component constructor, keyed by a new - * {@link Ext.Component#xtype}.

Use this method (or its alias {@link Ext#reg Ext.reg}) to register new - * subclasses of {@link Ext.Component} so that lazy instantiation may be used when specifying - * child Components. - * see {@link Ext.Container#items}

Registers a new Plugin constructor, keyed by a new - * {@link Ext.Component#ptype}.

Use this method (or its alias {@link Ext#preg Ext.preg}) to register new - * plugins for {@link Ext.Component}s so that lazy instantiation may be used when specifying - * Plugins.

Base class for all Ext components. All subclasses of Component may participate in the automated - * Ext component lifecycle of creation, rendering and destruction which is provided by the {@link Ext.Container Container} class. - * Components may be added to a Container through the {@link Ext.Container#items items} config option at the time the Container is created, - * or they may be added dynamically via the {@link Ext.Container#add add} method.

The Component base class has built-in support for basic hide/show and enable/disable behavior.

All Components are registered with the {@link Ext.ComponentMgr} on construction so that they can be referenced at any time via - * {@link Ext#getCmp}, passing the {@link #id}.

All user-developed visual widgets that are required to participate in automated lifecycle and size management should subclass Component (or - * {@link Ext.BoxComponent} if managed box model handling is required, ie height and width management).

See the Creating new UI controls tutorial for details on how - * and to either extend or augment ExtJs base classes to create custom Components.

Every component has a specific xtype, which is its Ext-specific type name, along with methods for checking the - * xtype like {@link #getXType} and {@link #isXType}. This is the list of all valid xtypes:

an element : - *
it is set as the internal element and its id used as the component id
a string : - *
it is assumed to be the id of an existing element and is used as the component id
anything else : - *
it is assumed to be a standard config object and is applied to the component

The afterrender event is fired after this Component has been {@link #rendered}, been postprocesed - * by any afterRender method defined for the Component, and, if {@link #stateful}, after state - * has been restored.

If a {@link #getKey} implementation was specified for this MixedCollection, + * or if the key of the stored items is in a property called id, + * the MixedCollection will be able to derive the key for the new item. + * In this case just pass the new item in this parameter.

A CSS style specification string to apply directly to this field's - * label. Defaults to the container's labelStyle value if set (e.g., - * {@link Ext.layout.FormLayout#labelStyle} , or '').

Also see {@link #hideLabel} and - * {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}.

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.

The separator to display after the text of each - * {@link #fieldLabel}. This property may be configured at various levels. - * The order of precedence is: - *

field / component level
container level
{@link Ext.layout.FormLayout#labelSeparator layout level} (defaults to colon ':')

Also see {@link #hideLabel} and - * {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}.

true to completely hide the label element - * ({@link #fieldLabel label} and {@link #labelSeparator separator}). Defaults to false. - * By default, even if you do not specify a {@link #fieldLabel} the space will still be - * reserved so that the field will line up with other fields that do have labels. - * Setting this to true will cause the field to not reserve that space.

The CSS class used to to apply to the special clearing div rendered - * directly after each form field wrapper to provide field clearing (defaults to - * 'x-form-clear-left').

Note: this config is only used when this Component is rendered by a Container - * which has been configured to use the {@link Ext.layout.FormLayout FormLayout} layout - * manager (e.g. {@link Ext.form.FormPanel} or specifying layout:'form') and either a - * {@link #fieldLabel} is specified or isFormField=true is specified.

See {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl} also.

item : Mixed
The collection item
index : Number
The item's index
length : Number
The total number of items in the collection

Note: this config is only used when this Component is rendered by a Container which - * has been configured to use the {@link Ext.layout.FormLayout FormLayout} layout manager (e.g. - * {@link Ext.form.FormPanel} or specifying layout:'form').

An additional CSS class to apply to the div wrapping the form item - * element of this field. If supplied, itemCls at the field level will override - * the default itemCls supplied at the container level. The value specified for - * itemCls will be added to the default class ('x-form-item').

Since it is applied to the item wrapper (see - * {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl}), it allows - * you to write standard CSS rules that can apply to the field, the label (if specified), or - * any other element within the markup for the field.

The unique id of this component (defaults to an {@link #getId auto-assigned id}). - * You should assign an id if you need to be able to access the component later and you do - * not have an object reference available (e.g., using {@link Ext}.{@link Ext#getCmp getCmp}).

Note that this id will also be used as the element id for the containing HTML element - * that is rendered to the page for this component. This allows you to write id-based CSS - * rules to style the specific instance of this component uniquely, and also to select - * sub-elements using this component's id as the parent.

Note: to avoid complications imposed by a unique id also see - * {@link #itemId} and {@link #ref}.

An itemId can be used as an alternative way to get a reference to a component - * when no object reference is available. Instead of using an {@link #id} with - * {@link Ext}.{@link Ext#getCmp getCmp}, use itemId with - * {@link Ext.Container}.{@link Ext.Container#getComponent getComponent} which will retrieve - * itemId's or {@link #id}'s. Since itemId's are an index to the - * container's internal MixedCollection, the itemId is scoped locally to the container -- - * avoiding potential conflicts with {@link Ext.ComponentMgr} which requires a unique - * {@link #id}.

An optional extra CSS class that will be added to this component's container. This can be useful for - * adding customized styles to the container or any of its children using standard CSS rules. See - * {@link Ext.layout.ContainerLayout}.{@link Ext.layout.ContainerLayout#extraCls extraCls} also.

Note: ctCls defaults to '' except for the following class - * which assigns a value by default: - *

{@link Ext.layout.Box Box Layout} : 'x-box-layout-ct'

Specify the id of the element, a DOM element or an existing Element corresponding to a DIV - * that is already present in the document that specifies some structural markup for this - * component.

Specify the id of the element, a DOM element or an existing Element that this component - * will be rendered into.

A flag which causes the Component to attempt to restore the state of - * internal properties from a saved state on startup. The component must have - * either a {@link #stateId} or {@link #id} assigned - * for state to be managed. Auto-generated ids are not guaranteed to be stable - * across page loads and cannot be relied upon to save and restore the same - * state for a component.

For state saving to work, the state manager's provider must have been - * set to an implementation of {@link Ext.state.Provider} which overrides the - * {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get} - * methods to save and recall name/value pairs. A built-in implementation, - * {@link Ext.state.CookieProvider} is available.

A stateful Component attempts to save state when one of the events - * listed in the {@link #stateEvents} configuration fires.

To save state, a stateful Component first serializes its state by - * calling getState. By default, this function does - * nothing. The developer must provide an implementation which returns an - * object hash which represents the Component's restorable state.

The value yielded by getState is passed to {@link Ext.state.Manager#set} - * which uses the configured {@link Ext.state.Provider} to save the object - * keyed by the Component's {@link stateId}, or, if that is not - * specified, its {@link #id}.

During construction, a stateful Component attempts to restore - * its state by calling {@link Ext.state.Manager#get} passing the - * {@link #stateId}, or, if that is not specified, the - * {@link #id}.

The resulting object is passed to applyState. - * The default implementation of applyState simply copies - * properties into the object, but a developer may override this to support - * more behaviour.

You can perform extra processing on state save and restore by attaching - * handlers to the {@link #beforestaterestore}, {@link #staterestore}, - * {@link #beforestatesave} and {@link #statesave} events.

See {@link #stateful} for an explanation of saving and - * restoring Component state.

An array of events that, when fired, should trigger this component to - * save its state (defaults to none). stateEvents may be any type - * of event supported by this component, including browser or custom events - * (e.g., ['click', 'customerchange']).

See {@link #stateful} for an explanation of saving and - * restoring Component state.

A tag name or {@link Ext.DomHelper DomHelper} spec used to create the {@link #getEl Element} which will - * encapsulate this Component.

You do not normally need to specify this. For the base classes {@link Ext.Component}, {@link Ext.BoxComponent}, - * and {@link Ext.Container}, this defaults to 'div'. The more complex Ext classes use a more complex - * DOM structure created by their own onRender methods.

This is intended to allow the developer to create application-specific utility Components encapsulated by - * different DOM elements. Example usage:

How this component should be hidden. Supported values are 'visibility' - * (css visibility), 'offsets' (negative offset position) and 'display' - * (css display).

Note: the default of 'display' is generally preferred - * since items are automatically laid out when they are first shown (no sizing - * is done while hidden).

This will usually be a <DIV> element created by the class's onRender method, but - * that may be overridden using the {@link #autoEl} config.

Note: this element will not be available until this Component has been rendered.

To add listeners for DOM events to this Component (as opposed to listeners - * for this Component's own Observable events), see the {@link Ext.util.Observable#listeners listeners} - * config for a suggestion, or use a render listener directly:


+     * top : Defaultchild items are aligned vertically
+     * at the top of the container
+     * middle : child items are aligned vertically in the
+     * middle of the container
+     * stretch : child items are stretched vertically to fill
+     * the height of the container
+     * stretchmax : child items are stretched vertically to
+     * the height of the largest item.
+     */
+    align: 'top', // top, middle, stretch, strechmax
+
+    type : 'hbox',
+
+    /**
+     * @private
+     * See parent documentation
+     */
+    updateInnerCtSize: function(tSize, calcs) {
+        var innerCtWidth  = tSize.width,
+            innerCtHeight = calcs.meta.maxHeight + this.padding.top + this.padding.bottom;
+
+        if (this.align == 'stretch') {
+            innerCtHeight = tSize.height;
+        } else if (this.align == 'middle') {
+            innerCtHeight = Math.max(tSize.height, innerCtHeight);
+        }
+
+        this.innerCt.setSize(innerCtWidth || undefined, innerCtHeight || undefined);
+    },
+
+    /**
+     * @cfg {String} pack
+     * Controls how the child items of the container are packed together. Acceptable configuration values
+     * for this property are:
+     * 
+     * start : Defaultchild items are packed together at
+     * left side of container
+     * center : child items are packed together at
+     * mid-width of container
+     * end : child items are packed together at right
+     * side of container
+     * 
+     */
+    /**
+     * @cfg {Number} flex
+     * This configuation option is to be applied to child items of the container managed
+     * by this layout. Each child item with a flex property will be flexed horizontally
+     * according to each item's relative flex value compared to the sum of all items with
+     * a flex value specified.  Any child items that have either a flex = 0 or
+     * flex = undefined will not be 'flexed' (the initial size will not be changed).
+     */
+
+    /**
+     * @private
+     * Calculates the size and positioning of each item in the HBox. This iterates over all of the rendered,
+     * visible items and returns a height, width, top and left for each, as well as a reference to each. Also
+     * returns meta data such as maxHeight which are useful when resizing layout wrappers such as this.innerCt.
+     * @param {Array} visibleItems The array of all rendered, visible items to be calculated for
+     * @param {Object} targetSize Object containing target size and height
+     * @return {Object} Object containing box measurements for each child, plus meta data
+     */
+    calculateChildBoxes: function(visibleItems, targetSize) {
+        var visibleCount = visibleItems.length,
+
+            padding      = this.padding,
+            topOffset    = padding.top,
+            leftOffset   = padding.left,
+            paddingVert  = topOffset  + padding.bottom,
+            paddingHoriz = leftOffset + padding.right,
+
+            width        = targetSize.width - this.scrollOffset,
+            height       = targetSize.height,
+            availHeight  = Math.max(0, height - paddingVert),
+
+            isStart      = this.pack == 'start',
+            isCenter     = this.pack == 'center',
+            isEnd        = this.pack == 'end',
+            // isRestore    = ['stretch', 'stretchmax'].indexOf(this.align) == -1,
+
+            nonFlexWidth = 0,
+            maxHeight    = 0,
+            totalFlex    = 0,
+
+            //used to cache the calculated size and position values for each child item
+            boxes        = [],
+
+            //used in the for loops below, just declared here for brevity
+            child, childWidth, childHeight, childSize, childMargins, canLayout, i, calcs, flexedWidth, vertMargins, stretchHeight;
+
+            //gather the total flex of all flexed items and the width taken up by fixed width items
+            for (i = 0; i < visibleCount; i++) {
+                child       = visibleItems[i];
+                childHeight = child.height;
+                childWidth  = child.width;
+                canLayout   = !child.hasLayout && Ext.isFunction(child.doLayout);
+
+                // Static width (numeric) requires no calcs
+                if (!Ext.isNumber(childWidth)) {
+
+                    // flex and not 'auto' width
+                    if (child.flex && !childWidth) {
+                        totalFlex += child.flex;
+
+                    // Not flexed or 'auto' width or undefined width
+                    } else {
+                        //Render and layout sub-containers without a flex or width defined, as otherwise we
+                        //don't know how wide the sub-container should be and cannot calculate flexed widths
+                        if (!childWidth && canLayout) {
+                            child.doLayout();
+                        }
+
+                        childSize   = child.getSize();
+                        childWidth  = childSize.width;
+                        childHeight = childSize.height;
+                    }
+                }
+
+                childMargins = child.margins;
+
+                nonFlexWidth += (childWidth || 0) + childMargins.left + childMargins.right;
+
+                // Max height for align - force layout of non-layed out subcontainers without a numeric height
+                if (!Ext.isNumber(childHeight)) {
+                    if (canLayout) {
+                        child.doLayout();
+                    }
+                    childHeight = child.getHeight();
+                }
+
+                maxHeight = Math.max(maxHeight, childHeight + childMargins.top + childMargins.bottom);
+
+                //cache the size of each child component
+                boxes.push({
+                    component: child,
+                    height   : childHeight || undefined,
+                    width    : childWidth || undefined
+                });
+            }
+
+            //the width available to the flexed items
+            var availableWidth = Math.max(0, (width - nonFlexWidth - paddingHoriz));
+
+            if (isCenter) {
+                leftOffset += availableWidth / 2;
+            } else if (isEnd) {
+                leftOffset += availableWidth;
+            }
+
+            //temporary variables used in the flex width calculations below
+            var remainingWidth = availableWidth,
+                remainingFlex  = totalFlex;
+
+            //calculate the widths of each flexed item, and the left + top positions of every item
+            for (i = 0; i < visibleCount; i++) {
+                child = visibleItems[i];
+                calcs = boxes[i];
+
+                childMargins = child.margins;
+                vertMargins  = childMargins.top + childMargins.bottom;
+
+                leftOffset  += childMargins.left;
+
+                if (isStart && child.flex && !child.width) {
+                    flexedWidth     = Math.ceil((child.flex / remainingFlex) * remainingWidth);
+                    remainingWidth -= flexedWidth;
+                    remainingFlex  -= child.flex;
+
+                    calcs.width = flexedWidth;
+                    calcs.dirtySize = true;
+                }
+
+                calcs.left = leftOffset;
+                calcs.top  = topOffset + childMargins.top;
+
+                switch (this.align) {
+                    case 'stretch':
+                        stretchHeight = availHeight - vertMargins;
+                        calcs.height  = stretchHeight.constrain(child.minHeight || 0, child.maxHeight || 1000000);
+                        calcs.dirtySize = true;
+                        break;
+                    case 'stretchmax':
+                        stretchHeight = maxHeight - vertMargins;
+                        calcs.height  = stretchHeight.constrain(child.minHeight || 0, child.maxHeight || 1000000);
+                        calcs.dirtySize = true;
+                        break;
+                    case 'middle':
+                        var diff = availHeight - calcs.height - vertMargins;
+                        if (diff > 0) {
+                            calcs.top = topOffset + vertMargins + (diff / 2);
+                        }
+                }
+                leftOffset += calcs.width + childMargins.right;
+            }
+
+        return {
+            boxes: boxes,
+            meta : {
+                maxHeight: maxHeight
+            }
+        };
+    }
+});
+
+Ext.Container.LAYOUTS.hbox = Ext.layout.HBoxLayout;
+/**
+ * @class Ext.layout.ToolbarLayout
+ * @extends Ext.layout.ContainerLayout
+ * Layout manager used by Ext.Toolbar. This is highly specialised for use by Toolbars and would not
+ * usually be used by any other class.
+ */
+Ext.layout.ToolbarLayout = Ext.extend(Ext.layout.ContainerLayout, {
+    monitorResize : true,
+
+    type: 'toolbar',
+
+    /**
+     * @property triggerWidth
+     * @type Number
+     * The width allocated for the menu trigger at the extreme right end of the Toolbar
+     */
+    triggerWidth: 18,
+
+    /**
+     * @property noItemsMenuText
+     * @type String
+     * HTML fragment to render into the toolbar overflow menu if there are no items to display
+     */
+    noItemsMenuText : '(None)',
+
+    /**
+     * @private
+     * @property lastOverflow
+     * @type Boolean
+     * Used internally to record whether the last layout caused an overflow or not
+     */
+    lastOverflow: false,
+
+    /**
+     * @private
+     * @property tableHTML
+     * @type String
+     * String used to build the HTML injected to support the Toolbar's layout. The align property is
+     * injected into this string inside the td.x-toolbar-left element during onLayout.
+     */
+    tableHTML: [
+        '',
+            '',
+                '',
+                    '',
+                    '',
+                '',
+            '',
+        '',
+                        '',
+                            '',
+                                '',
+                            '',
+                        '',
+                    ' ',
+                        '',
+                            '',
+                                '',
+                                    '',
+                                    '',
+                                '',
+                            '',
+                        '',
+                                        '',
+                                            '',
+                                                '',
+                                            '',
+                                        '',
+                                    ' ',
+                                        '',
+                                            '',
+                                                '',
+                                            '',
+                                        '',
+                                    '',
+                    ''
+    ].join(""),
+
+    /**
+     * @private
+     * Create the wrapping Toolbar HTML and render/move all the items into the correct places
+     */
+    onLayout : function(ct, target) {
+        //render the Toolbar  HTML if it's not already present
+        if (!this.leftTr) {
+            var align = ct.buttonAlign == 'center' ? 'center' : 'left';
+
+            target.addClass('x-toolbar-layout-ct');
+            target.insertHtml('beforeEnd', String.format(this.tableHTML, align));
+
+            this.leftTr   = target.child('tr.x-toolbar-left-row', true);
+            this.rightTr  = target.child('tr.x-toolbar-right-row', true);
+            this.extrasTr = target.child('tr.x-toolbar-extras-row', true);
+
+            if (this.hiddenItem == undefined) {
+                /**
+                 * @property hiddenItems
+                 * @type Array
+                 * Holds all items that are currently hidden due to there not being enough space to render them
+                 * These items will appear on the expand menu.
+                 */
+                this.hiddenItems = [];
+            }
+        }
+
+        var side     = ct.buttonAlign == 'right' ? this.rightTr : this.leftTr,
+            items    = ct.items.items,
+            position = 0;
+
+        //render each item if not already rendered, place it into the correct (left or right) target
+        for (var i = 0, len = items.length, c; i < len; i++, position++) {
+            c = items[i];
+
+            if (c.isFill) {
+                side   = this.rightTr;
+                position = -1;
+            } else if (!c.rendered) {
+                c.render(this.insertCell(c, side, position));
+            } else {
+                if (!c.xtbHidden && !this.isValidParent(c, side.childNodes[position])) {
+                    var td = this.insertCell(c, side, position);
+                    td.appendChild(c.getPositionEl().dom);
+                    c.container = Ext.get(td);
+                }
+            }
+        }
+
+        //strip extra empty cells
+        this.cleanup(this.leftTr);
+        this.cleanup(this.rightTr);
+        this.cleanup(this.extrasTr);
+        this.fitToSize(target);
+    },
+
+    /**
+     * @private
+     * Removes any empty nodes from the given element
+     * @param {Ext.Element} el The element to clean up
+     */
+    cleanup : function(el) {
+        var cn = el.childNodes, i, c;
+
+        for (i = cn.length-1; i >= 0 && (c = cn[i]); i--) {
+            if (!c.firstChild) {
+                el.removeChild(c);
+            }
+        }
+    },
+
+    /**
+     * @private
+     * Inserts the given Toolbar item into the given element
+     * @param {Ext.Component} c The component to add
+     * @param {Ext.Element} target The target to add the component to
+     * @param {Number} position The position to add the component at
+     */
+    insertCell : function(c, target, position) {
+        var td = document.createElement('td');
+        td.className = 'x-toolbar-cell';
+
+        target.insertBefore(td, target.childNodes[position] || null);
+
+        return td;
+    },
+
+    /**
+     * @private
+     * Hides an item because it will not fit in the available width. The item will be unhidden again
+     * if the Toolbar is resized to be large enough to show it
+     * @param {Ext.Component} item The item to hide
+     */
+    hideItem : function(item) {
+        this.hiddenItems.push(item);
+
+        item.xtbHidden = true;
+        item.xtbWidth = item.getPositionEl().dom.parentNode.offsetWidth;
+        item.hide();
+    },
+
+    /**
+     * @private
+     * Unhides an item that was previously hidden due to there not being enough space left on the Toolbar
+     * @param {Ext.Component} item The item to show
+     */
+    unhideItem : function(item) {
+        item.show();
+        item.xtbHidden = false;
+        this.hiddenItems.remove(item);
+    },
+
+    /**
+     * @private
+     * Returns the width of the given toolbar item. If the item is currently hidden because there
+     * is not enough room to render it, its previous width is returned
+     * @param {Ext.Component} c The component to measure
+     * @return {Number} The width of the item
+     */
+    getItemWidth : function(c) {
+        return c.hidden ? (c.xtbWidth || 0) : c.getPositionEl().dom.parentNode.offsetWidth;
+    },
+
+    /**
+     * @private
+     * Called at the end of onLayout. At this point the Toolbar has already been resized, so we need
+     * to fit the items into the available width. We add up the width required by all of the items in
+     * the toolbar - if we don't have enough space we hide the extra items and render the expand menu
+     * trigger.
+     * @param {Ext.Element} target The Element the Toolbar is currently laid out within
+     */
+    fitToSize : function(target) {
+        if (this.container.enableOverflow === false) {
+            return;
+        }
+
+        var width       = target.dom.clientWidth,
+            tableWidth  = target.dom.firstChild.offsetWidth,
+            clipWidth   = width - this.triggerWidth,
+            lastWidth   = this.lastWidth || 0,
+
+            hiddenItems = this.hiddenItems,
+            hasHiddens  = hiddenItems.length != 0,
+            isLarger    = width >= lastWidth;
+
+        this.lastWidth  = width;
+
+        if (tableWidth > width || (hasHiddens && isLarger)) {
+            var items     = this.container.items.items,
+                len       = items.length,
+                loopWidth = 0,
+                item;
+
+            for (var i = 0; i < len; i++) {
+                item = items[i];
+
+                if (!item.isFill) {
+                    loopWidth += this.getItemWidth(item);
+                    if (loopWidth > clipWidth) {
+                        if (!(item.hidden || item.xtbHidden)) {
+                            this.hideItem(item);
+                        }
+                    } else if (item.xtbHidden) {
+                        this.unhideItem(item);
+                    }
+                }
+            }
+        }
+
+        //test for number of hidden items again here because they may have changed above
+        hasHiddens = hiddenItems.length != 0;
+
+        if (hasHiddens) {
+            this.initMore();
+
+            if (!this.lastOverflow) {
+                this.container.fireEvent('overflowchange', this.container, true);
+                this.lastOverflow = true;
+            }
+        } else if (this.more) {
+            this.clearMenu();
+            this.more.destroy();
+            delete this.more;
+
+            if (this.lastOverflow) {
+                this.container.fireEvent('overflowchange', this.container, false);
+                this.lastOverflow = false;
+            }
+        }
+    },
+
+    /**
+     * @private
+     * Returns a menu config for a given component. This config is used to create a menu item
+     * to be added to the expander menu
+     * @param {Ext.Component} component The component to create the config for
+     * @param {Boolean} hideOnClick Passed through to the menu item
+     */
+    createMenuConfig : function(component, hideOnClick){
+        var config = Ext.apply({}, component.initialConfig),
+            group  = component.toggleGroup;
+
+        Ext.copyTo(config, component, [
+            'iconCls', 'icon', 'itemId', 'disabled', 'handler', 'scope', 'menu'
+        ]);
+
+        Ext.apply(config, {
+            text       : component.overflowText || component.text,
+            hideOnClick: hideOnClick
+        });
+
+        if (group || component.enableToggle) {
+            Ext.apply(config, {
+                group  : group,
+                checked: component.pressed,
+                listeners: {
+                    checkchange: function(item, checked){
+                        component.toggle(checked);
+                    }
+                }
+            });
+        }
+
+        delete config.ownerCt;
+        delete config.xtype;
+        delete config.id;
+
+        return config;
+    },
+
+    /**
+     * @private
+     * Adds the given Toolbar item to the given menu. Buttons inside a buttongroup are added individually.
+     * @param {Ext.menu.Menu} menu The menu to add to
+     * @param {Ext.Component} component The component to add
+     */
+    addComponentToMenu : function(menu, component) {
+        if (component instanceof Ext.Toolbar.Separator) {
+            menu.add('-');
+
+        } else if (Ext.isFunction(component.isXType)) {
+            if (component.isXType('splitbutton')) {
+                menu.add(this.createMenuConfig(component, true));
+
+            } else if (component.isXType('button')) {
+                menu.add(this.createMenuConfig(component, !component.menu));
+
+            } else if (component.isXType('buttongroup')) {
+                component.items.each(function(item){
+                     this.addComponentToMenu(menu, item);
+                }, this);
+            }
+        }
+    },
+
+    /**
+     * @private
+     * Deletes the sub-menu of each item in the expander menu. Submenus are created for items such as
+     * splitbuttons and buttongroups, where the Toolbar item cannot be represented by a single menu item
+     */
+    clearMenu : function(){
+        var menu = this.moreMenu;
+        if (menu && menu.items) {
+            menu.items.each(function(item){
+                delete item.menu;
+            });
+        }
+    },
+
+    /**
+     * @private
+     * Called before the expand menu is shown, this rebuilds the menu since it was last shown because
+     * it is possible that the items hidden due to space limitations on the Toolbar have changed since.
+     * @param {Ext.menu.Menu} m The menu
+     */
+    beforeMoreShow : function(menu) {
+        var items = this.container.items.items,
+            len   = items.length,
+            item,
+            prev;
+
+        var needsSep = function(group, item){
+            return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);
+        };
+
+        this.clearMenu();
+        menu.removeAll();
+        for (var i = 0; i < len; i++) {
+            item = items[i];
+            if (item.xtbHidden) {
+                if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
+                    menu.add('-');
+                }
+                this.addComponentToMenu(menu, item);
+                prev = item;
+            }
+        }
+
+        // put something so the menu isn't empty if no compatible items found
+        if (menu.items.length < 1) {
+            menu.add(this.noItemsMenuText);
+        }
+    },
+
+    /**
+     * @private
+     * Creates the expand trigger and menu, adding them to the  at the extreme right of the
+     * Toolbar table
+     */
+    initMore : function(){
+        if (!this.more) {
+            /**
+             * @private
+             * @property moreMenu
+             * @type Ext.menu.Menu
+             * The expand menu - holds items for every Toolbar item that cannot be shown
+             * because the Toolbar is currently not wide enough.
+             */
+            this.moreMenu = new Ext.menu.Menu({
+                ownerCt : this.container,
+                listeners: {
+                    beforeshow: this.beforeMoreShow,
+                    scope: this
+                }
+            });
+
+            /**
+             * @private
+             * @property more
+             * @type Ext.Button
+             * The expand button which triggers the overflow menu to be shown
+             */
+            this.more = new Ext.Button({
+                iconCls: 'x-toolbar-more-icon',
+                cls    : 'x-toolbar-more',
+                menu   : this.moreMenu,
+                ownerCt: this.container
+            });
+
+            var td = this.insertCell(this.more, this.extrasTr, 100);
+            this.more.render(td);
+        }
+    },
+
+    destroy : function(){
+        Ext.destroy(this.more, this.moreMenu);
+        delete this.leftTr;
+        delete this.rightTr;
+        delete this.extrasTr;
+        Ext.layout.ToolbarLayout.superclass.destroy.call(this);
+    }
+});
+
+Ext.Container.LAYOUTS.toolbar = Ext.layout.ToolbarLayout;
+/**
+ * @class Ext.layout.MenuLayout
+ * @extends Ext.layout.ContainerLayout
+ * Layout manager used by {@link Ext.menu.Menu}. Generally this class should not need to be used directly.
+ */
+ Ext.layout.MenuLayout = Ext.extend(Ext.layout.ContainerLayout, {
+    monitorResize : true,
+
+    type: 'menu',
+
+    setContainer : function(ct){
+        this.monitorResize = !ct.floating;
+        // This event is only fired by the menu in IE, used so we don't couple
+        // the menu with the layout.
+        ct.on('autosize', this.doAutoSize, this);
+        Ext.layout.MenuLayout.superclass.setContainer.call(this, ct);
+    },
+
+    renderItem : function(c, position, target){
+        if (!this.itemTpl) {
+            this.itemTpl = Ext.layout.MenuLayout.prototype.itemTpl = new Ext.XTemplate(
+                '',
+                    '',
+                        '',
+                    '',
+                ''
+            );
+        }
+
+        if(c && !c.rendered){
+            if(Ext.isNumber(position)){
+                position = target.dom.childNodes[position];
+            }
+            var a = this.getItemArgs(c);
+
+//          The Component's positionEl is the  it is rendered into
+            c.render(c.positionEl = position ?
+                this.itemTpl.insertBefore(position, a, true) :
+                this.itemTpl.append(target, a, true));
+
+//          Link the containing 
 to the item.
+            c.positionEl.menuItemId = c.getItemId();
+
+//          If rendering a regular Component, and it needs an icon,
+//          move the Component rightwards.
+            if (!a.isMenuItem && a.needsIcon) {
+                c.positionEl.addClass('x-menu-list-item-indent');
+            }
+            this.configureItem(c, position);
+        }else if(c && !this.isValidParent(c, target)){
+            if(Ext.isNumber(position)){
+                position = target.dom.childNodes[position];
+            }
+            target.dom.insertBefore(c.getActionEl().dom, position || null);
+        }
+    },
+
+    getItemArgs : function(c) {
+        var isMenuItem = c instanceof Ext.menu.Item;
+        return {
+            isMenuItem: isMenuItem,
+            needsIcon: !isMenuItem && (c.icon || c.iconCls),
+            icon: c.icon || Ext.BLANK_IMAGE_URL,
+            iconCls: 'x-menu-item-icon ' + (c.iconCls || ''),
+            itemId: 'x-menu-el-' + c.id,
+            itemCls: 'x-menu-list-item '
+        };
+    },
+
+    //  Valid if the Component is in a 
 which is part of our target 
+    isValidParent : function(c, target) {
+        return c.el.up('li.x-menu-list-item', 5).dom.parentNode === (target.dom || target);
+    },
+
+    onLayout : function(ct, target){
+        Ext.layout.MenuLayout.superclass.onLayout.call(this, ct, target);
+        this.doAutoSize();
+    },
+
+    doAutoSize : function(){
+        var ct = this.container, w = ct.width;
+        if(ct.floating){
+            if(w){
+                ct.setWidth(w);
+            }else if(Ext.isIE){
+                ct.setWidth(Ext.isStrict && (Ext.isIE7 || Ext.isIE8) ? 'auto' : ct.minWidth);
+                var el = ct.getEl(), t = el.dom.offsetWidth; // force recalc
+                ct.setWidth(ct.getLayoutTarget().getWidth() + el.getFrameWidth('lr'));
+            }
+        }
+    }
+});
+Ext.Container.LAYOUTS['menu'] = Ext.layout.MenuLayout;
+/**
+ * @class Ext.Viewport
+ * @extends Ext.Container
+ * A specialized container representing the viewable application area (the browser viewport).
+ * The Viewport renders itself to the document body, and automatically sizes itself to the size of
+ * the browser viewport and manages window resizing. There may only be one Viewport created
+ * in a page. Inner layouts are available by virtue of the fact that all {@link Ext.Panel Panel}s
+ * added to the Viewport, either through its {@link #items}, or through the items, or the {@link #add}
+ * method of any of its child Panels may themselves have a layout.
+ * The Viewport does not provide scrolling, so child Panels within the Viewport should provide
+ * for scrolling if needed using the {@link #autoScroll} config.
+ * An example showing a classic application border layout:

+new Ext.Viewport({
+    layout: 'border',
+    items: [{
+        region: 'north',
+        html: '<h1 class="x-panel-header">Page Title</h1>',
+        autoHeight: true,
+        border: false,
+        margins: '0 0 5 0'
+    }, {
+        region: 'west',
+        collapsible: true,
+        title: 'Navigation',
+        width: 200
+        // the west region might typically utilize a {@link Ext.tree.TreePanel TreePanel} or a Panel with {@link Ext.layout.AccordionLayout Accordion layout}
+    }, {
+        region: 'south',
+        title: 'Title for Panel',
+        collapsible: true,
+        html: 'Information goes here',
+        split: true,
+        height: 100,
+        minHeight: 100
+    }, {
+        region: 'east',
+        title: 'Title for the Grid Panel',
+        collapsible: true,
+        split: true,
+        width: 200,
+        xtype: 'grid',
+        // remaining grid configuration not shown ...
+        // notice that the GridPanel is added directly as the region
+        // it is not "overnested" inside another Panel
+    }, {
+        region: 'center',
+        xtype: 'tabpanel', // TabPanel itself has no title
+        items: {
+            title: 'Default Tab',
+            html: 'The first tab\'s content. Others may be added dynamically'
+        }
+    }]
+});
+
+ * @constructor
+ * Create a new Viewport
+ * @param {Object} config The config object
+ * @xtype viewport
+ */
+Ext.Viewport = Ext.extend(Ext.Container, {
+    /*
+     * Privatize config options which, if used, would interfere with the
+     * correct operation of the Viewport as the sole manager of the
+     * layout of the document body.
+     */
+    /**
+     * @cfg {Mixed} applyTo @hide
+     */
+    /**
+     * @cfg {Boolean} allowDomMove @hide
+     */
+    /**
+     * @cfg {Boolean} hideParent @hide
+     */
+    /**
+     * @cfg {Mixed} renderTo @hide
+     */
+    /**
+     * @cfg {Boolean} hideParent @hide
+     */
+    /**
+     * @cfg {Number} height @hide
+     */
+    /**
+     * @cfg {Number} width @hide
+     */
+    /**
+     * @cfg {Boolean} autoHeight @hide
+     */
+    /**
+     * @cfg {Boolean} autoWidth @hide
+     */
+    /**
+     * @cfg {Boolean} deferHeight @hide
+     */
+    /**
+     * @cfg {Boolean} monitorResize @hide
+     */
+
+    initComponent : function() {
+        Ext.Viewport.superclass.initComponent.call(this);
+        document.getElementsByTagName('html')[0].className += ' x-viewport';
+        this.el = Ext.getBody();
+        this.el.setHeight = Ext.emptyFn;
+        this.el.setWidth = Ext.emptyFn;
+        this.el.setSize = Ext.emptyFn;
+        this.el.dom.scroll = 'no';
+        this.allowDomMove = false;
+        this.autoWidth = true;
+        this.autoHeight = true;
+        Ext.EventManager.onWindowResize(this.fireResize, this);
+        this.renderTo = this.el;
+    },
+
+    fireResize : function(w, h){
+        this.fireEvent('resize', this, w, h, w, h);
+    }
+});
+Ext.reg('viewport', Ext.Viewport);
+/**
+ * @class Ext.Panel
+ * @extends Ext.Container
+ * Panel is a container that has specific functionality and structural components that make
+ * it the perfect building block for application-oriented user interfaces.
+ * Panels are, by virtue of their inheritance from {@link Ext.Container}, capable
+ * of being configured with a {@link Ext.Container#layout layout}, and containing child Components.
+ * When either specifying child {@link Ext.Component#items items} of a Panel, or dynamically {@link Ext.Container#add adding} Components
+ * to a Panel, remember to consider how you wish the Panel to arrange those child elements, and whether
+ * those child elements need to be sized using one of Ext's built-in {@link Ext.Container#layout layout} schemes. By
+ * default, Panels use the {@link Ext.layout.ContainerLayout ContainerLayout} scheme. This simply renders
+ * child components, appending them one after the other inside the Container, and does not apply any sizing
+ * at all.
+ * A Panel may also contain {@link #bbar bottom} and {@link #tbar top} toolbars, along with separate
+ * {@link #header}, {@link #footer} and {@link #body} sections (see {@link #frame} for additional
+ * information).
+ * Panel also provides built-in {@link #collapsible expandable and collapsible behavior}, along with
+ * a variety of {@link #tools prebuilt tool buttons} that can be wired up to provide other customized
+ * behavior.  Panels can be easily dropped into any {@link Ext.Container Container} or layout, and the
+ * layout and rendering pipeline is {@link Ext.Container#add completely managed by the framework}.
+ * @constructor
+ * @param {Object} config The config object
+ * @xtype panel
+ */
+Ext.Panel = Ext.extend(Ext.Container, {
+    /**
+     * The Panel's header {@link Ext.Element Element}. Read-only.
+     * This Element is used to house the {@link #title} and {@link #tools}
+     * 
Note: see the Note for {@link Ext.Component#el el} also.
+     * @type Ext.Element
+     * @property header
+     */
+    /**
+     * The Panel's body {@link Ext.Element Element} which may be used to contain HTML content.
+     * The content may be specified in the {@link #html} config, or it may be loaded using the
+     * {@link autoLoad} config, or through the Panel's {@link #getUpdater Updater}. Read-only.
+     * If this is used to load visible HTML elements in either way, then
+     * the Panel may not be used as a Layout for hosting nested Panels.
+     * If this Panel is intended to be used as the host of a Layout (See {@link #layout}
+     * then the body Element must not be loaded or changed - it is under the control
+     * of the Panel's Layout.
+     * 
Note: see the Note for {@link Ext.Component#el el} also.
+     * @type Ext.Element
+     * @property body
+     */
+    /**
+     * The Panel's bwrap {@link Ext.Element Element} used to contain other Panel elements
+     * (tbar, body, bbar, footer). See {@link #bodyCfg}. Read-only.
+     * @type Ext.Element
+     * @property bwrap
+     */
+    /**
+     * True if this panel is collapsed. Read-only.
+     * @type Boolean
+     * @property collapsed
+     */
+    /**
+     * @cfg {Object} bodyCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object may be specified for any
+     * Panel Element.
+     * By default, the Default element in the table below will be used for the html markup to
+     * create a child element with the commensurate Default class name (baseCls will be
+     * replaced by {@link #baseCls}):
+     * +     * Panel      Default  Default             Custom      Additional       Additional
+     * Element    element  class               element     class            style
+     * ========   ==========================   =========   ==============   ===========
+     * {@link #header}     div      {@link #baseCls}+'-header'   {@link #headerCfg}   headerCssClass   headerStyle
+     * {@link #bwrap}      div      {@link #baseCls}+'-bwrap'     {@link #bwrapCfg}    bwrapCssClass    bwrapStyle
+     * + tbar     div      {@link #baseCls}+'-tbar'       {@link #tbarCfg}     tbarCssClass     tbarStyle
+     * + {@link #body}     div      {@link #baseCls}+'-body'       {@link #bodyCfg}     {@link #bodyCssClass}     {@link #bodyStyle}
+     * + bbar     div      {@link #baseCls}+'-bbar'       {@link #bbarCfg}     bbarCssClass     bbarStyle
+     * + {@link #footer}   div      {@link #baseCls}+'-footer'   {@link #footerCfg}   footerCssClass   footerStyle
+     * 
+     * Configuring a Custom element may be used, for example, to force the {@link #body} Element
+     * to use a different form of markup than is created by default. An example of this might be
+     * to {@link Ext.Element#createChild create a child} Panel containing a custom content, such as
+     * a header, or forcing centering of all Panel content by having the body be a <center>
+     * element:
+     * 
+new Ext.Panel({
+    title: 'Message Title',
+    renderTo: Ext.getBody(),
+    width: 200, height: 130,
+    bodyCfg: {
+        tag: 'center',
+        cls: 'x-panel-body',  // Default class not applied if Custom element specified
+        html: 'Message'
+    },
+    footerCfg: {
+        tag: 'h2',
+        cls: 'x-panel-footer'        // same as the Default class
+        html: 'footer html'
+    },
+    footerCssClass: 'custom-footer', // additional css class, see {@link Ext.element#addClass addClass}
+    footerStyle:    'background-color:red' // see {@link #bodyStyle}
+});
+     * 
+     * The example above also explicitly creates a {@link #footer} with custom markup and
+     * styling applied.
+     */
+    /**
+     * @cfg {Object} headerCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
+     * of this Panel's {@link #header} Element.  See {@link #bodyCfg} also.
+     */
+    /**
+     * @cfg {Object} bwrapCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
+     * of this Panel's {@link #bwrap} Element.  See {@link #bodyCfg} also.
+     */
+    /**
+     * @cfg {Object} tbarCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
+     * of this Panel's {@link #tbar} Element.  See {@link #bodyCfg} also.
+     */
+    /**
+     * @cfg {Object} bbarCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
+     * of this Panel's {@link #bbar} Element.  See {@link #bodyCfg} also.
+     */
+    /**
+     * @cfg {Object} footerCfg
+     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
+     * of this Panel's {@link #footer} Element.  See {@link #bodyCfg} also.
+     */
+    /**
+     * @cfg {Boolean} closable
+     * Panels themselves do not directly support being closed, but some Panel subclasses do (like
+     * {@link Ext.Window}) or a Panel Class within an {@link Ext.TabPanel}.  Specify true
+     * to enable closing in such situations. Defaults to false.
+     */
+    /**
+     * The Panel's footer {@link Ext.Element Element}. Read-only.
+     * This Element is used to house the Panel's {@link #buttons} or {@link #fbar}.
+     * 
Note: see the Note for {@link Ext.Component#el el} also.
+     * @type Ext.Element
+     * @property footer
+     */
+    /**
+     * @cfg {Mixed} applyTo
+     * The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in
+     * the document that specifies some panel-specific structural markup.  When applyTo is used,
+     * constituent parts of the panel can be specified by CSS class name within the main element, and the panel
+     * will automatically create those components from that markup. Any required components not specified in the
+     * markup will be autogenerated if necessary.
+     * The following class names are supported (baseCls will be replaced by {@link #baseCls}):
+     * baseCls + '-header'
+     * baseCls + '-header-text'
+     * baseCls + '-bwrap'
+     * baseCls + '-tbar'
+     * baseCls + '-body'
+     * baseCls + '-bbar'
+     * baseCls + '-footer'
+     * Using this config, a call to render() is not required.  If applyTo is specified, any value passed for
+     * {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the
+     * panel's container.
+     */
+    /**
+     * @cfg {Object/Array} tbar
+     * The top toolbar of the panel. This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of
+     * buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render.
+     * To access the top toolbar after render, use {@link #getTopToolbar}.
+     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
+     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
+     * so are not scanned to collect form items. However, the values will be submitted because form
+     * submission parameters are collected from the DOM tree.
+     */
+    /**
+     * @cfg {Object/Array} bbar
+     * The bottom toolbar of the panel. This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of
+     * buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render.
+     * To access the bottom toolbar after render, use {@link #getBottomToolbar}.
+     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
+     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
+     * so are not scanned to collect form items. However, the values will be submitted because form
+     * submission parameters are collected from the DOM tree.
+     */
+    /** @cfg {Object/Array} fbar
+     * A {@link Ext.Toolbar Toolbar} object, a Toolbar config, or an array of
+     * {@link Ext.Button Button}s/{@link Ext.Button Button} configs, describing a {@link Ext.Toolbar Toolbar} to be rendered into this Panel's footer element.
+     * After render, the fbar property will be an {@link Ext.Toolbar Toolbar} instance.
+     * If {@link #buttons} are specified, they will supersede the fbar configuration property.
+     * The Panel's {@link #buttonAlign} configuration affects the layout of these items, for example:
+     * 
+var w = new Ext.Window({
+    height: 250,
+    width: 500,
+    bbar: new Ext.Toolbar({
+        items: [{
+            text: 'bbar Left'
+        },'->',{
+            text: 'bbar Right'
+        }]
+    }),
+    {@link #buttonAlign}: 'left', // anything but 'center' or 'right' and you can use '-', and '->'
+                                  // to control the alignment of fbar items
+    fbar: [{
+        text: 'fbar Left'
+    },'->',{
+        text: 'fbar Right'
+    }]
+}).show();
+     * 
+     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
+     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
+     * so are not scanned to collect form items. However, the values will be submitted because form
+     * submission parameters are collected from the DOM tree.
+     */
+    /**
+     * @cfg {Boolean} header
+     * true to create the Panel's header element explicitly, false to skip creating
+     * it.  If a {@link #title} is set the header will be created automatically, otherwise it will not.
+     * If a {@link #title} is set but header is explicitly set to false, the header
+     * will not be rendered.
+     */
+    /**
+     * @cfg {Boolean} footer
+     * true to create the footer element explicitly, false to skip creating it. The footer
+     * will be created automatically if {@link #buttons} or a {@link #fbar} have
+     * been configured.  See {@link #bodyCfg} for an example.
+     */
+    /**
+     * @cfg {String} title
+     * The title text to be used as innerHTML (html tags are accepted) to display in the panel
+     * {@link #header} (defaults to ''). When a title is specified the
+     * {@link #header} element will automatically be created and displayed unless
+     * {@link #header} is explicitly set to false.  If you do not want to specify a
+     * title at config time, but you may want one later, you must either specify a non-empty
+     * title (a blank space ' ' will do) or header:true so that the container
+     * element will get created.
+     */
+    /**
+     * @cfg {Array} buttons
+     * buttons will be used as {@link Ext.Container#items items} for the toolbar in
+     * the footer ({@link #fbar}). Typically the value of this configuration property will be
+     * an array of {@link Ext.Button}s or {@link Ext.Button} configuration objects.
+     * If an item is configured with minWidth or the Panel is configured with minButtonWidth,
+     * that width will be applied to the item.
+     */
+    /**
+     * @cfg {Object/String/Function} autoLoad
+     * A valid url spec according to the Updater {@link Ext.Updater#update} method.
+     * If autoLoad is not null, the panel will attempt to load its contents
+     * immediately upon render.
+     * The URL will become the default URL for this panel's {@link #body} element,
+     * so it may be {@link Ext.Element#refresh refresh}ed at any time.
+     */
+    /**
+     * @cfg {Boolean} frame
+     * false by default to render with plain 1px square borders. true to render with
+     * 9 elements, complete with custom rounded corners (also see {@link Ext.Element#boxWrap}).
+     * The template generated for each condition is depicted below:

+     *
+// frame = false
+<div id="developer-specified-id-goes-here" class="x-panel">
+
+    <div class="x-panel-header"><span class="x-panel-header-text">Title: (frame:false)</span></div>
+
+    <div class="x-panel-bwrap">
+        <div class="x-panel-body"><p>html value goes here</p></div>
+    </div>
+</div>
+
+// frame = true (create 9 elements)
+<div id="developer-specified-id-goes-here" class="x-panel">
+    <div class="x-panel-tl"><div class="x-panel-tr"><div class="x-panel-tc">
+        <div class="x-panel-header"><span class="x-panel-header-text">Title: (frame:true)</span></div>
+    </div></div></div>
+
+    <div class="x-panel-bwrap">
+        <div class="x-panel-ml"><div class="x-panel-mr"><div class="x-panel-mc">
+            <div class="x-panel-body"><p>html value goes here</p></div>
+        </div></div></div>
+
+        <div class="x-panel-bl"><div class="x-panel-br"><div class="x-panel-bc"/>
+        </div></div></div>
+</div>
+     * 
+     */
+    /**
+     * @cfg {Boolean} border
+     * True to display the borders of the panel's body element, false to hide them (defaults to true).  By default,
+     * the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
+     */
+    /**
+     * @cfg {Boolean} bodyBorder
+     * True to display an interior border on the body element of the panel, false to hide it (defaults to true).
+     * This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display
+     * as a 1px wide inset border, giving the entire body element an inset appearance.
+     */
+    /**
+     * @cfg {String/Object/Function} bodyCssClass
+     * Additional css class selector to be applied to the {@link #body} element in the format expected by
+     * {@link Ext.Element#addClass} (defaults to null). See {@link #bodyCfg}.
+     */
+    /**
+     * @cfg {String/Object/Function} bodyStyle
+     * Custom CSS styles to be applied to the {@link #body} element in the format expected by
+     * {@link Ext.Element#applyStyles} (defaults to null). See {@link #bodyCfg}.
+     */
+    /**
+     * @cfg {String} iconCls
+     * The CSS class selector that specifies a background image to be used as the header icon (defaults to '').
+     * An example of specifying a custom icon class would be something like:
+     * 

+// specify the property in the config for the class:
+     ...
+     iconCls: 'my-icon'
+
+// css class that specifies background image to be used as the icon image:
+.my-icon { background-image: url(../images/my-icon.gif) 0 6px no-repeat !important; }
+
+     */
+    /**
+     * @cfg {Boolean} collapsible
+     * True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into
+     * the header tool button area, false to keep the panel statically sized with no button (defaults to false).
+     */
+    /**
+     * @cfg {Array} tools
+     * An array of tool button configs to be added to the header tool area. When rendered, each tool is
+     * stored as an {@link Ext.Element Element} referenced by a public property called tools.<tool-type>
+     * Each tool config may contain the following properties:
+     * 

+     * id : StringRequired. The type
+     * of tool to create. By default, this assigns a CSS class of the form x-tool-<tool-type> to the
+     * resulting tool Element. Ext provides CSS rules, and an icon sprite containing images for the tool types listed below.
+     * The developer may implement custom tools by supplying alternate CSS rules and background images:
+     * 
+     *  
 toggle (Created by default when {@link #collapsible} is true)
+     *  
 close
+     *  
 minimize
+     *  
 maximize
+     *  
 restore
+     *  
 gear
+     *  
 pin
+     *  
 unpin
+     *  
 right
+     *  
 left
+     *  
 up
+     *  
 down
+     *  
 refresh
+     *  
 minus
+     *  
 plus
+     *  
 help
+     *  
 search
+     *  
 save
+     *  
 print
+     * 
+     * handler : FunctionRequired. The function to
+     * call when clicked. Arguments passed are:
+     * event : Ext.EventObjectThe click event.
+     * toolEl : Ext.ElementThe tool Element.
+     * panel : Ext.PanelThe host Panel
+     * tc : ObjectThe tool configuration object
+     * 
+     * stopEvent : BooleanDefaults to true. Specify as false to allow click event to propagate.
+     * scope : ObjectThe scope in which to call the handler.
+     * qtip : String/ObjectA tip string, or
+     * a config argument to {@link Ext.QuickTip#register}
+     * hidden : BooleanTrue to initially render hidden.
+     * on : ObjectA listener config object specifiying
+     * event listeners in the format of an argument to {@link #addListener}
+     * 
+     * Note that, apart from the toggle tool which is provided when a panel is collapsible, these
+     * tools only provide the visual button. Any required functionality must be provided by adding
+     * handlers that implement the necessary behavior.
+     * Example usage:
+     * 
+tools:[{
+    id:'refresh',
+    qtip: 'Refresh form Data',
+    // hidden:true,
+    handler: function(event, toolEl, panel){
+        // refresh logic
+    }
+},
+{
+    id:'help',
+    qtip: 'Get Help',
+    handler: function(event, toolEl, panel){
+        // whatever
+    }
+}]
+
+     * For the custom id of 'help' define two relevant css classes with a link to
+     * a 15x15 image:
+     * 
+.x-tool-help {background-image: url(images/help.png);}
+.x-tool-help-over {background-image: url(images/help_over.png);}
+// if using an image sprite:
+.x-tool-help {background-image: url(images/help.png) no-repeat 0 0;}
+.x-tool-help-over {background-position:-15px 0;}
+
+     */
+    /**
+     * @cfg {Ext.Template/Ext.XTemplate} toolTemplate
+     * A Template used to create {@link #tools} in the {@link #header} Element. Defaults to:

+new Ext.Template('<div class="x-tool x-tool-{id}">&#160;</div>')
+     * This may may be overridden to provide a custom DOM structure for tools based upon a more
+     * complex XTemplate. The template's data is a single tool configuration object (Not the entire Array)
+     * as specified in {@link #tools}.  In the following example an <a> tag is used to provide a
+     * visual indication when hovering over the tool:

+var win = new Ext.Window({
+    tools: [{
+        id: 'download',
+        href: '/MyPdfDoc.pdf'
+    }],
+    toolTemplate: new Ext.XTemplate(
+        '<tpl if="id==\'download\'">',
+            '<a class="x-tool x-tool-pdf" href="{href}"></a>',
+        '</tpl>',
+        '<tpl if="id!=\'download\'">',
+            '<div class="x-tool x-tool-{id}">&#160;</div>',
+        '</tpl>'
+    ),
+    width:500,
+    height:300,
+    closeAction:'hide'
+});
+     * Note that the CSS class 'x-tool-pdf' should have an associated style rule which provides an
+     * appropriate background image, something like:
+    
+    a.x-tool-pdf {background-image: url(../shared/extjs/images/pdf.gif)!important;}
+    
+     */
+    /**
+     * @cfg {Boolean} hideCollapseTool
+     * true to hide the expand/collapse toggle button when {@link #collapsible} == true,
+     * false to display it (defaults to false).
+     */
+    /**
+     * @cfg {Boolean} titleCollapse
+     * true to allow expanding and collapsing the panel (when {@link #collapsible} = true)
+     * by clicking anywhere in the header bar, false) to allow it only by clicking to tool button
+     * (defaults to false)). If this panel is a child item of a border layout also see the
+     * {@link Ext.layout.BorderLayout.Region BorderLayout.Region}
+     * {@link Ext.layout.BorderLayout.Region#floatable floatable} config option.
+     */
+
+    /**
+     * @cfg {Mixed} floating
+     * This property is used to configure the underlying {@link Ext.Layer}. Acceptable values for this
+     * configuration property are:

+     * false : Default.Display the panel inline where it is
+     * rendered.
+     * true : Float the panel (absolute position it with automatic
+     * shimming and shadow).
+     * Setting floating to true will create an Ext.Layer for this panel and display the
+     * panel at negative offsets so that it is hidden.
+     * Since the panel will be absolute positioned, the position must be set explicitly
+     * after render (e.g., myPanel.setPosition(100,100);).
+     * Note: when floating a panel you should always assign a fixed width,
+     * otherwise it will be auto width and will expand to fill to the right edge of the viewport.
+     * 
+     * {@link Ext.Layer object} : The specified object will be used
+     * as the configuration object for the {@link Ext.Layer} that will be created.
+     * 
+     */
+    /**
+     * @cfg {Boolean/String} shadow
+     * true (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the
+     * panel, false to display no shadow (defaults to 'sides').  Note that this option
+     * only applies when {@link #floating} = true.
+     */
+    /**
+     * @cfg {Number} shadowOffset
+     * The number of pixels to offset the shadow if displayed (defaults to 4). Note that this
+     * option only applies when {@link #floating} = true.
+     */
+    /**
+     * @cfg {Boolean} shim
+     * false to disable the iframe shim in browsers which need one (defaults to true).
+     * Note that this option only applies when {@link #floating} = true.
+     */
+    /**
+     * @cfg {Object/Array} keys
+     * A {@link Ext.KeyMap} config object (in the format expected by {@link Ext.KeyMap#addBinding}
+     * used to assign custom key handling to this panel (defaults to null).
+     */
+    /**
+     * @cfg {Boolean/Object} draggable
+     * true to enable dragging of this Panel (defaults to false).
+     * For custom drag/drop implementations, an Ext.Panel.DD config could also be passed
+     * in this config instead of true. Ext.Panel.DD is an internal, undocumented class which
+     * moves a proxy Element around in place of the Panel's element, but provides no other behaviour
+     * during dragging or on drop. It is a subclass of {@link Ext.dd.DragSource}, so behaviour may be
+     * added by implementing the interface methods of {@link Ext.dd.DragDrop} e.g.:
+     * 

+new Ext.Panel({
+    title: 'Drag me',
+    x: 100,
+    y: 100,
+    renderTo: Ext.getBody(),
+    floating: true,
+    frame: true,
+    width: 400,
+    height: 200,
+    draggable: {
+//      Config option of Ext.Panel.DD class.
+//      It's a floating Panel, so do not show a placeholder proxy in the original position.
+        insertProxy: false,
+
+//      Called for each mousemove event while dragging the DD object.
+        onDrag : function(e){
+//          Record the x,y position of the drag proxy so that we can
+//          position the Panel at end of drag.
+            var pel = this.proxy.getEl();
+            this.x = pel.getLeft(true);
+            this.y = pel.getTop(true);
+
+//          Keep the Shadow aligned if there is one.
+            var s = this.panel.getEl().shadow;
+            if (s) {
+                s.realign(this.x, this.y, pel.getWidth(), pel.getHeight());
+            }
+        },
+
+//      Called on the mouseup event.
+        endDrag : function(e){
+            this.panel.setPosition(this.x, this.y);
+        }
+    }
+}).show();
+
+     */
+    /**
+     * @cfg {Boolean} disabled
+     * Render this panel disabled (default is false). An important note when using the disabled
+     * config on panels is that IE will often fail to initialize the disabled mask element correectly if
+     * the panel's layout has not yet completed by the time the Panel is disabled during the render process.
+     * If you experience this issue, you may need to instead use the {@link #afterlayout} event to initialize
+     * the disabled state:
+     * 
+new Ext.Panel({
+    ...
+    listeners: {
+        'afterlayout': {
+            fn: function(p){
+                p.disable();
+            },
+            single: true // important, as many layouts can occur
+        }
+    }
+});
+
+     */
+    /**
+     * @cfg {Boolean} autoHeight
+     * true to use height:'auto', false to use fixed height (defaults to false).
+     * Note: Setting autoHeight: true means that the browser will manage the panel's height
+     * based on its contents, and that Ext will not manage it at all. If the panel is within a layout that
+     * manages dimensions (fit, border, etc.) then setting autoHeight: true
+     * can cause issues with scrolling and will not generally work as expected since the panel will take
+     * on the height of its contents rather than the height required by the Ext layout.
+     */
+
+
+    /**
+     * @cfg {String} baseCls
+     * The base CSS class to apply to this panel's element (defaults to 'x-panel').
+     * Another option available by default is to specify 'x-plain' which strips all styling
+     * except for required attributes for Ext layouts to function (e.g. overflow:hidden).
+     * See {@link #unstyled} also.
+     */
+    baseCls : 'x-panel',
+    /**
+     * @cfg {String} collapsedCls
+     * A CSS class to add to the panel's element after it has been collapsed (defaults to
+     * 'x-panel-collapsed').
+     */
+    collapsedCls : 'x-panel-collapsed',
+    /**
+     * @cfg {Boolean} maskDisabled
+     * true to mask the panel when it is {@link #disabled}, false to not mask it (defaults
+     * to true).  Either way, the panel will always tell its contained elements to disable themselves
+     * when it is disabled, but masking the panel can provide an additional visual cue that the panel is
+     * disabled.
+     */
+    maskDisabled : true,
+    /**
+     * @cfg {Boolean} animCollapse
+     * true to animate the transition when the panel is collapsed, false to skip the
+     * animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
+     */
+    animCollapse : Ext.enableFx,
+    /**
+     * @cfg {Boolean} headerAsText
+     * true to display the panel {@link #title} in the {@link #header},
+     * false to hide it (defaults to true).
+     */
+    headerAsText : true,
+    /**
+     * @cfg {String} buttonAlign
+     * The alignment of any {@link #buttons} added to this panel.  Valid values are 'right',
+     * 'left' and 'center' (defaults to 'right').
+     */
+    buttonAlign : 'right',
+    /**
+     * @cfg {Boolean} collapsed
+     * true to render the panel collapsed, false to render it expanded (defaults to
+     * false).
+     */
+    collapsed : false,
+    /**
+     * @cfg {Boolean} collapseFirst
+     * true to make sure the collapse/expand toggle button always renders first (to the left of)
+     * any other tools in the panel's title bar, false to render it last (defaults to true).
+     */
+    collapseFirst : true,
+    /**
+     * @cfg {Number} minButtonWidth
+     * Minimum width in pixels of all {@link #buttons} in this panel (defaults to 75)
+     */
+    minButtonWidth : 75,
+    /**
+     * @cfg {Boolean} unstyled
+     * Overrides the {@link #baseCls} setting to {@link #baseCls} = 'x-plain' which renders
+     * the panel unstyled except for required attributes for Ext layouts to function (e.g. overflow:hidden).
+     */
+    /**
+     * @cfg {String} elements
+     * A comma-delimited list of panel elements to initialize when the panel is rendered.  Normally, this list will be
+     * generated automatically based on the items added to the panel at config time, but sometimes it might be useful to
+     * make sure a structural element is rendered even if not specified at config time (for example, you may want
+     * to add a button or toolbar dynamically after the panel has been rendered).  Adding those elements to this
+     * list will allocate the required placeholders in the panel when it is rendered.  Valid values are
+     * header
+     * tbar (top bar)
+     * body
+     * bbar (bottom bar)
+     * footer
+     * 
+     * Defaults to 'body'.
+     */
+    elements : 'body',
+    /**
+     * @cfg {Boolean} preventBodyReset
+     * Defaults to false.  When set to true, an extra css class 'x-panel-normal'
+     * will be added to the panel's element, effectively applying css styles suggested by the W3C
+     * (see http://www.w3.org/TR/CSS21/sample.html) to the Panel's body element (not the header,
+     * footer, etc.).
+     */
+    preventBodyReset : false,
+
+    /**
+     * @cfg {Number/String} padding
+     * A shortcut for setting a padding style on the body element. The value can either be
+     * a number to be applied to all sides, or a normal css string describing padding.
+     * Defaults to undefined.
+     *
+     */
+    padding: undefined,
+
+    /** @cfg {String} resizeEvent
+     * The event to listen to for resizing in layouts. Defaults to 'bodyresize'.
+     */
+    resizeEvent: 'bodyresize',
+
+    // protected - these could be used to customize the behavior of the window,
+    // but changing them would not be useful without further mofifications and
+    // could lead to unexpected or undesirable results.
+    toolTarget : 'header',
+    collapseEl : 'bwrap',
+    slideAnchor : 't',
+    disabledClass : '',
+
+    // private, notify box this class will handle heights
+    deferHeight : true,
+    // private
+    expandDefaults: {
+        duration : 0.25
+    },
+    // private
+    collapseDefaults : {
+        duration : 0.25
+    },
+
+    // private
+    initComponent : function(){
+        Ext.Panel.superclass.initComponent.call(this);
+
+        this.addEvents(
+            /**
+             * @event bodyresize
+             * Fires after the Panel has been resized.
+             * @param {Ext.Panel} p the Panel which has been resized.
+             * @param {Number} width The Panel body's new width.
+             * @param {Number} height The Panel body's new height.
+             */
+            'bodyresize',
+            /**
+             * @event titlechange
+             * Fires after the Panel title has been {@link #title set} or {@link #setTitle changed}.
+             * @param {Ext.Panel} p the Panel which has had its title changed.
+             * @param {String} The new title.
+             */
+            'titlechange',
+            /**
+             * @event iconchange
+             * Fires after the Panel icon class has been {@link #iconCls set} or {@link #setIconClass changed}.
+             * @param {Ext.Panel} p the Panel which has had its {@link #iconCls icon class} changed.
+             * @param {String} The new icon class.
+             * @param {String} The old icon class.
+             */
+            'iconchange',
+            /**
+             * @event collapse
+             * Fires after the Panel has been collapsed.
+             * @param {Ext.Panel} p the Panel that has been collapsed.
+             */
+            'collapse',
+            /**
+             * @event expand
+             * Fires after the Panel has been expanded.
+             * @param {Ext.Panel} p The Panel that has been expanded.
+             */
+            'expand',
+            /**
+             * @event beforecollapse
+             * Fires before the Panel is collapsed.  A handler can return false to cancel the collapse.
+             * @param {Ext.Panel} p the Panel being collapsed.
+             * @param {Boolean} animate True if the collapse is animated, else false.
+             */
+            'beforecollapse',
+            /**
+             * @event beforeexpand
+             * Fires before the Panel is expanded.  A handler can return false to cancel the expand.
+             * @param {Ext.Panel} p The Panel being expanded.
+             * @param {Boolean} animate True if the expand is animated, else false.
+             */
+            'beforeexpand',
+            /**
+             * @event beforeclose
+             * Fires before the Panel is closed.  Note that Panels do not directly support being closed, but some
+             * Panel subclasses do (like {@link Ext.Window}) or a Panel within a Ext.TabPanel.  This event only
+             * applies to such subclasses.
+             * A handler can return false to cancel the close.
+             * @param {Ext.Panel} p The Panel being closed.
+             */
+            'beforeclose',
+            /**
+             * @event close
+             * Fires after the Panel is closed.  Note that Panels do not directly support being closed, but some
+             * Panel subclasses do (like {@link Ext.Window}) or a Panel within a Ext.TabPanel.
+             * @param {Ext.Panel} p The Panel that has been closed.
+             */
+            'close',
+            /**
+             * @event activate
+             * Fires after the Panel has been visually activated.
+             * Note that Panels do not directly support being activated, but some Panel subclasses
+             * do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
+             * activate and deactivate events under the control of the TabPanel.
+             * @param {Ext.Panel} p The Panel that has been activated.
+             */
+            'activate',
+            /**
+             * @event deactivate
+             * Fires after the Panel has been visually deactivated.
+             * Note that Panels do not directly support being deactivated, but some Panel subclasses
+             * do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
+             * activate and deactivate events under the control of the TabPanel.
+             * @param {Ext.Panel} p The Panel that has been deactivated.
+             */
+            'deactivate'
+        );
+
+        if(this.unstyled){
+            this.baseCls = 'x-plain';
+        }
+
+
+        this.toolbars = [];
+        // shortcuts
+        if(this.tbar){
+            this.elements += ',tbar';
+            this.topToolbar = this.createToolbar(this.tbar);
+            this.tbar = null;
+
+        }
+        if(this.bbar){
+            this.elements += ',bbar';
+            this.bottomToolbar = this.createToolbar(this.bbar);
+            this.bbar = null;
+        }
+
+        if(this.header === true){
+            this.elements += ',header';
+            this.header = null;
+        }else if(this.headerCfg || (this.title && this.header !== false)){
+            this.elements += ',header';
+        }
+
+        if(this.footerCfg || this.footer === true){
+            this.elements += ',footer';
+            this.footer = null;
+        }
+
+        if(this.buttons){
+            this.fbar = this.buttons;
+            this.buttons = null;
+        }
+        if(this.fbar){
+            this.createFbar(this.fbar);
+        }
+        if(this.autoLoad){
+            this.on('render', this.doAutoLoad, this, {delay:10});
+        }
+    },
+
+    // private
+    createFbar : function(fbar){
+        var min = this.minButtonWidth;
+        this.elements += ',footer';
+        this.fbar = this.createToolbar(fbar, {
+            buttonAlign: this.buttonAlign,
+            toolbarCls: 'x-panel-fbar',
+            enableOverflow: false,
+            defaults: function(c){
+                return {
+                    minWidth: c.minWidth || min
+                };
+            }
+        });
+        // @compat addButton and buttons could possibly be removed
+        // @target 4.0
+        /**
+         * This Panel's Array of buttons as created from the {@link #buttons}
+         * config property. Read only.
+         * @type Array
+         * @property buttons
+         */
+        this.fbar.items.each(function(c){
+            c.minWidth = c.minWidth || this.minButtonWidth;
+        }, this);
+        this.buttons = this.fbar.items.items;
+    },
+
+    // private
+    createToolbar: function(tb, options){
+        var result;
+        // Convert array to proper toolbar config
+        if(Ext.isArray(tb)){
+            tb = {
+                items: tb
+            };
+        }
+        result = tb.events ? Ext.apply(tb, options) : this.createComponent(Ext.apply({}, tb, options), 'toolbar');
+        this.toolbars.push(result);
+        return result;
+    },
+
+    // private
+    createElement : function(name, pnode){
+        if(this[name]){
+            pnode.appendChild(this[name].dom);
+            return;
+        }
+
+        if(name === 'bwrap' || this.elements.indexOf(name) != -1){
+            if(this[name+'Cfg']){
+                this[name] = Ext.fly(pnode).createChild(this[name+'Cfg']);
+            }else{
+                var el = document.createElement('div');
+                el.className = this[name+'Cls'];
+                this[name] = Ext.get(pnode.appendChild(el));
+            }
+            if(this[name+'CssClass']){
+                this[name].addClass(this[name+'CssClass']);
+            }
+            if(this[name+'Style']){
+                this[name].applyStyles(this[name+'Style']);
+            }
+        }
+    },
+
+    // private
+    onRender : function(ct, position){
+        Ext.Panel.superclass.onRender.call(this, ct, position);
+        this.createClasses();
+
+        var el = this.el,
+            d = el.dom,
+            bw,
+            ts;
+
+
+        if(this.collapsible && !this.hideCollapseTool){
+            this.tools = this.tools ? this.tools.slice(0) : [];
+            this.tools[this.collapseFirst?'unshift':'push']({
+                id: 'toggle',
+                handler : this.toggleCollapse,
+                scope: this
+            });
+        }
+
+        if(this.tools){
+            ts = this.tools;
+            this.elements += (this.header !== false) ? ',header' : '';
+        }
+        this.tools = {};
+
+        el.addClass(this.baseCls);
+        if(d.firstChild){ // existing markup
+            this.header = el.down('.'+this.headerCls);
+            this.bwrap = el.down('.'+this.bwrapCls);
+            var cp = this.bwrap ? this.bwrap : el;
+            this.tbar = cp.down('.'+this.tbarCls);
+            this.body = cp.down('.'+this.bodyCls);
+            this.bbar = cp.down('.'+this.bbarCls);
+            this.footer = cp.down('.'+this.footerCls);
+            this.fromMarkup = true;
+        }
+        if (this.preventBodyReset === true) {
+            el.addClass('x-panel-reset');
+        }
+        if(this.cls){
+            el.addClass(this.cls);
+        }
+
+        if(this.buttons){
+            this.elements += ',footer';
+        }
+
+        // This block allows for maximum flexibility and performance when using existing markup
+
+        // framing requires special markup
+        if(this.frame){
+            el.insertHtml('afterBegin', String.format(Ext.Element.boxMarkup, this.baseCls));
+
+            this.createElement('header', d.firstChild.firstChild.firstChild);
+            this.createElement('bwrap', d);
+
+            // append the mid and bottom frame to the bwrap
+            bw = this.bwrap.dom;
+            var ml = d.childNodes[1], bl = d.childNodes[2];
+            bw.appendChild(ml);
+            bw.appendChild(bl);
+
+            var mc = bw.firstChild.firstChild.firstChild;
+            this.createElement('tbar', mc);
+            this.createElement('body', mc);
+            this.createElement('bbar', mc);
+            this.createElement('footer', bw.lastChild.firstChild.firstChild);
+
+            if(!this.footer){
+                this.bwrap.dom.lastChild.className += ' x-panel-nofooter';
+            }
+            /*
+             * Store a reference to this element so:
+             * a) We aren't looking it up all the time
+             * b) The last element is reported incorrectly when using a loadmask
+             */
+            this.ft = Ext.get(this.bwrap.dom.lastChild);
+            this.mc = Ext.get(mc);
+        }else{
+            this.createElement('header', d);
+            this.createElement('bwrap', d);
+
+            // append the mid and bottom frame to the bwrap
+            bw = this.bwrap.dom;
+            this.createElement('tbar', bw);
+            this.createElement('body', bw);
+            this.createElement('bbar', bw);
+            this.createElement('footer', bw);
+
+            if(!this.header){
+                this.body.addClass(this.bodyCls + '-noheader');
+                if(this.tbar){
+                    this.tbar.addClass(this.tbarCls + '-noheader');
+                }
+            }
+        }
+
+        if(Ext.isDefined(this.padding)){
+            this.body.setStyle('padding', this.body.addUnits(this.padding));
+        }
+
+        if(this.border === false){
+            this.el.addClass(this.baseCls + '-noborder');
+            this.body.addClass(this.bodyCls + '-noborder');
+            if(this.header){
+                this.header.addClass(this.headerCls + '-noborder');
+            }
+            if(this.footer){
+                this.footer.addClass(this.footerCls + '-noborder');
+            }
+            if(this.tbar){
+                this.tbar.addClass(this.tbarCls + '-noborder');
+            }
+            if(this.bbar){
+                this.bbar.addClass(this.bbarCls + '-noborder');
+            }
+        }
+
+        if(this.bodyBorder === false){
+           this.body.addClass(this.bodyCls + '-noborder');
+        }
+
+        this.bwrap.enableDisplayMode('block');
+
+        if(this.header){
+            this.header.unselectable();
+
+            // for tools, we need to wrap any existing header markup
+            if(this.headerAsText){
+                this.header.dom.innerHTML =
+                    ''+this.header.dom.innerHTML+'';
+
+                if(this.iconCls){
+                    this.setIconClass(this.iconCls);
+                }
+            }
+        }
+
+        if(this.floating){
+            this.makeFloating(this.floating);
+        }
+
+        if(this.collapsible && this.titleCollapse && this.header){
+            this.mon(this.header, 'click', this.toggleCollapse, this);
+            this.header.setStyle('cursor', 'pointer');
+        }
+        if(ts){
+            this.addTool.apply(this, ts);
+        }
+
+        // Render Toolbars.
+        if(this.fbar){
+            this.footer.addClass('x-panel-btns');
+            this.fbar.ownerCt = this;
+            this.fbar.render(this.footer);
+            this.footer.createChild({cls:'x-clear'});
+        }
+        if(this.tbar && this.topToolbar){
+            this.topToolbar.ownerCt = this;
+            this.topToolbar.render(this.tbar);
+        }
+        if(this.bbar && this.bottomToolbar){
+            this.bottomToolbar.ownerCt = this;
+            this.bottomToolbar.render(this.bbar);
+        }
+    },
+
+    /**
+     * Sets the CSS class that provides the icon image for this panel.  This method will replace any existing
+     * icon class if one has already been set and fire the {@link #iconchange} event after completion.
+     * @param {String} cls The new CSS class name
+     */
+    setIconClass : function(cls){
+        var old = this.iconCls;
+        this.iconCls = cls;
+        if(this.rendered && this.header){
+            if(this.frame){
+                this.header.addClass('x-panel-icon');
+                this.header.replaceClass(old, this.iconCls);
+            }else{
+                var hd = this.header,
+                    img = hd.child('img.x-panel-inline-icon');
+                if(img){
+                    Ext.fly(img).replaceClass(old, this.iconCls);
+                }else{
+                    var hdspan = hd.child('span.' + this.headerTextCls);
+                    if (hdspan) {
+                        Ext.DomHelper.insertBefore(hdspan.dom, {
+                            tag:'img', src: Ext.BLANK_IMAGE_URL, cls:'x-panel-inline-icon '+this.iconCls
+                        });
+                    }
+                 }
+            }
+        }
+        this.fireEvent('iconchange', this, cls, old);
+    },
+
+    // private
+    makeFloating : function(cfg){
+        this.floating = true;
+        this.el = new Ext.Layer(Ext.apply({}, cfg, {
+            shadow: Ext.isDefined(this.shadow) ? this.shadow : 'sides',
+            shadowOffset: this.shadowOffset,
+            constrain:false,
+            shim: this.shim === false ? false : undefined
+        }), this.el);
+    },
+
+    /**
+     * Returns the {@link Ext.Toolbar toolbar} from the top ({@link #tbar}) section of the panel.
+     * @return {Ext.Toolbar} The toolbar
+     */
+    getTopToolbar : function(){
+        return this.topToolbar;
+    },
+
+    /**
+     * Returns the {@link Ext.Toolbar toolbar} from the bottom ({@link #bbar}) section of the panel.
+     * @return {Ext.Toolbar} The toolbar
+     */
+    getBottomToolbar : function(){
+        return this.bottomToolbar;
+    },
+    
+    /**
+     * Returns the {@link Ext.Toolbar toolbar} from the footer ({@link #fbar}) section of the panel.
+     * @return {Ext.Toolbar} The toolbar
+     */
+    getFooterToolbar : function() {
+        return this.fbar;
+    },
+
+    /**
+     * Adds a button to this panel.  Note that this method must be called prior to rendering.  The preferred
+     * approach is to add buttons via the {@link #buttons} config.
+     * @param {String/Object} config A valid {@link Ext.Button} config.  A string will become the text for a default
+     * button config, an object will be treated as a button config object.
+     * @param {Function} handler The function to be called on button {@link Ext.Button#click}
+     * @param {Object} scope The scope (this reference) in which the button handler function is executed. Defaults to the Button.
+     * @return {Ext.Button} The button that was added
+     */
+    addButton : function(config, handler, scope){
+        if(!this.fbar){
+            this.createFbar([]);
+        }
+        if(handler){
+            if(Ext.isString(config)){
+                config = {text: config};
+            }
+            config = Ext.apply({
+                handler: handler,
+                scope: scope
+            }, config);
+        }
+        return this.fbar.add(config);
+    },
+
+    // private
+    addTool : function(){
+        if(!this.rendered){
+            if(!this.tools){
+                this.tools = [];
+            }
+            Ext.each(arguments, function(arg){
+                this.tools.push(arg);
+            }, this);
+            return;
+        }
+         // nowhere to render tools!
+        if(!this[this.toolTarget]){
+            return;
+        }
+        if(!this.toolTemplate){
+            // initialize the global tool template on first use
+            var tt = new Ext.Template(
+                 ' '
+            );
+            tt.disableFormats = true;
+            tt.compile();
+            Ext.Panel.prototype.toolTemplate = tt;
+        }
+        for(var i = 0, a = arguments, len = a.length; i < len; i++) {
+            var tc = a[i];
+            if(!this.tools[tc.id]){
+                var overCls = 'x-tool-'+tc.id+'-over';
+                var t = this.toolTemplate.insertFirst(this[this.toolTarget], tc, true);
+                this.tools[tc.id] = t;
+                t.enableDisplayMode('block');
+                this.mon(t, 'click',  this.createToolHandler(t, tc, overCls, this));
+                if(tc.on){
+                    this.mon(t, tc.on);
+                }
+                if(tc.hidden){
+                    t.hide();
+                }
+                if(tc.qtip){
+                    if(Ext.isObject(tc.qtip)){
+                        Ext.QuickTips.register(Ext.apply({
+                              target: t.id
+                        }, tc.qtip));
+                    } else {
+                        t.dom.qtip = tc.qtip;
+                    }
+                }
+                t.addClassOnOver(overCls);
+            }
+        }
+    },
+
+    onLayout : function(shallow, force){
+        Ext.Panel.superclass.onLayout.apply(this, arguments);
+        if(this.hasLayout && this.toolbars.length > 0){
+            Ext.each(this.toolbars, function(tb){
+                tb.doLayout(undefined, force);
+            });
+            this.syncHeight();
+        }
+    },
+
+    syncHeight : function(){
+        var h = this.toolbarHeight,
+                bd = this.body,
+                lsh = this.lastSize.height,
+                sz;
+
+        if(this.autoHeight || !Ext.isDefined(lsh) || lsh == 'auto'){
+            return;
+        }
+
+
+        if(h != this.getToolbarHeight()){
+            h = Math.max(0, lsh - this.getFrameHeight());
+            bd.setHeight(h);
+            sz = bd.getSize();
+            this.toolbarHeight = this.getToolbarHeight();
+            this.onBodyResize(sz.width, sz.height);
+        }
+    },
+
+    // private
+    onShow : function(){
+        if(this.floating){
+            return this.el.show();
+        }
+        Ext.Panel.superclass.onShow.call(this);
+    },
+
+    // private
+    onHide : function(){
+        if(this.floating){
+            return this.el.hide();
+        }
+        Ext.Panel.superclass.onHide.call(this);
+    },
+
+    // private
+    createToolHandler : function(t, tc, overCls, panel){
+        return function(e){
+            t.removeClass(overCls);
+            if(tc.stopEvent !== false){
+                e.stopEvent();
+            }
+            if(tc.handler){
+                tc.handler.call(tc.scope || t, e, t, panel, tc);
+            }
+        };
+    },
+
+    // private
+    afterRender : function(){
+        if(this.floating && !this.hidden){
+            this.el.show();
+        }
+        if(this.title){
+            this.setTitle(this.title);
+        }
+        Ext.Panel.superclass.afterRender.call(this); // do sizing calcs last
+        if (this.collapsed) {
+            this.collapsed = false;
+            this.collapse(false);
+        }
+        this.initEvents();
+    },
+
+    // private
+    getKeyMap : function(){
+        if(!this.keyMap){
+            this.keyMap = new Ext.KeyMap(this.el, this.keys);
+        }
+        return this.keyMap;
+    },
+
+    // private
+    initEvents : function(){
+        if(this.keys){
+            this.getKeyMap();
+        }
+        if(this.draggable){
+            this.initDraggable();
+        }
+        if(this.toolbars.length > 0){
+            Ext.each(this.toolbars, function(tb){
+                tb.doLayout();
+                tb.on({
+                    scope: this,
+                    afterlayout: this.syncHeight,
+                    remove: this.syncHeight
+                });
+            }, this);
+            this.syncHeight();
+        }
+
+    },
+
+    // private
+    initDraggable : function(){
+        /**
+         * If this Panel is configured {@link #draggable}, this property will contain
+         * an instance of {@link Ext.dd.DragSource} which handles dragging the Panel.
+         * The developer must provide implementations of the abstract methods of {@link Ext.dd.DragSource}
+         * in order to supply behaviour for each stage of the drag/drop process. See {@link #draggable}.
+         * @type Ext.dd.DragSource.
+         * @property dd
+         */
+        this.dd = new Ext.Panel.DD(this, Ext.isBoolean(this.draggable) ? null : this.draggable);
+    },
+
+    // private
+    beforeEffect : function(anim){
+        if(this.floating){
+            this.el.beforeAction();
+        }
+        if(anim !== false){
+            this.el.addClass('x-panel-animated');
+        }
+    },
+
+    // private
+    afterEffect : function(anim){
+        this.syncShadow();
+        this.el.removeClass('x-panel-animated');
+    },
+
+    // private - wraps up an animation param with internal callbacks
+    createEffect : function(a, cb, scope){
+        var o = {
+            scope:scope,
+            block:true
+        };
+        if(a === true){
+            o.callback = cb;
+            return o;
+        }else if(!a.callback){
+            o.callback = cb;
+        }else { // wrap it up
+            o.callback = function(){
+                cb.call(scope);
+                Ext.callback(a.callback, a.scope);
+            };
+        }
+        return Ext.applyIf(o, a);
+    },
+
+    /**
+     * Collapses the panel body so that it becomes hidden.  Fires the {@link #beforecollapse} event which will
+     * cancel the collapse action if it returns false.
+     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
+     * {@link #animCollapse} panel config)
+     * @return {Ext.Panel} this
+     */
+    collapse : function(animate){
+        if(this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforecollapse', this, animate) === false){
+            return;
+        }
+        var doAnim = animate === true || (animate !== false && this.animCollapse);
+        this.beforeEffect(doAnim);
+        this.onCollapse(doAnim, animate);
+        return this;
+    },
+
+    // private
+    onCollapse : function(doAnim, animArg){
+        if(doAnim){
+            this[this.collapseEl].slideOut(this.slideAnchor,
+                    Ext.apply(this.createEffect(animArg||true, this.afterCollapse, this),
+                        this.collapseDefaults));
+        }else{
+            this[this.collapseEl].hide(this.hideMode);
+            this.afterCollapse(false);
+        }
+    },
+
+    // private
+    afterCollapse : function(anim){
+        this.collapsed = true;
+        this.el.addClass(this.collapsedCls);
+        if(anim !== false){
+            this[this.collapseEl].hide(this.hideMode);
+        }
+        this.afterEffect(anim);
+
+        // Reset lastSize of all sub-components so they KNOW they are in a collapsed container
+        this.cascade(function(c) {
+            if (c.lastSize) {
+                c.lastSize = { width: 0, height: 0 };
+            }
+        });
+        this.fireEvent('collapse', this);
+    },
+
+    /**
+     * Expands the panel body so that it becomes visible.  Fires the {@link #beforeexpand} event which will
+     * cancel the expand action if it returns false.
+     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
+     * {@link #animCollapse} panel config)
+     * @return {Ext.Panel} this
+     */
+    expand : function(animate){
+        if(!this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforeexpand', this, animate) === false){
+            return;
+        }
+        var doAnim = animate === true || (animate !== false && this.animCollapse);
+        this.el.removeClass(this.collapsedCls);
+        this.beforeEffect(doAnim);
+        this.onExpand(doAnim, animate);
+        return this;
+    },
+
+    // private
+    onExpand : function(doAnim, animArg){
+        if(doAnim){
+            this[this.collapseEl].slideIn(this.slideAnchor,
+                    Ext.apply(this.createEffect(animArg||true, this.afterExpand, this),
+                        this.expandDefaults));
+        }else{
+            this[this.collapseEl].show(this.hideMode);
+            this.afterExpand(false);
+        }
+    },
+
+    // private
+    afterExpand : function(anim){
+        this.collapsed = false;
+        if(anim !== false){
+            this[this.collapseEl].show(this.hideMode);
+        }
+        this.afterEffect(anim);
+        if (this.deferLayout) {
+            delete this.deferLayout;
+            this.doLayout(true);
+        }
+        this.fireEvent('expand', this);
+    },
+
+    /**
+     * Shortcut for performing an {@link #expand} or {@link #collapse} based on the current state of the panel.
+     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
+     * {@link #animCollapse} panel config)
+     * @return {Ext.Panel} this
+     */
+    toggleCollapse : function(animate){
+        this[this.collapsed ? 'expand' : 'collapse'](animate);
+        return this;
+    },
+
+    // private
+    onDisable : function(){
+        if(this.rendered && this.maskDisabled){
+            this.el.mask();
+        }
+        Ext.Panel.superclass.onDisable.call(this);
+    },
+
+    // private
+    onEnable : function(){
+        if(this.rendered && this.maskDisabled){
+            this.el.unmask();
+        }
+        Ext.Panel.superclass.onEnable.call(this);
+    },
+
+    // private
+    onResize : function(adjWidth, adjHeight, rawWidth, rawHeight){
+        var w = adjWidth,
+            h = adjHeight;
+
+        if(Ext.isDefined(w) || Ext.isDefined(h)){
+            if(!this.collapsed){
+                // First, set the the Panel's body width.
+                // If we have auto-widthed it, get the resulting full offset width so we can size the Toolbars to match
+                // The Toolbars must not buffer this resize operation because we need to know their heights.
+
+                if(Ext.isNumber(w)){
+                    this.body.setWidth(w = this.adjustBodyWidth(w - this.getFrameWidth()));
+                } else if (w == 'auto') {
+                    w = this.body.setWidth('auto').dom.offsetWidth;
+                } else {
+                    w = this.body.dom.offsetWidth;
+                }
+
+                if(this.tbar){
+                    this.tbar.setWidth(w);
+                    if(this.topToolbar){
+                        this.topToolbar.setSize(w);
+                    }
+                }
+                if(this.bbar){
+                    this.bbar.setWidth(w);
+                    if(this.bottomToolbar){
+                        this.bottomToolbar.setSize(w);
+                        // The bbar does not move on resize without this.
+                        if (Ext.isIE) {
+                            this.bbar.setStyle('position', 'static');
+                            this.bbar.setStyle('position', '');
+                        }
+                    }
+                }
+                if(this.footer){
+                    this.footer.setWidth(w);
+                    if(this.fbar){
+                        this.fbar.setSize(Ext.isIE ? (w - this.footer.getFrameWidth('lr')) : 'auto');
+                    }
+                }
+
+                // At this point, the Toolbars must be layed out for getFrameHeight to find a result.
+                if(Ext.isNumber(h)){
+                    h = Math.max(0, h - this.getFrameHeight());
+                    //h = Math.max(0, h - (this.getHeight() - this.body.getHeight()));
+                    this.body.setHeight(h);
+                }else if(h == 'auto'){
+                    this.body.setHeight(h);
+                }
+
+                if(this.disabled && this.el._mask){
+                    this.el._mask.setSize(this.el.dom.clientWidth, this.el.getHeight());
+                }
+            }else{
+                // Adds an event to set the correct height afterExpand.  This accounts for the deferHeight flag in panel
+                this.queuedBodySize = {width: w, height: h};
+                if(!this.queuedExpand && this.allowQueuedExpand !== false){
+                    this.queuedExpand = true;
+                    this.on('expand', function(){
+                        delete this.queuedExpand;
+                        this.onResize(this.queuedBodySize.width, this.queuedBodySize.height);
+                    }, this, {single:true});
+                }
+            }
+            this.onBodyResize(w, h);
+        }
+        this.syncShadow();
+        Ext.Panel.superclass.onResize.call(this, adjWidth, adjHeight, rawWidth, rawHeight);
+
+    },
+
+    // private
+    onBodyResize: function(w, h){
+        this.fireEvent('bodyresize', this, w, h);
+    },
+
+    // private
+    getToolbarHeight: function(){
+        var h = 0;
+        if(this.rendered){
+            Ext.each(this.toolbars, function(tb){
+                h += tb.getHeight();
+            }, this);
+        }
+        return h;
+    },
+
+    // deprecate
+    adjustBodyHeight : function(h){
+        return h;
+    },
+
+    // private
+    adjustBodyWidth : function(w){
+        return w;
+    },
+
+    // private
+    onPosition : function(){
+        this.syncShadow();
+    },
+
+    /**
+     * Returns the width in pixels of the framing elements of this panel (not including the body width).  To
+     * retrieve the body width see {@link #getInnerWidth}.
+     * @return {Number} The frame width
+     */
+    getFrameWidth : function(){
+        var w = this.el.getFrameWidth('lr') + this.bwrap.getFrameWidth('lr');
+
+        if(this.frame){
+            var l = this.bwrap.dom.firstChild;
+            w += (Ext.fly(l).getFrameWidth('l') + Ext.fly(l.firstChild).getFrameWidth('r'));
+            w += this.mc.getFrameWidth('lr');
+        }
+        return w;
+    },
+
+    /**
+     * Returns the height in pixels of the framing elements of this panel (including any top and bottom bars and
+     * header and footer elements, but not including the body height).  To retrieve the body height see {@link #getInnerHeight}.
+     * @return {Number} The frame height
+     */
+    getFrameHeight : function() {
+        var h = Math.max(0, this.getHeight() - this.body.getHeight());
+
+        if (isNaN(h)) {
+            h = 0;
+        }
+        return h;
+
+        /* Deprecate
+            var h  = this.el.getFrameWidth('tb') + this.bwrap.getFrameWidth('tb');
+            h += (this.tbar ? this.tbar.getHeight() : 0) +
+                 (this.bbar ? this.bbar.getHeight() : 0);
+
+            if(this.frame){
+                h += this.el.dom.firstChild.offsetHeight + this.ft.dom.offsetHeight + this.mc.getFrameWidth('tb');
+            }else{
+                h += (this.header ? this.header.getHeight() : 0) +
+                    (this.footer ? this.footer.getHeight() : 0);
+            }
+            return h;
+        */
+    },
+
+    /**
+     * Returns the width in pixels of the body element (not including the width of any framing elements).
+     * For the frame width see {@link #getFrameWidth}.
+     * @return {Number} The body width
+     */
+    getInnerWidth : function(){
+        return this.getSize().width - this.getFrameWidth();
+    },
+
+    /**
+     * Returns the height in pixels of the body element (not including the height of any framing elements).
+     * For the frame height see {@link #getFrameHeight}.
+     * @return {Number} The body height
+     */
+    getInnerHeight : function(){
+        return this.body.getHeight();
+        /* Deprecate
+            return this.getSize().height - this.getFrameHeight();
+        */
+    },
+
+    // private
+    syncShadow : function(){
+        if(this.floating){
+            this.el.sync(true);
+        }
+    },
+
+    // private
+    getLayoutTarget : function(){
+        return this.body;
+    },
+
+    // private
+    getContentTarget : function(){
+        return this.body;
+    },
+
+    /**
+     * Sets the title text for the panel and optionally the {@link #iconCls icon class}.
+     * In order to be able to set the title, a header element must have been created
+     * for the Panel. This is triggered either by configuring the Panel with a non-blank {@link #title},
+     * or configuring it with {@link #header}: true.
+     * @param {String} title The title text to set
+     * @param {String} iconCls (optional) {@link #iconCls iconCls} A user-defined CSS class that provides the icon image for this panel
+     */
+    setTitle : function(title, iconCls){
+        this.title = title;
+        if(this.header && this.headerAsText){
+            this.header.child('span').update(title);
+        }
+        if(iconCls){
+            this.setIconClass(iconCls);
+        }
+        this.fireEvent('titlechange', this, title);
+        return this;
+    },
+
+    /**
+     * Get the {@link Ext.Updater} for this panel. Enables you to perform Ajax updates of this panel's body.
+     * @return {Ext.Updater} The Updater
+     */
+    getUpdater : function(){
+        return this.body.getUpdater();
+    },
+
+     /**
+     * Loads this content panel immediately with content returned from an XHR call.
+     * @param {Object/String/Function} config A config object containing any of the following options:
+
+panel.load({
+    url: 'your-url.php',
+    params: {param1: 'foo', param2: 'bar'}, // or a URL encoded string
+    callback: yourFunction,
+    scope: yourObject, // optional scope for the callback
+    discardUrl: false,
+    nocache: false,
+    text: 'Loading...',
+    timeout: 30,
+    scripts: false
+});
+
+     * The only required property is url. The optional properties nocache, text and scripts
+     * are shorthand for disableCaching, indicatorText and loadScripts and are used to set their
+     * associated property on this panel Updater instance.
+     * @return {Ext.Panel} this
+     */
+    load : function(){
+        var um = this.body.getUpdater();
+        um.update.apply(um, arguments);
+        return this;
+    },
+
+    // private
+    beforeDestroy : function(){
+        Ext.Panel.superclass.beforeDestroy.call(this);
+        if(this.header){
+            this.header.removeAllListeners();
+        }
+        if(this.tools){
+            for(var k in this.tools){
+                Ext.destroy(this.tools[k]);
+            }
+        }
+        if(this.toolbars.length > 0){
+            Ext.each(this.toolbars, function(tb){
+                tb.un('afterlayout', this.syncHeight, this);
+                tb.un('remove', this.syncHeight, this);
+            }, this);
+        }
+        if(Ext.isArray(this.buttons)){
+            while(this.buttons.length) {
+                Ext.destroy(this.buttons[0]);
+            }
+        }
+        if(this.rendered){
+            Ext.destroy(
+                this.ft,
+                this.header,
+                this.footer,
+                this.toolbars,
+                this.tbar,
+                this.bbar,
+                this.body,
+                this.mc,
+                this.bwrap
+            );
+            if (this.fbar) {
+                Ext.destroy(
+                    this.fbar,
+                    this.fbar.el
+                );
+            }
+        }else{
+            Ext.destroy(
+                this.topToolbar,
+                this.bottomToolbar
+            );
+        }
+    },
+
+    // private
+    createClasses : function(){
+        this.headerCls = this.baseCls + '-header';
+        this.headerTextCls = this.baseCls + '-header-text';
+        this.bwrapCls = this.baseCls + '-bwrap';
+        this.tbarCls = this.baseCls + '-tbar';
+        this.bodyCls = this.baseCls + '-body';
+        this.bbarCls = this.baseCls + '-bbar';
+        this.footerCls = this.baseCls + '-footer';
+    },
+
+    // private
+    createGhost : function(cls, useShim, appendTo){
+        var el = document.createElement('div');
+        el.className = 'x-panel-ghost ' + (cls ? cls : '');
+        if(this.header){
+            el.appendChild(this.el.dom.firstChild.cloneNode(true));
+        }
+        Ext.fly(el.appendChild(document.createElement('ul'))).setHeight(this.bwrap.getHeight());
+        el.style.width = this.el.dom.offsetWidth + 'px';;
+        if(!appendTo){
+            this.container.dom.appendChild(el);
+        }else{
+            Ext.getDom(appendTo).appendChild(el);
+        }
+        if(useShim !== false && this.el.useShim !== false){
+            var layer = new Ext.Layer({shadow:false, useDisplay:true, constrain:false}, el);
+            layer.show();
+            return layer;
+        }else{
+            return new Ext.Element(el);
+        }
+    },
+
+    // private
+    doAutoLoad : function(){
+        var u = this.body.getUpdater();
+        if(this.renderer){
+            u.setRenderer(this.renderer);
+        }
+        u.update(Ext.isObject(this.autoLoad) ? this.autoLoad : {url: this.autoLoad});
+    },
+
+    /**
+     * Retrieve a tool by id.
+     * @param {String} id
+     * @return {Object} tool
+     */
+    getTool : function(id) {
+        return this.tools[id];
+    }
+
+/**
+ * @cfg {String} autoEl @hide
+ */
+});
+Ext.reg('panel', Ext.Panel);
+/**
+ * @class Ext.Editor
+ * @extends Ext.Component
+ * A base editor field that handles displaying/hiding on demand and has some built-in sizing and event handling logic.
+ * @constructor
+ * Create a new Editor
+ * @param {Object} config The config object
+ * @xtype editor
+ */
+Ext.Editor = function(field, config){
+    if(field.field){
+        this.field = Ext.create(field.field, 'textfield');
+        config = Ext.apply({}, field); // copy so we don't disturb original config
+        delete config.field;
+    }else{
+        this.field = field;
+    }
+    Ext.Editor.superclass.constructor.call(this, config);
+};
+
+Ext.extend(Ext.Editor, Ext.Component, {
+    /**
+    * @cfg {Ext.form.Field} field
+    * The Field object (or descendant) or config object for field
+    */
+    /**
+     * @cfg {Boolean} allowBlur
+     * True to {@link #completeEdit complete the editing process} if in edit mode when the
+     * field is blurred. Defaults to true.
+     */
+    allowBlur: true,
+    /**
+     * @cfg {Boolean/String} autoSize
+     * True for the editor to automatically adopt the size of the underlying field, "width" to adopt the width only,
+     * or "height" to adopt the height only, "none" to always use the field dimensions. (defaults to false)
+     */
+    /**
+     * @cfg {Boolean} revertInvalid
+     * True to automatically revert the field value and cancel the edit when the user completes an edit and the field
+     * validation fails (defaults to true)
+     */
+    /**
+     * @cfg {Boolean} ignoreNoChange
+     * True to skip the edit completion process (no save, no events fired) if the user completes an edit and
+     * the value has not changed (defaults to false).  Applies only to string values - edits for other data types
+     * will never be ignored.
+     */
+    /**
+     * @cfg {Boolean} hideEl
+     * False to keep the bound element visible while the editor is displayed (defaults to true)
+     */
+    /**
+     * @cfg {Mixed} value
+     * The data value of the underlying field (defaults to "")
+     */
+    value : "",
+    /**
+     * @cfg {String} alignment
+     * The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "c-c?").
+     */
+    alignment: "c-c?",
+    /**
+     * @cfg {Array} offsets
+     * The offsets to use when aligning (see {@link Ext.Element#alignTo} for more details. Defaults to [0, 0].
+     */
+    offsets: [0, 0],
+    /**
+     * @cfg {Boolean/String} shadow "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop"
+     * for bottom-right shadow (defaults to "frame")
+     */
+    shadow : "frame",
+    /**
+     * @cfg {Boolean} constrain True to constrain the editor to the viewport
+     */
+    constrain : false,
+    /**
+     * @cfg {Boolean} swallowKeys Handle the keydown/keypress events so they don't propagate (defaults to true)
+     */
+    swallowKeys : true,
+    /**
+     * @cfg {Boolean} completeOnEnter True to complete the edit when the enter key is pressed. Defaults to true.
+     */
+    completeOnEnter : true,
+    /**
+     * @cfg {Boolean} cancelOnEsc True to cancel the edit when the escape key is pressed. Defaults to true.
+     */
+    cancelOnEsc : true,
+    /**
+     * @cfg {Boolean} updateEl True to update the innerHTML of the bound element when the update completes (defaults to false)
+     */
+    updateEl : false,
+
+    initComponent : function(){
+        Ext.Editor.superclass.initComponent.call(this);
+        this.addEvents(
+            /**
+             * @event beforestartedit
+             * Fires when editing is initiated, but before the value changes.  Editing can be canceled by returning
+             * false from the handler of this event.
+             * @param {Editor} this
+             * @param {Ext.Element} boundEl The underlying element bound to this editor
+             * @param {Mixed} value The field value being set
+             */
+            "beforestartedit",
+            /**
+             * @event startedit
+             * Fires when this editor is displayed
+             * @param {Ext.Element} boundEl The underlying element bound to this editor
+             * @param {Mixed} value The starting field value
+             */
+            "startedit",
+            /**
+             * @event beforecomplete
+             * Fires after a change has been made to the field, but before the change is reflected in the underlying
+             * field.  Saving the change to the field can be canceled by returning false from the handler of this event.
+             * Note that if the value has not changed and ignoreNoChange = true, the editing will still end but this
+             * event will not fire since no edit actually occurred.
+             * @param {Editor} this
+             * @param {Mixed} value The current field value
+             * @param {Mixed} startValue The original field value
+             */
+            "beforecomplete",
+            /**
+             * @event complete
+             * Fires after editing is complete and any changed value has been written to the underlying field.
+             * @param {Editor} this
+             * @param {Mixed} value The current field value
+             * @param {Mixed} startValue The original field value
+             */
+            "complete",
+            /**
+             * @event canceledit
+             * Fires after editing has been canceled and the editor's value has been reset.
+             * @param {Editor} this
+             * @param {Mixed} value The user-entered field value that was discarded
+             * @param {Mixed} startValue The original field value that was set back into the editor after cancel
+             */
+            "canceledit",
+            /**
+             * @event specialkey
+             * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed.  You can check
+             * {@link Ext.EventObject#getKey} to determine which key was pressed.
+             * @param {Ext.form.Field} this
+             * @param {Ext.EventObject} e The event object
+             */
+            "specialkey"
+        );
+    },
+
+    // private
+    onRender : function(ct, position){
+        this.el = new Ext.Layer({
+            shadow: this.shadow,
+            cls: "x-editor",
+            parentEl : ct,
+            shim : this.shim,
+            shadowOffset: this.shadowOffset || 4,
+            id: this.id,
+            constrain: this.constrain
+        });
+        if(this.zIndex){
+            this.el.setZIndex(this.zIndex);
+        }
+        this.el.setStyle("overflow", Ext.isGecko ? "auto" : "hidden");
+        if(this.field.msgTarget != 'title'){
+            this.field.msgTarget = 'qtip';
+        }
+        this.field.inEditor = true;
+        this.mon(this.field, {
+            scope: this,
+            blur: this.onBlur,
+            specialkey: this.onSpecialKey
+        });
+        if(this.field.grow){
+            this.mon(this.field, "autosize", this.el.sync,  this.el, {delay:1});
+        }
+        this.field.render(this.el).show();
+        this.field.getEl().dom.name = '';
+        if(this.swallowKeys){
+            this.field.el.swallowEvent([
+                'keypress', // *** Opera
+                'keydown'   // *** all other browsers
+            ]);
+        }
+    },
+
+    // private
+    onSpecialKey : function(field, e){
+        var key = e.getKey(),
+            complete = this.completeOnEnter && key == e.ENTER,
+            cancel = this.cancelOnEsc && key == e.ESC;
+        if(complete || cancel){
+            e.stopEvent();
+            if(complete){
+                this.completeEdit();
+            }else{
+                this.cancelEdit();
+            }
+            if(field.triggerBlur){
+                field.triggerBlur();
+            }
+        }
+        this.fireEvent('specialkey', field, e);
+    },
+
+    /**
+     * Starts the editing process and shows the editor.
+     * @param {Mixed} el The element to edit
+     * @param {String} value (optional) A value to initialize the editor with. If a value is not provided, it defaults
+      * to the innerHTML of el.
+     */
+    startEdit : function(el, value){
+        if(this.editing){
+            this.completeEdit();
+        }
+        this.boundEl = Ext.get(el);
+        var v = value !== undefined ? value : this.boundEl.dom.innerHTML;
+        if(!this.rendered){
+            this.render(this.parentEl || document.body);
+        }
+        if(this.fireEvent("beforestartedit", this, this.boundEl, v) !== false){
+            this.startValue = v;
+            this.field.reset();
+            this.field.setValue(v);
+            this.realign(true);
+            this.editing = true;
+            this.show();
+        }
+    },
+
+    // private
+    doAutoSize : function(){
+        if(this.autoSize){
+            var sz = this.boundEl.getSize(),
+                fs = this.field.getSize();
+
+            switch(this.autoSize){
+                case "width":
+                    this.setSize(sz.width, fs.height);
+                    break;
+                case "height":
+                    this.setSize(fs.width, sz.height);
+                    break;
+                case "none":
+                    this.setSize(fs.width, fs.height);
+                    break;
+                default:
+                    this.setSize(sz.width, sz.height);
+            }
+        }
+    },
+
+    /**
+     * Sets the height and width of this editor.
+     * @param {Number} width The new width
+     * @param {Number} height The new height
+     */
+    setSize : function(w, h){
+        delete this.field.lastSize;
+        this.field.setSize(w, h);
+        if(this.el){
+            if(Ext.isGecko2 || Ext.isOpera){
+                // prevent layer scrollbars
+                this.el.setSize(w, h);
+            }
+            this.el.sync();
+        }
+    },
+
+    /**
+     * Realigns the editor to the bound field based on the current alignment config value.
+     * @param {Boolean} autoSize (optional) True to size the field to the dimensions of the bound element.
+     */
+    realign : function(autoSize){
+        if(autoSize === true){
+            this.doAutoSize();
+        }
+        this.el.alignTo(this.boundEl, this.alignment, this.offsets);
+    },
+
+    /**
+     * Ends the editing process, persists the changed value to the underlying field, and hides the editor.
+     * @param {Boolean} remainVisible Override the default behavior and keep the editor visible after edit (defaults to false)
+     */
+    completeEdit : function(remainVisible){
+        if(!this.editing){
+            return;
+        }
+        // Assert combo values first
+        if (this.field.assertValue) {
+            this.field.assertValue();
+        }
+        var v = this.getValue();
+        if(!this.field.isValid()){
+            if(this.revertInvalid !== false){
+                this.cancelEdit(remainVisible);
+            }
+            return;
+        }
+        if(String(v) === String(this.startValue) && this.ignoreNoChange){
+            this.hideEdit(remainVisible);
+            return;
+        }
+        if(this.fireEvent("beforecomplete", this, v, this.startValue) !== false){
+            v = this.getValue();
+            if(this.updateEl && this.boundEl){
+                this.boundEl.update(v);
+            }
+            this.hideEdit(remainVisible);
+            this.fireEvent("complete", this, v, this.startValue);
+        }
+    },
+
+    // private
+    onShow : function(){
+        this.el.show();
+        if(this.hideEl !== false){
+            this.boundEl.hide();
+        }
+        this.field.show().focus(false, true);
+        this.fireEvent("startedit", this.boundEl, this.startValue);
+    },
+
+    /**
+     * Cancels the editing process and hides the editor without persisting any changes.  The field value will be
+     * reverted to the original starting value.
+     * @param {Boolean} remainVisible Override the default behavior and keep the editor visible after
+     * cancel (defaults to false)
+     */
+    cancelEdit : function(remainVisible){
+        if(this.editing){
+            var v = this.getValue();
+            this.setValue(this.startValue);
+            this.hideEdit(remainVisible);
+            this.fireEvent("canceledit", this, v, this.startValue);
+        }
+    },
+
+    // private
+    hideEdit: function(remainVisible){
+        if(remainVisible !== true){
+            this.editing = false;
+            this.hide();
+        }
+    },
+
+    // private
+    onBlur : function(){
+        // selectSameEditor flag allows the same editor to be started without onBlur firing on itself
+        if(this.allowBlur === true && this.editing && this.selectSameEditor !== true){
+            this.completeEdit();
+        }
+    },
+
+    // private
+    onHide : function(){
+        if(this.editing){
+            this.completeEdit();
+            return;
+        }
+        this.field.blur();
+        if(this.field.collapse){
+            this.field.collapse();
+        }
+        this.el.hide();
+        if(this.hideEl !== false){
+            this.boundEl.show();
+        }
+    },
+
+    /**
+     * Sets the data value of the editor
+     * @param {Mixed} value Any valid value supported by the underlying field
+     */
+    setValue : function(v){
+        this.field.setValue(v);
+    },
+
+    /**
+     * Gets the data value of the editor
+     * @return {Mixed} The data value
+     */
+    getValue : function(){
+        return this.field.getValue();
+    },
+
+    beforeDestroy : function(){
+        Ext.destroyMembers(this, 'field');
+
+        delete this.parentEl;
+        delete this.boundEl;
+    }
+});
+Ext.reg('editor', Ext.Editor);
+/**
+ * @class Ext.ColorPalette
+ * @extends Ext.Component
+ * Simple color palette class for choosing colors.  The palette can be rendered to any container.

+ * Here's an example of typical usage:
+ * 
+var cp = new Ext.ColorPalette({value:'993300'});  // initial selected color
+cp.render('my-div');
+
+cp.on('select', function(palette, selColor){
+    // do something with selColor
+});
+
+ * @constructor
+ * Create a new ColorPalette
+ * @param {Object} config The config object
+ * @xtype colorpalette
+ */
+Ext.ColorPalette = Ext.extend(Ext.Component, {
+	/**
+	 * @cfg {String} tpl An existing XTemplate instance to be used in place of the default template for rendering the component.
+	 */
+    /**
+     * @cfg {String} itemCls
+     * The CSS class to apply to the containing element (defaults to 'x-color-palette')
+     */
+    itemCls : 'x-color-palette',
+    /**
+     * @cfg {String} value
+     * The initial color to highlight (should be a valid 6-digit color hex code without the # symbol).  Note that
+     * the hex codes are case-sensitive.
+     */
+    value : null,
+    /**
+     * @cfg {String} clickEvent
+     * The DOM event that will cause a color to be selected. This can be any valid event name (dblclick, contextmenu). 
+     * Defaults to 'click'.
+     */
+    clickEvent :'click',
+    // private
+    ctype : 'Ext.ColorPalette',
+
+    /**
+     * @cfg {Boolean} allowReselect If set to true then reselecting a color that is already selected fires the {@link #select} event
+     */
+    allowReselect : false,
+
+    /**
+     * An array of 6-digit color hex code strings (without the # symbol).  This array can contain any number
+     * of colors, and each hex code should be unique.  The width of the palette is controlled via CSS by adjusting
+     * the width property of the 'x-color-palette' class (or assigning a custom class), so you can balance the number
+     * of colors with the width setting until the box is symmetrical.
+     * You can override individual colors if needed:
+     * 
+var cp = new Ext.ColorPalette();
+cp.colors[0] = 'FF0000';  // change the first box to red
+
+
+Or you can provide a custom array of your own for complete control:
+
+var cp = new Ext.ColorPalette();
+cp.colors = ['000000', '993300', '333300'];
+
+     * @type Array
+     */
+    colors : [
+        '000000', '993300', '333300', '003300', '003366', '000080', '333399', '333333',
+        '800000', 'FF6600', '808000', '008000', '008080', '0000FF', '666699', '808080',
+        'FF0000', 'FF9900', '99CC00', '339966', '33CCCC', '3366FF', '800080', '969696',
+        'FF00FF', 'FFCC00', 'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0',
+        'FF99CC', 'FFCC99', 'FFFF99', 'CCFFCC', 'CCFFFF', '99CCFF', 'CC99FF', 'FFFFFF'
+    ],
+
+    /**
+     * @cfg {Function} handler
+     * Optional. A function that will handle the select event of this palette.
+     * The handler is passed the following parameters:
+     * palette : ColorPaletteThe {@link #palette Ext.ColorPalette}.
+     * color : StringThe 6-digit color hex code (without the # symbol).
+     * 
+     */
+    /**
+     * @cfg {Object} scope
+     * The scope (this reference) in which the {@link #handler}
+     * function will be called.  Defaults to this ColorPalette instance.
+     */
+    
+    // private
+    initComponent : function(){
+        Ext.ColorPalette.superclass.initComponent.call(this);
+        this.addEvents(
+            /**
+             * @event select
+             * Fires when a color is selected
+             * @param {ColorPalette} this
+             * @param {String} color The 6-digit color hex code (without the # symbol)
+             */
+            'select'
+        );
+
+        if(this.handler){
+            this.on('select', this.handler, this.scope, true);
+        }    
+    },
+
+    // private
+    onRender : function(container, position){
+        this.autoEl = {
+            tag: 'div',
+            cls: this.itemCls
+        };
+        Ext.ColorPalette.superclass.onRender.call(this, container, position);
+        var t = this.tpl || new Ext.XTemplate(
+            ' '
+        );
+        t.overwrite(this.el, this.colors);
+        this.mon(this.el, this.clickEvent, this.handleClick, this, {delegate: 'a'});
+        if(this.clickEvent != 'click'){
+        	this.mon(this.el, 'click', Ext.emptyFn, this, {delegate: 'a', preventDefault: true});
+        }
+    },
+
+    // private
+    afterRender : function(){
+        Ext.ColorPalette.superclass.afterRender.call(this);
+        if(this.value){
+            var s = this.value;
+            this.value = null;
+            this.select(s);
+        }
+    },
+
+    // private
+    handleClick : function(e, t){
+        e.preventDefault();
+        if(!this.disabled){
+            var c = t.className.match(/(?:^|\s)color-(.{6})(?:\s|$)/)[1];
+            this.select(c.toUpperCase());
+        }
+    },
+
+    /**
+     * Selects the specified color in the palette (fires the {@link #select} event)
+     * @param {String} color A valid 6-digit color hex code (# will be stripped if included)
+     */
+    select : function(color){
+        color = color.replace('#', '');
+        if(color != this.value || this.allowReselect){
+            var el = this.el;
+            if(this.value){
+                el.child('a.color-'+this.value).removeClass('x-color-palette-sel');
+            }
+            el.child('a.color-'+color).addClass('x-color-palette-sel');
+            this.value = color;
+            this.fireEvent('select', this, color);
+        }
+    }
+
+    /**
+     * @cfg {String} autoEl @hide
+     */
+});
+Ext.reg('colorpalette', Ext.ColorPalette);
+/**
+ * @class Ext.DatePicker
+ * @extends Ext.Component
+ * A popup date picker. This class is used by the {@link Ext.form.DateField DateField} class
+ * to allow browsing and selection of valid dates.
+ * All the string values documented below may be overridden by including an Ext locale file in
+ * your page.
+ * @constructor
+ * Create a new DatePicker
+ * @param {Object} config The config object
+ * @xtype datepicker
+ */
+Ext.DatePicker = Ext.extend(Ext.BoxComponent, {
+    /**
+     * @cfg {String} todayText
+     * The text to display on the button that selects the current date (defaults to 'Today')
+     */
+    todayText : 'Today',
+    /**
+     * @cfg {String} okText
+     * The text to display on the ok button (defaults to ' OK ' to give the user extra clicking room)
+     */
+    okText : ' OK ',
+    /**
+     * @cfg {String} cancelText
+     * The text to display on the cancel button (defaults to 'Cancel')
+     */
+    cancelText : 'Cancel',
+    /**
+     * @cfg {Function} handler
+     * Optional. A function that will handle the select event of this picker.
+     * The handler is passed the following parameters:
+     * picker : DatePickerThis DatePicker.
+     * date : DateThe selected date.
+     * 
+     */
+    /**
+     * @cfg {Object} scope
+     * The scope (this reference) in which the {@link #handler}
+     * function will be called.  Defaults to this DatePicker instance.
+     */
+    /**
+     * @cfg {String} todayTip
+     * A string used to format the message for displaying in a tooltip over the button that
+     * selects the current date. Defaults to '{0} (Spacebar)' where
+     * the {0} token is replaced by today's date.
+     */
+    todayTip : '{0} (Spacebar)',
+    /**
+     * @cfg {String} minText
+     * The error text to display if the minDate validation fails (defaults to 'This date is before the minimum date')
+     */
+    minText : 'This date is before the minimum date',
+    /**
+     * @cfg {String} maxText
+     * The error text to display if the maxDate validation fails (defaults to 'This date is after the maximum date')
+     */
+    maxText : 'This date is after the maximum date',
+    /**
+     * @cfg {String} format
+     * The default date format string which can be overriden for localization support.  The format must be
+     * valid according to {@link Date#parseDate} (defaults to 'm/d/y').
+     */
+    format : 'm/d/y',
+    /**
+     * @cfg {String} disabledDaysText
+     * The tooltip to display when the date falls on a disabled day (defaults to 'Disabled')
+     */
+    disabledDaysText : 'Disabled',
+    /**
+     * @cfg {String} disabledDatesText
+     * The tooltip text to display when the date falls on a disabled date (defaults to 'Disabled')
+     */
+    disabledDatesText : 'Disabled',
+    /**
+     * @cfg {Array} monthNames
+     * An array of textual month names which can be overriden for localization support (defaults to Date.monthNames)
+     */
+    monthNames : Date.monthNames,
+    /**
+     * @cfg {Array} dayNames
+     * An array of textual day names which can be overriden for localization support (defaults to Date.dayNames)
+     */
+    dayNames : Date.dayNames,
+    /**
+     * @cfg {String} nextText
+     * The next month navigation button tooltip (defaults to 'Next Month (Control+Right)')
+     */
+    nextText : 'Next Month (Control+Right)',
+    /**
+     * @cfg {String} prevText
+     * The previous month navigation button tooltip (defaults to 'Previous Month (Control+Left)')
+     */
+    prevText : 'Previous Month (Control+Left)',
+    /**
+     * @cfg {String} monthYearText
+     * The header month selector tooltip (defaults to 'Choose a month (Control+Up/Down to move years)')
+     */
+    monthYearText : 'Choose a month (Control+Up/Down to move years)',
+    /**
+     * @cfg {Number} startDay
+     * Day index at which the week should begin, 0-based (defaults to 0, which is Sunday)
+     */
+    startDay : 0,
+    /**
+     * @cfg {Boolean} showToday
+     * False to hide the footer area containing the Today button and disable the keyboard handler for spacebar
+     * that selects the current date (defaults to true).
+     */
+    showToday : true,
+    /**
+     * @cfg {Date} minDate
+     * Minimum allowable date (JavaScript date object, defaults to null)
+     */
+    /**
+     * @cfg {Date} maxDate
+     * Maximum allowable date (JavaScript date object, defaults to null)
+     */
+    /**
+     * @cfg {Array} disabledDays
+     * An array of days to disable, 0-based. For example, [0, 6] disables Sunday and Saturday (defaults to null).
+     */
+    /**
+     * @cfg {RegExp} disabledDatesRE
+     * JavaScript regular expression used to disable a pattern of dates (defaults to null).  The {@link #disabledDates}
+     * config will generate this regex internally, but if you specify disabledDatesRE it will take precedence over the
+     * disabledDates value.
+     */
+    /**
+     * @cfg {Array} disabledDates
+     * An array of 'dates' to disable, as strings. These strings will be used to build a dynamic regular
+     * expression so they are very powerful. Some examples:
+     * 
+     * ['03/08/2003', '09/16/2003'] would disable those exact dates
+     * ['03/08', '09/16'] would disable those days for every year
+     * ['^03/08'] would only match the beginning (useful if you are using short years)
+     * ['03/../2006'] would disable every day in March 2006
+     * ['^03'] would disable every day in every March
+     * 
+     * Note that the format of the dates included in the array should exactly match the {@link #format} config.
+     * In order to support regular expressions, if you are using a date format that has '.' in it, you will have to
+     * escape the dot when restricting dates. For example: ['03\\.08\\.03'].
+     */
+
+    // private
+    // Set by other components to stop the picker focus being updated when the value changes.
+    focusOnSelect: true,
+
+    // default value used to initialise each date in the DatePicker
+    // (note: 12 noon was chosen because it steers well clear of all DST timezone changes)
+    initHour: 12, // 24-hour format
+
+    // private
+    initComponent : function(){
+        Ext.DatePicker.superclass.initComponent.call(this);
+
+        this.value = this.value ?
+                 this.value.clearTime(true) : new Date().clearTime();
+
+        this.addEvents(
+            /**
+             * @event select
+             * Fires when a date is selected
+             * @param {DatePicker} this DatePicker
+             * @param {Date} date The selected date
+             */
+            'select'
+        );
+
+        if(this.handler){
+            this.on('select', this.handler,  this.scope || this);
+        }
+
+        this.initDisabledDays();
+    },
+
+    // private
+    initDisabledDays : function(){
+        if(!this.disabledDatesRE && this.disabledDates){
+            var dd = this.disabledDates,
+                len = dd.length - 1,
+                re = '(?:';
+
+            Ext.each(dd, function(d, i){
+                re += Ext.isDate(d) ? '^' + Ext.escapeRe(d.dateFormat(this.format)) + '$' : dd[i];
+                if(i != len){
+                    re += '|';
+                }
+            }, this);
+            this.disabledDatesRE = new RegExp(re + ')');
+        }
+    },
+
+    /**
+     * Replaces any existing disabled dates with new values and refreshes the DatePicker.
+     * @param {Array/RegExp} disabledDates An array of date strings (see the {@link #disabledDates} config
+     * for details on supported values), or a JavaScript regular expression used to disable a pattern of dates.
+     */
+    setDisabledDates : function(dd){
+        if(Ext.isArray(dd)){
+            this.disabledDates = dd;
+            this.disabledDatesRE = null;
+        }else{
+            this.disabledDatesRE = dd;
+        }
+        this.initDisabledDays();
+        this.update(this.value, true);
+    },
+
+    /**
+     * Replaces any existing disabled days (by index, 0-6) with new values and refreshes the DatePicker.
+     * @param {Array} disabledDays An array of disabled day indexes. See the {@link #disabledDays} config
+     * for details on supported values.
+     */
+    setDisabledDays : function(dd){
+        this.disabledDays = dd;
+        this.update(this.value, true);
+    },
+
+    /**
+     * Replaces any existing {@link #minDate} with the new value and refreshes the DatePicker.
+     * @param {Date} value The minimum date that can be selected
+     */
+    setMinDate : function(dt){
+        this.minDate = dt;
+        this.update(this.value, true);
+    },
+
+    /**
+     * Replaces any existing {@link #maxDate} with the new value and refreshes the DatePicker.
+     * @param {Date} value The maximum date that can be selected
+     */
+    setMaxDate : function(dt){
+        this.maxDate = dt;
+        this.update(this.value, true);
+    },
+
+    /**
+     * Sets the value of the date field
+     * @param {Date} value The date to set
+     */
+    setValue : function(value){
+        this.value = value.clearTime(true);
+        this.update(this.value);
+    },
+
+    /**
+     * Gets the current selected value of the date field
+     * @return {Date} The selected date
+     */
+    getValue : function(){
+        return this.value;
+    },
+
+    // private
+    focus : function(){
+        this.update(this.activeDate);
+    },
+
+    // private
+    onEnable: function(initial){
+        Ext.DatePicker.superclass.onEnable.call(this);
+        this.doDisabled(false);
+        this.update(initial ? this.value : this.activeDate);
+        if(Ext.isIE){
+            this.el.repaint();
+        }
+
+    },
+
+    // private
+    onDisable : function(){
+        Ext.DatePicker.superclass.onDisable.call(this);
+        this.doDisabled(true);
+        if(Ext.isIE && !Ext.isIE8){
+            /* Really strange problem in IE6/7, when disabled, have to explicitly
+             * repaint each of the nodes to get them to display correctly, simply
+             * calling repaint on the main element doesn't appear to be enough.
+             */
+             Ext.each([].concat(this.textNodes, this.el.query('th span')), function(el){
+                 Ext.fly(el).repaint();
+             });
+        }
+    },
+
+    // private
+    doDisabled : function(disabled){
+        this.keyNav.setDisabled(disabled);
+        this.prevRepeater.setDisabled(disabled);
+        this.nextRepeater.setDisabled(disabled);
+        if(this.showToday){
+            this.todayKeyListener.setDisabled(disabled);
+            this.todayBtn.setDisabled(disabled);
+        }
+    },
+
+    // private
+    onRender : function(container, position){
+        var m = [
+             '
',
+                '',
+                '',
+                this.showToday ? '' : '',
+                '   
'],
+                dn = this.dayNames,
+                i;
+        for(i = 0; i < 7; i++){
+            var d = this.startDay+i;
+            if(d > 6){
+                d = d-7;
+            }
+            m.push('');
+        }
+        m[m.length] = '';
+        for(i = 0; i < 42; i++) {
+            if(i % 7 === 0 && i !== 0){
+                m[m.length] = '';
+            }
+            m[m.length] = '';
+        }
+        m.push('', dn[d].substr(0,1), '
');
+
+        var el = document.createElement('div');
+        el.className = 'x-date-picker';
+        el.innerHTML = m.join('');
+
+        container.dom.insertBefore(el, position);
+
+        this.el = Ext.get(el);
+        this.eventEl = Ext.get(el.firstChild);
+
+        this.prevRepeater = new Ext.util.ClickRepeater(this.el.child('td.x-date-left a'), {
+            handler: this.showPrevMonth,
+            scope: this,
+            preventDefault:true,
+            stopDefault:true
+        });
+
+        this.nextRepeater = new Ext.util.ClickRepeater(this.el.child('td.x-date-right a'), {
+            handler: this.showNextMonth,
+            scope: this,
+            preventDefault:true,
+            stopDefault:true
+        });
+
+        this.monthPicker = this.el.down('div.x-date-mp');
+        this.monthPicker.enableDisplayMode('block');
+
+        this.keyNav = new Ext.KeyNav(this.eventEl, {
+            'left' : function(e){
+                if(e.ctrlKey){
+                    this.showPrevMonth();
+                }else{
+                    this.update(this.activeDate.add('d', -1));
+                }
+            },
+
+            'right' : function(e){
+                if(e.ctrlKey){
+                    this.showNextMonth();
+                }else{
+                    this.update(this.activeDate.add('d', 1));
+                }
+            },
+
+            'up' : function(e){
+                if(e.ctrlKey){
+                    this.showNextYear();
+                }else{
+                    this.update(this.activeDate.add('d', -7));
+                }
+            },
+
+            'down' : function(e){
+                if(e.ctrlKey){
+                    this.showPrevYear();
+                }else{
+                    this.update(this.activeDate.add('d', 7));
+                }
+            },
+
+            'pageUp' : function(e){
+                this.showNextMonth();
+            },
+
+            'pageDown' : function(e){
+                this.showPrevMonth();
+            },
+
+            'enter' : function(e){
+                e.stopPropagation();
+                return true;
+            },
+
+            scope : this
+        });
+
+        this.el.unselectable();
+
+        this.cells = this.el.select('table.x-date-inner tbody td');
+        this.textNodes = this.el.query('table.x-date-inner tbody span');
+
+        this.mbtn = new Ext.Button({
+            text: ' ',
+            tooltip: this.monthYearText,
+            renderTo: this.el.child('td.x-date-middle', true)
+        });
+        this.mbtn.el.child('em').addClass('x-btn-arrow');
+
+        if(this.showToday){
+            this.todayKeyListener = this.eventEl.addKeyListener(Ext.EventObject.SPACE, this.selectToday,  this);
+            var today = (new Date()).dateFormat(this.format);
+            this.todayBtn = new Ext.Button({
+                renderTo: this.el.child('td.x-date-bottom', true),
+                text: String.format(this.todayText, today),
+                tooltip: String.format(this.todayTip, today),
+                handler: this.selectToday,
+                scope: this
+            });
+        }
+        this.mon(this.eventEl, 'mousewheel', this.handleMouseWheel, this);
+        this.mon(this.eventEl, 'click', this.handleDateClick,  this, {delegate: 'a.x-date-date'});
+        this.mon(this.mbtn, 'click', this.showMonthPicker, this);
+        this.onEnable(true);
+    },
+
+    // private
+    createMonthPicker : function(){
+        if(!this.monthPicker.dom.firstChild){
+            var buf = [''];
+            for(var i = 0; i < 6; i++){
+                buf.push(
+                    '',
+                    '',
+                    i === 0 ?
+                    '' :
+                    ''
+                );
+            }
+            buf.push(
+                '',
+                '', Date.getShortMonthName(i), ' ', Date.getShortMonthName(i + 6), ' 
'
+            );
+            this.monthPicker.update(buf.join(''));
+
+            this.mon(this.monthPicker, 'click', this.onMonthClick, this);
+            this.mon(this.monthPicker, 'dblclick', this.onMonthDblClick, this);
+
+            this.mpMonths = this.monthPicker.select('td.x-date-mp-month');
+            this.mpYears = this.monthPicker.select('td.x-date-mp-year');
+
+            this.mpMonths.each(function(m, a, i){
+                i += 1;
+                if((i%2) === 0){
+                    m.dom.xmonth = 5 + Math.round(i * 0.5);
+                }else{
+                    m.dom.xmonth = Math.round((i-1) * 0.5);
+                }
+            });
+        }
+    },
+
+    // private
+    showMonthPicker : function(){
+        if(!this.disabled){
+            this.createMonthPicker();
+            var size = this.el.getSize();
+            this.monthPicker.setSize(size);
+            this.monthPicker.child('table').setSize(size);
+
+            this.mpSelMonth = (this.activeDate || this.value).getMonth();
+            this.updateMPMonth(this.mpSelMonth);
+            this.mpSelYear = (this.activeDate || this.value).getFullYear();
+            this.updateMPYear(this.mpSelYear);
+
+            this.monthPicker.slideIn('t', {duration:0.2});
+        }
+    },
+
+    // private
+    updateMPYear : function(y){
+        this.mpyear = y;
+        var ys = this.mpYears.elements;
+        for(var i = 1; i <= 10; i++){
+            var td = ys[i-1], y2;
+            if((i%2) === 0){
+                y2 = y + Math.round(i * 0.5);
+                td.firstChild.innerHTML = y2;
+                td.xyear = y2;
+            }else{
+                y2 = y - (5-Math.round(i * 0.5));
+                td.firstChild.innerHTML = y2;
+                td.xyear = y2;
+            }
+            this.mpYears.item(i-1)[y2 == this.mpSelYear ? 'addClass' : 'removeClass']('x-date-mp-sel');
+        }
+    },
+
+    // private
+    updateMPMonth : function(sm){
+        this.mpMonths.each(function(m, a, i){
+            m[m.dom.xmonth == sm ? 'addClass' : 'removeClass']('x-date-mp-sel');
+        });
+    },
+
+    // private
+    selectMPMonth : function(m){
+
+    },
+
+    // private
+    onMonthClick : function(e, t){
+        e.stopEvent();
+        var el = new Ext.Element(t), pn;
+        if(el.is('button.x-date-mp-cancel')){
+            this.hideMonthPicker();
+        }
+        else if(el.is('button.x-date-mp-ok')){
+            var d = new Date(this.mpSelYear, this.mpSelMonth, (this.activeDate || this.value).getDate());
+            if(d.getMonth() != this.mpSelMonth){
+                // 'fix' the JS rolling date conversion if needed
+                d = new Date(this.mpSelYear, this.mpSelMonth, 1).getLastDateOfMonth();
+            }
+            this.update(d);
+            this.hideMonthPicker();
+        }
+        else if((pn = el.up('td.x-date-mp-month', 2))){
+            this.mpMonths.removeClass('x-date-mp-sel');
+            pn.addClass('x-date-mp-sel');
+            this.mpSelMonth = pn.dom.xmonth;
+        }
+        else if((pn = el.up('td.x-date-mp-year', 2))){
+            this.mpYears.removeClass('x-date-mp-sel');
+            pn.addClass('x-date-mp-sel');
+            this.mpSelYear = pn.dom.xyear;
+        }
+        else if(el.is('a.x-date-mp-prev')){
+            this.updateMPYear(this.mpyear-10);
+        }
+        else if(el.is('a.x-date-mp-next')){
+            this.updateMPYear(this.mpyear+10);
+        }
+    },
+
+    // private
+    onMonthDblClick : function(e, t){
+        e.stopEvent();
+        var el = new Ext.Element(t), pn;
+        if((pn = el.up('td.x-date-mp-month', 2))){
+            this.update(new Date(this.mpSelYear, pn.dom.xmonth, (this.activeDate || this.value).getDate()));
+            this.hideMonthPicker();
+        }
+        else if((pn = el.up('td.x-date-mp-year', 2))){
+            this.update(new Date(pn.dom.xyear, this.mpSelMonth, (this.activeDate || this.value).getDate()));
+            this.hideMonthPicker();
+        }
+    },
+
+    // private
+    hideMonthPicker : function(disableAnim){
+        if(this.monthPicker){
+            if(disableAnim === true){
+                this.monthPicker.hide();
+            }else{
+                this.monthPicker.slideOut('t', {duration:0.2});
+            }
+        }
+    },
+
+    // private
+    showPrevMonth : function(e){
+        this.update(this.activeDate.add('mo', -1));
+    },
+
+    // private
+    showNextMonth : function(e){
+        this.update(this.activeDate.add('mo', 1));
+    },
+
+    // private
+    showPrevYear : function(){
+        this.update(this.activeDate.add('y', -1));
+    },
+
+    // private
+    showNextYear : function(){
+        this.update(this.activeDate.add('y', 1));
+    },
+
+    // private
+    handleMouseWheel : function(e){
+        e.stopEvent();
+        if(!this.disabled){
+            var delta = e.getWheelDelta();
+            if(delta > 0){
+                this.showPrevMonth();
+            } else if(delta < 0){
+                this.showNextMonth();
+            }
+        }
+    },
+
+    // private
+    handleDateClick : function(e, t){
+        e.stopEvent();
+        if(!this.disabled && t.dateValue && !Ext.fly(t.parentNode).hasClass('x-date-disabled')){
+            this.cancelFocus = this.focusOnSelect === false;
+            this.setValue(new Date(t.dateValue));
+            delete this.cancelFocus;
+            this.fireEvent('select', this, this.value);
+        }
+    },
+
+    // private
+    selectToday : function(){
+        if(this.todayBtn && !this.todayBtn.disabled){
+            this.setValue(new Date().clearTime());
+            this.fireEvent('select', this, this.value);
+        }
+    },
+
+    // private
+    update : function(date, forceRefresh){
+        if(this.rendered){
+            var vd = this.activeDate, vis = this.isVisible();
+            this.activeDate = date;
+            if(!forceRefresh && vd && this.el){
+                var t = date.getTime();
+                if(vd.getMonth() == date.getMonth() && vd.getFullYear() == date.getFullYear()){
+                    this.cells.removeClass('x-date-selected');
+                    this.cells.each(function(c){
+                       if(c.dom.firstChild.dateValue == t){
+                           c.addClass('x-date-selected');
+                           if(vis && !this.cancelFocus){
+                               Ext.fly(c.dom.firstChild).focus(50);
+                           }
+                           return false;
+                       }
+                    }, this);
+                    return;
+                }
+            }
+            var days = date.getDaysInMonth(),
+                firstOfMonth = date.getFirstDateOfMonth(),
+                startingPos = firstOfMonth.getDay()-this.startDay;
+
+            if(startingPos < 0){
+                startingPos += 7;
+            }
+            days += startingPos;
+
+            var pm = date.add('mo', -1),
+                prevStart = pm.getDaysInMonth()-startingPos,
+                cells = this.cells.elements,
+                textEls = this.textNodes,
+                // convert everything to numbers so it's fast
+                d = (new Date(pm.getFullYear(), pm.getMonth(), prevStart, this.initHour)),
+                today = new Date().clearTime().getTime(),
+                sel = date.clearTime(true).getTime(),
+                min = this.minDate ? this.minDate.clearTime(true) : Number.NEGATIVE_INFINITY,
+                max = this.maxDate ? this.maxDate.clearTime(true) : Number.POSITIVE_INFINITY,
+                ddMatch = this.disabledDatesRE,
+                ddText = this.disabledDatesText,
+                ddays = this.disabledDays ? this.disabledDays.join('') : false,
+                ddaysText = this.disabledDaysText,
+                format = this.format;
+
+            if(this.showToday){
+                var td = new Date().clearTime(),
+                    disable = (td < min || td > max ||
+                    (ddMatch && format && ddMatch.test(td.dateFormat(format))) ||
+                    (ddays && ddays.indexOf(td.getDay()) != -1));
+
+                if(!this.disabled){
+                    this.todayBtn.setDisabled(disable);
+                    this.todayKeyListener[disable ? 'disable' : 'enable']();
+                }
+            }
+
+            var setCellClass = function(cal, cell){
+                cell.title = '';
+                var t = d.clearTime(true).getTime();
+                cell.firstChild.dateValue = t;
+                if(t == today){
+                    cell.className += ' x-date-today';
+                    cell.title = cal.todayText;
+                }
+                if(t == sel){
+                    cell.className += ' x-date-selected';
+                    if(vis){
+                        Ext.fly(cell.firstChild).focus(50);
+                    }
+                }
+                // disabling
+                if(t < min) {
+                    cell.className = ' x-date-disabled';
+                    cell.title = cal.minText;
+                    return;
+                }
+                if(t > max) {
+                    cell.className = ' x-date-disabled';
+                    cell.title = cal.maxText;
+                    return;
+                }
+                if(ddays){
+                    if(ddays.indexOf(d.getDay()) != -1){
+                        cell.title = ddaysText;
+                        cell.className = ' x-date-disabled';
+                    }
+                }
+                if(ddMatch && format){
+                    var fvalue = d.dateFormat(format);
+                    if(ddMatch.test(fvalue)){
+                        cell.title = ddText.replace('%0', fvalue);
+                        cell.className = ' x-date-disabled';
+                    }
+                }
+            };
+
+            var i = 0;
+            for(; i < startingPos; i++) {
+                textEls[i].innerHTML = (++prevStart);
+                d.setDate(d.getDate()+1);
+                cells[i].className = 'x-date-prevday';
+                setCellClass(this, cells[i]);
+            }
+            for(; i < days; i++){
+                var intDay = i - startingPos + 1;
+                textEls[i].innerHTML = (intDay);
+                d.setDate(d.getDate()+1);
+                cells[i].className = 'x-date-active';
+                setCellClass(this, cells[i]);
+            }
+            var extraDays = 0;
+            for(; i < 42; i++) {
+                 textEls[i].innerHTML = (++extraDays);
+                 d.setDate(d.getDate()+1);
+                 cells[i].className = 'x-date-nextday';
+                 setCellClass(this, cells[i]);
+            }
+
+            this.mbtn.setText(this.monthNames[date.getMonth()] + ' ' + date.getFullYear());
+
+            if(!this.internalRender){
+                var main = this.el.dom.firstChild,
+                    w = main.offsetWidth;
+                this.el.setWidth(w + this.el.getBorderWidth('lr'));
+                Ext.fly(main).setWidth(w);
+                this.internalRender = true;
+                // opera does not respect the auto grow header center column
+                // then, after it gets a width opera refuses to recalculate
+                // without a second pass
+                if(Ext.isOpera && !this.secondPass){
+                    main.rows[0].cells[1].style.width = (w - (main.rows[0].cells[0].offsetWidth+main.rows[0].cells[2].offsetWidth)) + 'px';
+                    this.secondPass = true;
+                    this.update.defer(10, this, [date]);
+                }
+            }
+        }
+    },
+
+    // private
+    beforeDestroy : function() {
+        if(this.rendered){
+            Ext.destroy(
+                this.keyNav,
+                this.monthPicker,
+                this.eventEl,
+                this.mbtn,
+                this.nextRepeater,
+                this.prevRepeater,
+                this.cells.el,
+                this.todayBtn
+            );
+            delete this.textNodes;
+            delete this.cells.elements;
+        }
+    }
+
+    /**
+     * @cfg {String} autoEl @hide
+     */
+});
+
+Ext.reg('datepicker', Ext.DatePicker);
+/**
+ * @class Ext.LoadMask
+ * A simple utility class for generically masking elements while loading data.  If the {@link #store}
+ * config option is specified, the masking will be automatically synchronized with the store's loading
+ * process and the mask element will be cached for reuse.  For all other elements, this mask will replace the
+ * element's Updater load indicator and will be destroyed after the initial load.
+ * Example usage:
+ *
+// Basic mask:
+var myMask = new Ext.LoadMask(Ext.getBody(), {msg:"Please wait..."});
+myMask.show();
+
+ * @constructor
+ * Create a new LoadMask
+ * @param {Mixed} el The element or DOM node, or its id
+ * @param {Object} config The config object
+ */
+Ext.LoadMask = function(el, config){
+    this.el = Ext.get(el);
+    Ext.apply(this, config);
+    if(this.store){
+        this.store.on({
+            scope: this,
+            beforeload: this.onBeforeLoad,
+            load: this.onLoad,
+            exception: this.onLoad
+        });
+        this.removeMask = Ext.value(this.removeMask, false);
+    }else{
+        var um = this.el.getUpdater();
+        um.showLoadIndicator = false; // disable the default indicator
+        um.on({
+            scope: this,
+            beforeupdate: this.onBeforeLoad,
+            update: this.onLoad,
+            failure: this.onLoad
+        });
+        this.removeMask = Ext.value(this.removeMask, true);
+    }
+};
+
+Ext.LoadMask.prototype = {
+    /**
+     * @cfg {Ext.data.Store} store
+     * Optional Store to which the mask is bound. The mask is displayed when a load request is issued, and
+     * hidden on either load sucess, or load fail.
+     */
+    /**
+     * @cfg {Boolean} removeMask
+     * True to create a single-use mask that is automatically destroyed after loading (useful for page loads),
+     * False to persist the mask element reference for multiple uses (e.g., for paged data widgets).  Defaults to false.
+     */
+    /**
+     * @cfg {String} msg
+     * The text to display in a centered loading message box (defaults to 'Loading...')
+     */
+    msg : 'Loading...',
+    /**
+     * @cfg {String} msgCls
+     * The CSS class to apply to the loading message element (defaults to "x-mask-loading")
+     */
+    msgCls : 'x-mask-loading',
+
+    /**
+     * Read-only. True if the mask is currently disabled so that it will not be displayed (defaults to false)
+     * @type Boolean
+     */
+    disabled: false,
+
+    /**
+     * Disables the mask to prevent it from being displayed
+     */
+    disable : function(){
+       this.disabled = true;
+    },
+
+    /**
+     * Enables the mask so that it can be displayed
+     */
+    enable : function(){
+        this.disabled = false;
+    },
+
+    // private
+    onLoad : function(){
+        this.el.unmask(this.removeMask);
+    },
+
+    // private
+    onBeforeLoad : function(){
+        if(!this.disabled){
+            this.el.mask(this.msg, this.msgCls);
+        }
+    },
+
+    /**
+     * Show this LoadMask over the configured Element.
+     */
+    show: function(){
+        this.onBeforeLoad();
+    },
+
+    /**
+     * Hide this LoadMask.
+     */
+    hide: function(){
+        this.onLoad();
+    },
+
+    // private
+    destroy : function(){
+        if(this.store){
+            this.store.un('beforeload', this.onBeforeLoad, this);
+            this.store.un('load', this.onLoad, this);
+            this.store.un('exception', this.onLoad, this);
+        }else{
+            var um = this.el.getUpdater();
+            um.un('beforeupdate', this.onBeforeLoad, this);
+            um.un('update', this.onLoad, this);
+            um.un('failure', this.onLoad, this);
+        }
+    }
+};Ext.ns('Ext.slider');
+
+/**
+ * @class Ext.slider.Thumb
+ * @extends Object
+ * Represents a single thumb element on a Slider. This would not usually be created manually and would instead
+ * be created internally by an {@link Ext.slider.MultiSlider Ext.Slider}.
+ */
+Ext.slider.Thumb = Ext.extend(Object, {
+
+    /**
+     * @constructor
+     * @cfg {Ext.slider.MultiSlider} slider The Slider to render to (required)
+     */
+    constructor: function(config) {
+        /**
+         * @property slider
+         * @type Ext.slider.MultiSlider
+         * The slider this thumb is contained within
+         */
+        Ext.apply(this, config || {}, {
+            cls: 'x-slider-thumb',
+
+            /**
+             * @cfg {Boolean} constrain True to constrain the thumb so that it cannot overlap its siblings
+             */
+            constrain: false
+        });
+
+        Ext.slider.Thumb.superclass.constructor.call(this, config);
+
+        if (this.slider.vertical) {
+            Ext.apply(this, Ext.slider.Thumb.Vertical);
+        }
+    },
+
+    /**
+     * Renders the thumb into a slider
+     */
+    render: function() {
+        this.el = this.slider.innerEl.insertFirst({cls: this.cls});
+
+        this.initEvents();
+    },
+
+    /**
+     * Enables the thumb if it is currently disabled
+     */
+    enable: function() {
+        this.disabled = false;
+        this.el.removeClass(this.slider.disabledClass);
+    },
+
+    /**
+     * Disables the thumb if it is currently enabled
+     */
+    disable: function() {
+        this.disabled = true;
+        this.el.addClass(this.slider.disabledClass);
+    },
+
+    /**
+     * Sets up an Ext.dd.DragTracker for this thumb
+     */
+    initEvents: function() {
+        var el = this.el;
+
+        el.addClassOnOver('x-slider-thumb-over');
+
+        this.tracker = new Ext.dd.DragTracker({
+            onBeforeStart: this.onBeforeDragStart.createDelegate(this),
+            onStart      : this.onDragStart.createDelegate(this),
+            onDrag       : this.onDrag.createDelegate(this),
+            onEnd        : this.onDragEnd.createDelegate(this),
+            tolerance    : 3,
+            autoStart    : 300
+        });
+
+        this.tracker.initEl(el);
+    },
+
+    /**
+     * @private
+     * This is tied into the internal Ext.dd.DragTracker. If the slider is currently disabled,
+     * this returns false to disable the DragTracker too.
+     * @return {Boolean} False if the slider is currently disabled
+     */
+    onBeforeDragStart : function(e) {
+        if (this.disabled) {
+            return false;
+        } else {
+            this.slider.promoteThumb(this);
+            return true;
+        }
+    },
+
+    /**
+     * @private
+     * This is tied into the internal Ext.dd.DragTracker's onStart template method. Adds the drag CSS class
+     * to the thumb and fires the 'dragstart' event
+     */
+    onDragStart: function(e){
+        this.el.addClass('x-slider-thumb-drag');
+        this.dragging = true;
+        this.dragStartValue = this.value;
+
+        this.slider.fireEvent('dragstart', this.slider, e, this);
+    },
+
+    /**
+     * @private
+     * This is tied into the internal Ext.dd.DragTracker's onDrag template method. This is called every time
+     * the DragTracker detects a drag movement. It updates the Slider's value using the position of the drag
+     */
+    onDrag: function(e) {
+        var slider   = this.slider,
+            index    = this.index,
+            newValue = this.getNewValue();
+
+        if (this.constrain) {
+            var above = slider.thumbs[index + 1],
+                below = slider.thumbs[index - 1];
+
+            if (below != undefined && newValue <= below.value) newValue = below.value;
+            if (above != undefined && newValue >= above.value) newValue = above.value;
+        }
+
+        slider.setValue(index, newValue, false);
+        slider.fireEvent('drag', slider, e, this);
+    },
+
+    getNewValue: function() {
+        var slider   = this.slider,
+            pos      = slider.innerEl.translatePoints(this.tracker.getXY());
+
+        return Ext.util.Format.round(slider.reverseValue(pos.left), slider.decimalPrecision);
+    },
+
+    /**
+     * @private
+     * This is tied to the internal Ext.dd.DragTracker's onEnd template method. Removes the drag CSS class and
+     * fires the 'changecomplete' event with the new value
+     */
+    onDragEnd: function(e) {
+        var slider = this.slider,
+            value  = this.value;
+
+        this.el.removeClass('x-slider-thumb-drag');
+
+        this.dragging = false;
+        slider.fireEvent('dragend', slider, e);
+
+        if (this.dragStartValue != value) {
+            slider.fireEvent('changecomplete', slider, value, this);
+        }
+    }
+});
+
+/**
+ * @class Ext.slider.MultiSlider
+ * @extends Ext.BoxComponent
+ * Slider which supports vertical or horizontal orientation, keyboard adjustments, configurable snapping, axis clicking and animation. Can be added as an item to any container. Example usage:
++new Ext.Slider({
+    renderTo: Ext.getBody(),
+    width: 200,
+    value: 50,
+    increment: 10,
+    minValue: 0,
+    maxValue: 100
+});
+
+ * Sliders can be created with more than one thumb handle by passing an array of values instead of a single one:
++new Ext.Slider({
+    renderTo: Ext.getBody(),
+    width: 200,
+    values: [25, 50, 75],
+    minValue: 0,
+    maxValue: 100,
+
+    //this defaults to true, setting to false allows the thumbs to pass each other
+    {@link #constrainThumbs}: false
+});
+
+ */
+Ext.slider.MultiSlider = Ext.extend(Ext.BoxComponent, {
+    /**
+     * @cfg {Number} value The value to initialize the slider with. Defaults to minValue.
+     */
+    /**
+     * @cfg {Boolean} vertical Orient the Slider vertically rather than horizontally, defaults to false.
+     */
+    vertical: false,
+    /**
+     * @cfg {Number} minValue The minimum value for the Slider. Defaults to 0.
+     */
+    minValue: 0,
+    /**
+     * @cfg {Number} maxValue The maximum value for the Slider. Defaults to 100.
+     */
+    maxValue: 100,
+    /**
+     * @cfg {Number/Boolean} decimalPrecision.
+     * The number of decimal places to which to round the Slider's value. Defaults to 0.
+     * To disable rounding, configure as false.
+     */
+    decimalPrecision: 0,
+    /**
+     * @cfg {Number} keyIncrement How many units to change the Slider when adjusting with keyboard navigation. Defaults to 1. If the increment config is larger, it will be used instead.
+     */
+    keyIncrement: 1,
+    /**
+     * @cfg {Number} increment How many units to change the slider when adjusting by drag and drop. Use this option to enable 'snapping'.
+     */
+    increment: 0,
+
+    /**
+     * @private
+     * @property clickRange
+     * @type Array
+     * Determines whether or not a click to the slider component is considered to be a user request to change the value. Specified as an array of [top, bottom],
+     * the click event's 'top' property is compared to these numbers and the click only considered a change request if it falls within them. e.g. if the 'top'
+     * value of the click event is 4 or 16, the click is not considered a change request as it falls outside of the [5, 15] range
+     */
+    clickRange: [5,15],
+
+    /**
+     * @cfg {Boolean} clickToChange Determines whether or not clicking on the Slider axis will change the slider. Defaults to true
+     */
+    clickToChange : true,
+    /**
+     * @cfg {Boolean} animate Turn on or off animation. Defaults to true
+     */
+    animate: true,
+
+    /**
+     * True while the thumb is in a drag operation
+     * @type Boolean
+     */
+    dragging: false,
+
+    /**
+     * @cfg {Boolean} constrainThumbs True to disallow thumbs from overlapping one another. Defaults to true
+     */
+    constrainThumbs: true,
+
+    /**
+     * @private
+     * @property topThumbZIndex
+     * @type Number
+     * The number used internally to set the z index of the top thumb (see promoteThumb for details)
+     */
+    topThumbZIndex: 10000,
+
+    // private override
+    initComponent : function(){
+        if(!Ext.isDefined(this.value)){
+            this.value = this.minValue;
+        }
+
+        /**
+         * @property thumbs
+         * @type Array
+         * Array containing references to each thumb
+         */
+        this.thumbs = [];
+
+        Ext.slider.MultiSlider.superclass.initComponent.call(this);
+
+        this.keyIncrement = Math.max(this.increment, this.keyIncrement);
+        this.addEvents(
+            /**
+             * @event beforechange
+             * Fires before the slider value is changed. By returning false from an event handler,
+             * you can cancel the event and prevent the slider from changing.
+             * @param {Ext.Slider} slider The slider
+             * @param {Number} newValue The new value which the slider is being changed to.
+             * @param {Number} oldValue The old value which the slider was previously.
+             */
+            'beforechange',
+
+            /**
+             * @event change
+             * Fires when the slider value is changed.
+             * @param {Ext.Slider} slider The slider
+             * @param {Number} newValue The new value which the slider has been changed to.
+             * @param {Ext.slider.Thumb} thumb The thumb that was changed
+             */
+            'change',
+
+            /**
+             * @event changecomplete
+             * Fires when the slider value is changed by the user and any drag operations have completed.
+             * @param {Ext.Slider} slider The slider
+             * @param {Number} newValue The new value which the slider has been changed to.
+             * @param {Ext.slider.Thumb} thumb The thumb that was changed
+             */
+            'changecomplete',
+
+            /**
+             * @event dragstart
+             * Fires after a drag operation has started.
+             * @param {Ext.Slider} slider The slider
+             * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker
+             */
+            'dragstart',
+
+            /**
+             * @event drag
+             * Fires continuously during the drag operation while the mouse is moving.
+             * @param {Ext.Slider} slider The slider
+             * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker
+             */
+            'drag',
+
+            /**
+             * @event dragend
+             * Fires after the drag operation has completed.
+             * @param {Ext.Slider} slider The slider
+             * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker
+             */
+            'dragend'
+        );
+
+        /**
+         * @property values
+         * @type Array
+         * Array of values to initalize the thumbs with
+         */
+        if (this.values == undefined || Ext.isEmpty(this.values)) this.values = [0];
+
+        var values = this.values;
+
+        for (var i=0; i < values.length; i++) {
+            this.addThumb(values[i]);
+        }
+
+        if(this.vertical){
+            Ext.apply(this, Ext.slider.Vertical);
+        }
+    },
+
+    /**
+     * Creates a new thumb and adds it to the slider
+     * @param {Number} value The initial value to set on the thumb. Defaults to 0
+     */
+    addThumb: function(value) {
+        var thumb = new Ext.slider.Thumb({
+            value    : value,
+            slider   : this,
+            index    : this.thumbs.length,
+            constrain: this.constrainThumbs
+        });
+        this.thumbs.push(thumb);
+
+        //render the thumb now if needed
+        if (this.rendered) thumb.render();
+    },
+
+    /**
+     * @private
+     * Moves the given thumb above all other by increasing its z-index. This is called when as drag
+     * any thumb, so that the thumb that was just dragged is always at the highest z-index. This is
+     * required when the thumbs are stacked on top of each other at one of the ends of the slider's
+     * range, which can result in the user not being able to move any of them.
+     * @param {Ext.slider.Thumb} topThumb The thumb to move to the top
+     */
+    promoteThumb: function(topThumb) {
+        var thumbs = this.thumbs,
+            zIndex, thumb;
+
+        for (var i = 0, j = thumbs.length; i < j; i++) {
+            thumb = thumbs[i];
+
+            if (thumb == topThumb) {
+                zIndex = this.topThumbZIndex;
+            } else {
+                zIndex = '';
+            }
+
+            thumb.el.setStyle('zIndex', zIndex);
+        }
+    },
+
+    // private override
+    onRender : function() {
+        this.autoEl = {
+            cls: 'x-slider ' + (this.vertical ? 'x-slider-vert' : 'x-slider-horz'),
+            cn : {
+                cls: 'x-slider-end',
+                cn : {
+                    cls:'x-slider-inner',
+                    cn : [{tag:'a', cls:'x-slider-focus', href:"#", tabIndex: '-1', hidefocus:'on'}]
+                }
+            }
+        };
+
+        Ext.slider.MultiSlider.superclass.onRender.apply(this, arguments);
+
+        this.endEl   = this.el.first();
+        this.innerEl = this.endEl.first();
+        this.focusEl = this.innerEl.child('.x-slider-focus');
+
+        //render each thumb
+        for (var i=0; i < this.thumbs.length; i++) {
+            this.thumbs[i].render();
+        }
+
+        //calculate the size of half a thumb
+        var thumb      = this.innerEl.child('.x-slider-thumb');
+        this.halfThumb = (this.vertical ? thumb.getHeight() : thumb.getWidth()) / 2;
+
+        this.initEvents();
+    },
+
+    /**
+     * @private
+     * Adds keyboard and mouse listeners on this.el. Ignores click events on the internal focus element.
+     * Creates a new DragTracker which is used to control what happens when the user drags the thumb around.
+     */
+    initEvents : function(){
+        this.mon(this.el, {
+            scope    : this,
+            mousedown: this.onMouseDown,
+            keydown  : this.onKeyDown
+        });
+
+        this.focusEl.swallowEvent("click", true);
+    },
+
+    /**
+     * @private
+     * Mousedown handler for the slider. If the clickToChange is enabled and the click was not on the draggable 'thumb',
+     * this calculates the new value of the slider and tells the implementation (Horizontal or Vertical) to move the thumb
+     * @param {Ext.EventObject} e The click event
+     */
+    onMouseDown : function(e){
+        if(this.disabled){
+            return;
+        }
+
+        //see if the click was on any of the thumbs
+        var thumbClicked = false;
+        for (var i=0; i < this.thumbs.length; i++) {
+            thumbClicked = thumbClicked || e.target == this.thumbs[i].el.dom;
+        }
+
+        if (this.clickToChange && !thumbClicked) {
+            var local = this.innerEl.translatePoints(e.getXY());
+            this.onClickChange(local);
+        }
+        this.focus();
+    },
+
+    /**
+     * @private
+     * Moves the thumb to the indicated position. Note that a Vertical implementation is provided in Ext.slider.Vertical.
+     * Only changes the value if the click was within this.clickRange.
+     * @param {Object} local Object containing top and left values for the click event.
+     */
+    onClickChange : function(local) {
+        if (local.top > this.clickRange[0] && local.top < this.clickRange[1]) {
+            //find the nearest thumb to the click event
+            var thumb = this.getNearest(local, 'left'),
+                index = thumb.index;
+
+            this.setValue(index, Ext.util.Format.round(this.reverseValue(local.left), this.decimalPrecision), undefined, true);
+        }
+    },
+
+    /**
+     * @private
+     * Returns the nearest thumb to a click event, along with its distance
+     * @param {Object} local Object containing top and left values from a click event
+     * @param {String} prop The property of local to compare on. Use 'left' for horizontal sliders, 'top' for vertical ones
+     * @return {Object} The closest thumb object and its distance from the click event
+     */
+    getNearest: function(local, prop) {
+        var localValue = prop == 'top' ? this.innerEl.getHeight() - local[prop] : local[prop],
+            clickValue = this.reverseValue(localValue),
+            nearestDistance = (this.maxValue - this.minValue) + 5, //add a small fudge for the end of the slider 
+            index = 0,
+            nearest = null;
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            var thumb = this.thumbs[i],
+                value = thumb.value,
+                dist  = Math.abs(value - clickValue);
+
+            if (Math.abs(dist <= nearestDistance)) {
+                nearest = thumb;
+                index = i;
+                nearestDistance = dist;
+            }
+        }
+        return nearest;
+    },
+
+    /**
+     * @private
+     * Handler for any keypresses captured by the slider. If the key is UP or RIGHT, the thumb is moved along to the right
+     * by this.keyIncrement. If DOWN or LEFT it is moved left. Pressing CTRL moves the slider to the end in either direction
+     * @param {Ext.EventObject} e The Event object
+     */
+    onKeyDown : function(e){
+        if(this.disabled){e.preventDefault();return;}
+        var k = e.getKey();
+        switch(k){
+            case e.UP:
+            case e.RIGHT:
+                e.stopEvent();
+                if(e.ctrlKey){
+                    this.setValue(this.maxValue, undefined, true);
+                }else{
+                    this.setValue(this.value+this.keyIncrement, undefined, true);
+                }
+            break;
+            case e.DOWN:
+            case e.LEFT:
+                e.stopEvent();
+                if(e.ctrlKey){
+                    this.setValue(this.minValue, undefined, true);
+                }else{
+                    this.setValue(this.value-this.keyIncrement, undefined, true);
+                }
+            break;
+            default:
+                e.preventDefault();
+        }
+    },
+
+    /**
+     * @private
+     * If using snapping, this takes a desired new value and returns the closest snapped
+     * value to it
+     * @param {Number} value The unsnapped value
+     * @return {Number} The value of the nearest snap target
+     */
+    doSnap : function(value){
+        if (!(this.increment && value)) {
+            return value;
+        }
+        var newValue = value,
+            inc = this.increment,
+            m = value % inc;
+        if (m != 0) {
+            newValue -= m;
+            if (m * 2 >= inc) {
+                newValue += inc;
+            } else if (m * 2 < -inc) {
+                newValue -= inc;
+            }
+        }
+        return newValue.constrain(this.minValue,  this.maxValue);
+    },
+
+    // private
+    afterRender : function(){
+        Ext.slider.MultiSlider.superclass.afterRender.apply(this, arguments);
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            var thumb = this.thumbs[i];
+
+            if (thumb.value !== undefined) {
+                var v = this.normalizeValue(thumb.value);
+
+                if (v !== thumb.value) {
+                    // delete this.value;
+                    this.setValue(i, v, false);
+                } else {
+                    this.moveThumb(i, this.translateValue(v), false);
+                }
+            }
+        };
+    },
+
+    /**
+     * @private
+     * Returns the ratio of pixels to mapped values. e.g. if the slider is 200px wide and maxValue - minValue is 100,
+     * the ratio is 2
+     * @return {Number} The ratio of pixels to mapped values
+     */
+    getRatio : function(){
+        var w = this.innerEl.getWidth(),
+            v = this.maxValue - this.minValue;
+        return v == 0 ? w : (w/v);
+    },
+
+    /**
+     * @private
+     * Returns a snapped, constrained value when given a desired value
+     * @param {Number} value Raw number value
+     * @return {Number} The raw value rounded to the correct d.p. and constrained within the set max and min values
+     */
+    normalizeValue : function(v){
+        v = this.doSnap(v);
+        v = Ext.util.Format.round(v, this.decimalPrecision);
+        v = v.constrain(this.minValue, this.maxValue);
+        return v;
+    },
+
+    /**
+     * Sets the minimum value for the slider instance. If the current value is less than the
+     * minimum value, the current value will be changed.
+     * @param {Number} val The new minimum value
+     */
+    setMinValue : function(val){
+        this.minValue = val;
+        this.syncThumb();
+
+        for (var i=0, j = this.thumbs.length; i < j; i++) {
+            if (this.thumbs[i].value < val) this.thumbs[i].value = val;
+        }
+    },
+
+    /**
+     * Sets the maximum value for the slider instance. If the current value is more than the
+     * maximum value, the current value will be changed.
+     * @param {Number} val The new maximum value
+     */
+    setMaxValue : function(val){
+        this.maxValue = val;
+        this.syncThumb();
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            if (this.thumbs[i].value > val) this.thumbs[i].value = val;
+        }
+    },
+
+    /**
+     * Programmatically sets the value of the Slider. Ensures that the value is constrained within
+     * the minValue and maxValue.
+     * @param {Number} index Index of the thumb to move
+     * @param {Number} value The value to set the slider to. (This will be constrained within minValue and maxValue)
+     * @param {Boolean} animate Turn on or off animation, defaults to true
+     */
+    setValue : function(index, v, animate, changeComplete) {
+        var thumb = this.thumbs[index],
+            el    = thumb.el;
+
+        v = this.normalizeValue(v);
+
+        if (v !== thumb.value && this.fireEvent('beforechange', this, v, thumb.value) !== false) {
+            thumb.value = v;
+            this.moveThumb(index, this.translateValue(v), animate !== false);
+            this.fireEvent('change', this, v, thumb);
+            if(changeComplete){
+                this.fireEvent('changecomplete', this, v, thumb);
+            }
+        }
+    },
+
+    /**
+     * @private
+     */
+    translateValue : function(v) {
+        var ratio = this.getRatio();
+        return (v * ratio) - (this.minValue * ratio) - this.halfThumb;
+    },
+
+    /**
+     * @private
+     * Given a pixel location along the slider, returns the mapped slider value for that pixel.
+     * E.g. if we have a slider 200px wide with minValue = 100 and maxValue = 500, reverseValue(50)
+     * returns 200
+     * @param {Number} pos The position along the slider to return a mapped value for
+     * @return {Number} The mapped value for the given position
+     */
+    reverseValue : function(pos){
+        var ratio = this.getRatio();
+        return (pos + (this.minValue * ratio)) / ratio;
+    },
+
+    /**
+     * @private
+     * @param {Number} index Index of the thumb to move
+     */
+    moveThumb: function(index, v, animate){
+        var thumb = this.thumbs[index].el;
+
+        if(!animate || this.animate === false){
+            thumb.setLeft(v);
+        }else{
+            thumb.shift({left: v, stopFx: true, duration:.35});
+        }
+    },
+
+    // private
+    focus : function(){
+        this.focusEl.focus(10);
+    },
+
+    // private
+    onResize : function(w, h){
+        var thumbs = this.thumbs,
+            len = thumbs.length,
+            i = 0;
+            
+        /*
+         * If we happen to be animating during a resize, the position of the thumb will likely be off
+         * when the animation stops. As such, just stop any animations before syncing the thumbs.
+         */
+        for(; i < len; ++i){
+            thumbs[i].el.stopFx();    
+        }
+        this.innerEl.setWidth(w - (this.el.getPadding('l') + this.endEl.getPadding('r')));
+        this.syncThumb();
+        Ext.slider.MultiSlider.superclass.onResize.apply(this, arguments);
+    },
+
+    //private
+    onDisable: function(){
+        Ext.slider.MultiSlider.superclass.onDisable.call(this);
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            var thumb = this.thumbs[i],
+                el    = thumb.el;
+
+            thumb.disable();
+
+            if(Ext.isIE){
+                //IE breaks when using overflow visible and opacity other than 1.
+                //Create a place holder for the thumb and display it.
+                var xy = el.getXY();
+                el.hide();
+
+                this.innerEl.addClass(this.disabledClass).dom.disabled = true;
+
+                if (!this.thumbHolder) {
+                    this.thumbHolder = this.endEl.createChild({cls: 'x-slider-thumb ' + this.disabledClass});
+                }
+
+                this.thumbHolder.show().setXY(xy);
+            }
+        }
+    },
+
+    //private
+    onEnable: function(){
+        Ext.slider.MultiSlider.superclass.onEnable.call(this);
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            var thumb = this.thumbs[i],
+                el    = thumb.el;
+
+            thumb.enable();
+
+            if (Ext.isIE) {
+                this.innerEl.removeClass(this.disabledClass).dom.disabled = false;
+
+                if (this.thumbHolder) this.thumbHolder.hide();
+
+                el.show();
+                this.syncThumb();
+            }
+        }
+    },
+
+    /**
+     * Synchronizes the thumb position to the proper proportion of the total component width based
+     * on the current slider {@link #value}.  This will be called automatically when the Slider
+     * is resized by a layout, but if it is rendered auto width, this method can be called from
+     * another resize handler to sync the Slider if necessary.
+     */
+    syncThumb : function() {
+        if (this.rendered) {
+            for (var i=0; i < this.thumbs.length; i++) {
+                this.moveThumb(i, this.translateValue(this.thumbs[i].value));
+            }
+        }
+    },
+
+    /**
+     * Returns the current value of the slider
+     * @param {Number} index The index of the thumb to return a value for
+     * @return {Number} The current value of the slider
+     */
+    getValue : function(index) {
+        return this.thumbs[index].value;
+    },
+
+    /**
+     * Returns an array of values - one for the location of each thumb
+     * @return {Array} The set of thumb values
+     */
+    getValues: function() {
+        var values = [];
+
+        for (var i=0; i < this.thumbs.length; i++) {
+            values.push(this.thumbs[i].value);
+        }
+
+        return values;
+    },
+
+    // private
+    beforeDestroy : function(){
+        Ext.destroyMembers(this, 'endEl', 'innerEl', 'thumb', 'halfThumb', 'focusEl', 'tracker', 'thumbHolder');
+        Ext.slider.MultiSlider.superclass.beforeDestroy.call(this);
+    }
+});
+
+Ext.reg('multislider', Ext.slider.MultiSlider);
+
+/**
+ * @class Ext.slider.SingleSlider
+ * @extends Ext.slider.MultiSlider
+ * Slider which supports vertical or horizontal orientation, keyboard adjustments,
+ * configurable snapping, axis clicking and animation. Can be added as an item to
+ * any container. Example usage:
+
+new Ext.slider.SingleSlider({
+    renderTo: Ext.getBody(),
+    width: 200,
+    value: 50,
+    increment: 10,
+    minValue: 0,
+    maxValue: 100
+});
+
+ * The class Ext.slider.SingleSlider is aliased to Ext.Slider for backwards compatibility.
+ */
+Ext.slider.SingleSlider = Ext.extend(Ext.slider.MultiSlider, {
+    constructor: function(config) {
+      config = config || {};
+
+      Ext.applyIf(config, {
+          values: [config.value || 0]
+      });
+
+      Ext.slider.SingleSlider.superclass.constructor.call(this, config);
+    },
+
+    /**
+     * Returns the current value of the slider
+     * @return {Number} The current value of the slider
+     */
+    getValue: function() {
+        //just returns the value of the first thumb, which should be the only one in a single slider
+        return Ext.slider.SingleSlider.superclass.getValue.call(this, 0);
+    },
+
+    /**
+     * Programmatically sets the value of the Slider. Ensures that the value is constrained within
+     * the minValue and maxValue.
+     * @param {Number} value The value to set the slider to. (This will be constrained within minValue and maxValue)
+     * @param {Boolean} animate Turn on or off animation, defaults to true
+     */
+    setValue: function(value, animate) {
+        var args = Ext.toArray(arguments),
+            len  = args.length;
+
+        //this is to maintain backwards compatiblity for sliders with only one thunb. Usually you must pass the thumb
+        //index to setValue, but if we only have one thumb we inject the index here first if given the multi-slider
+        //signature without the required index. The index will always be 0 for a single slider
+        if (len == 1 || (len <= 3 && typeof arguments[1] != 'number')) {
+            args.unshift(0);
+        }
+
+        return Ext.slider.SingleSlider.superclass.setValue.apply(this, args);
+    },
+
+    /**
+     * Synchronizes the thumb position to the proper proportion of the total component width based
+     * on the current slider {@link #value}.  This will be called automatically when the Slider
+     * is resized by a layout, but if it is rendered auto width, this method can be called from
+     * another resize handler to sync the Slider if necessary.
+     */
+    syncThumb : function() {
+        return Ext.slider.SingleSlider.superclass.syncThumb.apply(this, [0].concat(arguments));
+    },
+    
+    // private
+    getNearest : function(){
+        // Since there's only 1 thumb, it's always the nearest
+        return this.thumbs[0];    
+    }
+});
+
+//backwards compatibility
+Ext.Slider = Ext.slider.SingleSlider;
+
+Ext.reg('slider', Ext.slider.SingleSlider);
+
+// private class to support vertical sliders
+Ext.slider.Vertical = {
+    onResize : function(w, h){
+        this.innerEl.setHeight(h - (this.el.getPadding('t') + this.endEl.getPadding('b')));
+        this.syncThumb();
+    },
+
+    getRatio : function(){
+        var h = this.innerEl.getHeight(),
+            v = this.maxValue - this.minValue;
+        return h/v;
+    },
+
+    moveThumb: function(index, v, animate) {
+        var thumb = this.thumbs[index],
+            el    = thumb.el;
+
+        if (!animate || this.animate === false) {
+            el.setBottom(v);
+        } else {
+            el.shift({bottom: v, stopFx: true, duration:.35});
+        }
+    },
+
+    onClickChange : function(local) {
+        if (local.left > this.clickRange[0] && local.left < this.clickRange[1]) {
+            var thumb = this.getNearest(local, 'top'),
+                index = thumb.index,
+                value = this.minValue + this.reverseValue(this.innerEl.getHeight() - local.top);
+
+            this.setValue(index, Ext.util.Format.round(value, this.decimalPrecision), undefined, true);
+        }
+    }
+};
+
+//private class to support vertical dragging of thumbs within a slider
+Ext.slider.Thumb.Vertical = {
+    getNewValue: function() {
+        var slider   = this.slider,
+            innerEl  = slider.innerEl,
+            pos      = innerEl.translatePoints(this.tracker.getXY()),
+            bottom   = innerEl.getHeight() - pos.top;
+
+        return slider.minValue + Ext.util.Format.round(bottom / slider.getRatio(), slider.decimalPrecision);
+    }
+};
+/**
+ * @class Ext.ProgressBar
+ * @extends Ext.BoxComponent
+ * An updateable progress bar component.  The progress bar supports two different modes: manual and automatic.
+ * In manual mode, you are responsible for showing, updating (via {@link #updateProgress}) and clearing the
+ * progress bar as needed from your own code.  This method is most appropriate when you want to show progress
+ * throughout an operation that has predictable points of interest at which you can update the control.
+ * In automatic mode, you simply call {@link #wait} and let the progress bar run indefinitely, only clearing it
+ * once the operation is complete.  You can optionally have the progress bar wait for a specific amount of time
+ * and then clear itself.  Automatic mode is most appropriate for timed operations or asynchronous operations in
+ * which you have no need for indicating intermediate progress.
+ * @cfg {Float} value A floating point value between 0 and 1 (e.g., .5, defaults to 0)
+ * @cfg {String} text The progress bar text (defaults to '')
+ * @cfg {Mixed} textEl The element to render the progress text to (defaults to the progress
+ * bar's internal text element)
+ * @cfg {String} id The progress bar element's id (defaults to an auto-generated id)
+ * @xtype progress
+ */
+Ext.ProgressBar = Ext.extend(Ext.BoxComponent, {
+   /**
+    * @cfg {String} baseCls
+    * The base CSS class to apply to the progress bar's wrapper element (defaults to 'x-progress')
+    */
+    baseCls : 'x-progress',
+    
+    /**
+    * @cfg {Boolean} animate
+    * True to animate the progress bar during transitions (defaults to false)
+    */
+    animate : false,
+
+    // private
+    waitTimer : null,
+
+    // private
+    initComponent : function(){
+        Ext.ProgressBar.superclass.initComponent.call(this);
+        this.addEvents(
+            /**
+             * @event update
+             * Fires after each update interval
+             * @param {Ext.ProgressBar} this
+             * @param {Number} The current progress value
+             * @param {String} The current progress text
+             */
+            "update"
+        );
+    },
+
+    // private
+    onRender : function(ct, position){
+        var tpl = new Ext.Template(
+            '',
+                '',
+                    '',
+                        '',
+                            ' ',
+                        '',
+                    '',
+                    '',
+                        ' ',
+                    '',
+                '',
+            ''
+        );
+
+        this.el = position ? tpl.insertBefore(position, {cls: this.baseCls}, true)
+            : tpl.append(ct, {cls: this.baseCls}, true);
+                
+        if(this.id){
+            this.el.dom.id = this.id;
+        }
+        var inner = this.el.dom.firstChild;
+        this.progressBar = Ext.get(inner.firstChild);
+
+        if(this.textEl){
+            //use an external text el
+            this.textEl = Ext.get(this.textEl);
+            delete this.textTopEl;
+        }else{
+            //setup our internal layered text els
+            this.textTopEl = Ext.get(this.progressBar.dom.firstChild);
+            var textBackEl = Ext.get(inner.childNodes[1]);
+            this.textTopEl.setStyle("z-index", 99).addClass('x-hidden');
+            this.textEl = new Ext.CompositeElement([this.textTopEl.dom.firstChild, textBackEl.dom.firstChild]);
+            this.textEl.setWidth(inner.offsetWidth);
+        }
+        this.progressBar.setHeight(inner.offsetHeight);
+    },
+    
+    // private
+    afterRender : function(){
+        Ext.ProgressBar.superclass.afterRender.call(this);
+        if(this.value){
+            this.updateProgress(this.value, this.text);
+        }else{
+            this.updateText(this.text);
+        }
+    },
+
+    /**
+     * Updates the progress bar value, and optionally its text.  If the text argument is not specified,
+     * any existing text value will be unchanged.  To blank out existing text, pass ''.  Note that even
+     * if the progress bar value exceeds 1, it will never automatically reset -- you are responsible for
+     * determining when the progress is complete and calling {@link #reset} to clear and/or hide the control.
+     * @param {Float} value (optional) A floating point value between 0 and 1 (e.g., .5, defaults to 0)
+     * @param {String} text (optional) The string to display in the progress text element (defaults to '')
+     * @param {Boolean} animate (optional) Whether to animate the transition of the progress bar. If this value is
+     * not specified, the default for the class is used (default to false)
+     * @return {Ext.ProgressBar} this
+     */
+    updateProgress : function(value, text, animate){
+        this.value = value || 0;
+        if(text){
+            this.updateText(text);
+        }
+        if(this.rendered && !this.isDestroyed){
+            var w = Math.floor(value*this.el.dom.firstChild.offsetWidth);
+            this.progressBar.setWidth(w, animate === true || (animate !== false && this.animate));
+            if(this.textTopEl){
+                //textTopEl should be the same width as the bar so overflow will clip as the bar moves
+                this.textTopEl.removeClass('x-hidden').setWidth(w);
+            }
+        }
+        this.fireEvent('update', this, value, text);
+        return this;
+    },
+
+    /**
+     * Initiates an auto-updating progress bar.  A duration can be specified, in which case the progress
+     * bar will automatically reset after a fixed amount of time and optionally call a callback function
+     * if specified.  If no duration is passed in, then the progress bar will run indefinitely and must
+     * be manually cleared by calling {@link #reset}.  The wait method accepts a config object with
+     * the following properties:
+     * +Property   Type          Description
+---------- ------------  ----------------------------------------------------------------------
+duration   Number        The length of time in milliseconds that the progress bar should
+                         run before resetting itself (defaults to undefined, in which case it
+                         will run indefinitely until reset is called)
+interval   Number        The length of time in milliseconds between each progress update
+                         (defaults to 1000 ms)
+animate    Boolean       Whether to animate the transition of the progress bar. If this value is
+                         not specified, the default for the class is used.                                                   
+increment  Number        The number of progress update segments to display within the progress
+                         bar (defaults to 10).  If the bar reaches the end and is still
+                         updating, it will automatically wrap back to the beginning.
+text       String        Optional text to display in the progress bar element (defaults to '').
+fn         Function      A callback function to execute after the progress bar finishes auto-
+                         updating.  The function will be called with no arguments.  This function
+                         will be ignored if duration is not specified since in that case the
+                         progress bar can only be stopped programmatically, so any required function
+                         should be called by the same code after it resets the progress bar.
+scope      Object        The scope that is passed to the callback function (only applies when
+                         duration and fn are both passed).
+
+         *
+         * Example usage:
+         * 
+var p = new Ext.ProgressBar({
+   renderTo: 'my-el'
+});
+
+//Wait for 5 seconds, then update the status el (progress bar will auto-reset)
+p.wait({
+   interval: 100, //bar will move fast!
+   duration: 5000,
+   increment: 15,
+   text: 'Updating...',
+   scope: this,
+   fn: function(){
+      Ext.fly('status').update('Done!');
+   }
+});
+
+//Or update indefinitely until some async action completes, then reset manually
+p.wait();
+myAction.on('complete', function(){
+    p.reset();
+    Ext.fly('status').update('Done!');
+});
+
+     * @param {Object} config (optional) Configuration options
+     * @return {Ext.ProgressBar} this
+     */
+    wait : function(o){
+        if(!this.waitTimer){
+            var scope = this;
+            o = o || {};
+            this.updateText(o.text);
+            this.waitTimer = Ext.TaskMgr.start({
+                run: function(i){
+                    var inc = o.increment || 10;
+                    i -= 1;
+                    this.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate);
+                },
+                interval: o.interval || 1000,
+                duration: o.duration,
+                onStop: function(){
+                    if(o.fn){
+                        o.fn.apply(o.scope || this);
+                    }
+                    this.reset();
+                },
+                scope: scope
+            });
+        }
+        return this;
+    },
+
+    /**
+     * Returns true if the progress bar is currently in a {@link #wait} operation
+     * @return {Boolean} True if waiting, else false
+     */
+    isWaiting : function(){
+        return this.waitTimer !== null;
+    },
+
+    /**
+     * Updates the progress bar text.  If specified, textEl will be updated, otherwise the progress
+     * bar itself will display the updated text.
+     * @param {String} text (optional) The string to display in the progress text element (defaults to '')
+     * @return {Ext.ProgressBar} this
+     */
+    updateText : function(text){
+        this.text = text || ' ';
+        if(this.rendered){
+            this.textEl.update(this.text);
+        }
+        return this;
+    },
+    
+    /**
+     * Synchronizes the inner bar width to the proper proportion of the total componet width based
+     * on the current progress {@link #value}.  This will be called automatically when the ProgressBar
+     * is resized by a layout, but if it is rendered auto width, this method can be called from
+     * another resize handler to sync the ProgressBar if necessary.
+     */
+    syncProgressBar : function(){
+        if(this.value){
+            this.updateProgress(this.value, this.text);
+        }
+        return this;
+    },
+
+    /**
+     * Sets the size of the progress bar.
+     * @param {Number} width The new width in pixels
+     * @param {Number} height The new height in pixels
+     * @return {Ext.ProgressBar} this
+     */
+    setSize : function(w, h){
+        Ext.ProgressBar.superclass.setSize.call(this, w, h);
+        if(this.textTopEl){
+            var inner = this.el.dom.firstChild;
+            this.textEl.setSize(inner.offsetWidth, inner.offsetHeight);
+        }
+        this.syncProgressBar();
+        return this;
+    },
+
+    /**
+     * Resets the progress bar value to 0 and text to empty string.  If hide = true, the progress
+     * bar will also be hidden (using the {@link #hideMode} property internally).
+     * @param {Boolean} hide (optional) True to hide the progress bar (defaults to false)
+     * @return {Ext.ProgressBar} this
+     */
+    reset : function(hide){
+        this.updateProgress(0);
+        if(this.textTopEl){
+            this.textTopEl.addClass('x-hidden');
+        }
+        this.clearTimer();
+        if(hide === true){
+            this.hide();
+        }
+        return this;
+    },
+    
+    // private
+    clearTimer : function(){
+        if(this.waitTimer){
+            this.waitTimer.onStop = null; //prevent recursion
+            Ext.TaskMgr.stop(this.waitTimer);
+            this.waitTimer = null;
+        }
+    },
+    
+    onDestroy: function(){
+        this.clearTimer();
+        if(this.rendered){
+            if(this.textEl.isComposite){
+                this.textEl.clear();
+            }
+            Ext.destroyMembers(this, 'textEl', 'progressBar', 'textTopEl');
+        }
+        Ext.ProgressBar.superclass.onDestroy.call(this);
+    }
+});
+Ext.reg('progress', Ext.ProgressBar);/*
+ * 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=Ext.EventManager;
+var Dom=Ext.lib.Dom;
+
+/**
+ * @class 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 Ext.dd.DD}.  setDragElId() lets you define
+ * a separate element that would be moved, as in {@link 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 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
+ */
+Ext.dd.DragDrop = function(id, sGroup, config) {
+    if(id) {
+        this.init(id, sGroup, config);
+    }
+};
+
+Ext.dd.DragDrop.prototype = {
+
+    /**
+     * Set to false to enable a DragDrop object to fire drag events while dragging
+     * over its own Element. Defaults to true - DragDrop objects do not by default
+     * fire drag events to themselves.
+     * @property ignoreSelf
+     * @type Boolean
+     */
+
+    /**
+     * 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:
+     * 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;
+    },
+
+    /**
+     * When set to true, other DD objects in cooperating DDGroups do not receive
+     * notification events when this DD object is dragged over them. Defaults to false.
+     * @property moveOnly
+     * @type boolean
+     */
+    moveOnly: false,
+
+    /**
+     * Unlock this instace
+     * @method unlock
+     */
+    unlock: function() {
+        this.locked = false;
+    },
+
+    /**
+     * By default, all instances 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
+     * @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 available 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 Ext.dd.DDProxy("dragDiv1", "proxytest",
+                { dragElId: "existingProxyDiv" });
+ dd.startDrag = function(){
+     this.constrainTo("parent-id");
+ };
+ 
+ * Or you can initalize it using the {@link Ext.Element} object:
+ 
+ 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(Ext.isNumber(pad)){
+            pad = {left: pad, right:pad, top:pad, bottom:pad};
+        }
+        pad = pad || this.defaultPadding;
+        var b = Ext.get(this.getEl()).getBox(),
+            ce = Ext.get(constrainTo),
+            s = ce.getScroll(),
+            c, 
+            cd = ce.dom;
+        if(cd == document.body){
+            c = { x: s.left, y: s.top, width: Ext.lib.Dom.getViewWidth(), height: Ext.lib.Dom.getViewHeight()};
+        }else{
+            var xy = ce.getXY();
+            c = {x : xy[0], y: xy[1], width: cd.clientWidth, height: cd.clientHeight};
+        }
+
+
+        var topSpace = b.y - c.y,
+            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 = 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 Ext.dd.DDProxy
+     * @method getDragEl
+     * @return {HTMLElement} the html element
+     */
+    getDragEl: function() {
+        return Ext.getDom(this.dragElId);
+    },
+
+    /**
+     * Sets up the DragDrop object.  Must be called in the constructor of any
+     * 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 = 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 = 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 setInitPosition
+     * @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 = 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 = 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 {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 Ext.lib.Point(Ext.lib.Event.getPageX(e), 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 = 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 = 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 (!Ext.dd.DragDropMgr) {
+
+/**
+ * @class 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
+ */
+Ext.dd.DragDropMgr = function() {
+
+    var Event = 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[]
+         * @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[]
+         * @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=350
+         * @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] && 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 (var 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} oDD the drag obj
+         * @param {DragDrop} oTargetDD 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);
+
+            return true;
+        },
+
+        /**
+         * Iterates over all of the DragDrop elements to find ones we are
+         * hovering over or dropping on
+         * @method fireEvents
+         * @param {Event} e the event
+         * @param {boolean} isDrop is this a drop op or a mouseover op?
+         * @private
+         * @static
+         */
+        fireEvents: function(e, isDrop) {
+            var dc = this.dragCurrent;
+
+            // If the user did the mouse up outside of the window, we could
+            // get here even though we have ended the drag.
+            if (!dc || dc.isLocked()) {
+                return;
+            }
+
+            var pt = e.getPoint();
+
+            // cache the previous dragOver array
+            var oldOvers = [];
+
+            var outEvts   = [];
+            var overEvts  = [];
+            var dropEvts  = [];
+            var enterEvts = [];
+
+            // Check to see if the object(s) we were hovering over is no longer
+            // being hovered over so we can fire the onDragOut event
+            for (var i in this.dragOvers) {
+
+                var ddo = this.dragOvers[i];
+
+                if (! this.isTypeOfDD(ddo)) {
+                    continue;
+                }
+
+                if (! this.isOverTarget(pt, ddo, this.mode)) {
+                    outEvts.push( ddo );
+                }
+
+                oldOvers[i] = true;
+                delete this.dragOvers[i];
+            }
+
+            for (var sGroup in dc.groups) {
+
+                if ("string" != typeof sGroup) {
+                    continue;
+                }
+
+                for (i in this.ids[sGroup]) {
+                    var oDD = this.ids[sGroup][i];
+                    if (! this.isTypeOfDD(oDD)) {
+                        continue;
+                    }
+
+                    if (oDD.isTarget && !oDD.isLocked() && ((oDD != dc) || (dc.ignoreSelf === false))) {
+                        if (this.isOverTarget(pt, oDD, this.mode)) {
+                            // look for drop interactions
+                            if (isDrop) {
+                                dropEvts.push( oDD );
+                            // look for drag enter and drag over interactions
+                            } else {
+
+                                // initial drag over: dragEnter fires
+                                if (!oldOvers[oDD.id]) {
+                                    enterEvts.push( oDD );
+                                // subsequent drag overs: dragOver fires
+                                } else {
+                                    overEvts.push( oDD );
+                                }
+
+                                this.dragOvers[oDD.id] = oDD;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (this.mode) {
+                if (outEvts.length) {
+                    dc.b4DragOut(e, outEvts);
+                    dc.onDragOut(e, outEvts);
+                }
+
+                if (enterEvts.length) {
+                    dc.onDragEnter(e, enterEvts);
+                }
+
+                if (overEvts.length) {
+                    dc.b4DragOver(e, overEvts);
+                    dc.onDragOver(e, overEvts);
+                }
+
+                if (dropEvts.length) {
+                    dc.b4DragDrop(e, dropEvts);
+                    dc.onDragDrop(e, dropEvts);
+                }
+
+            } else {
+                // fire dragout events
+                var len = 0;
+                for (i=0, len=outEvts.length; i
+         * Ext.dd.DragDropMgr.refreshCache(ddinstance.groups);
+         * 
+         * Alternatively:
+         * 
+         * Ext.dd.DragDropMgr.refreshCache({group1:true, group2:true});
+         * 
+         * @TODO this really should be an indexed array.  Alternatively this
+         * method could accept both.
+         * @method refreshCache
+         * @param {Object} groups an associative array of groups to refresh
+         * @static
+         */
+        refreshCache: function(groups) {
+            for (var sGroup in groups) {
+                if ("string" != typeof sGroup) {
+                    continue;
+                }
+                for (var i in this.ids[sGroup]) {
+                    var oDD = this.ids[sGroup][i];
+
+                    if (this.isTypeOfDD(oDD)) {
+                    // if (this.isTypeOfDD(oDD) && oDD.isTarget) {
+                        var loc = this.getLocation(oDD);
+                        if (loc) {
+                            this.locationCache[oDD.id] = loc;
+                        } else {
+                            delete this.locationCache[oDD.id];
+                            // this will unregister the drag and drop object if
+                            // the element is not in a usable state
+                            // oDD.unreg();
+                        }
+                    }
+                }
+            }
+        },
+
+        /**
+         * This checks to make sure an element exists and is in the DOM.  The
+         * main purpose is to handle cases where innerHTML is used to remove
+         * drag and drop objects from the DOM.  IE provides an 'unspecified
+         * error' when trying to access the offsetParent of such an element
+         * @method verifyEl
+         * @param {HTMLElement} el the element to check
+         * @return {boolean} true if the element looks usable
+         * @static
+         */
+        verifyEl: function(el) {
+            if (el) {
+                var parent;
+                if(Ext.isIE){
+                    try{
+                        parent = el.offsetParent;
+                    }catch(e){}
+                }else{
+                    parent = el.offsetParent;
+                }
+                if (parent) {
+                    return true;
+                }
+            }
+
+            return false;
+        },
+
+        /**
+         * Returns a Region object containing the drag and drop element's position
+         * and size, including the padding configured for it
+         * @method getLocation
+         * @param {DragDrop} oDD the drag and drop object to get the
+         *                       location for
+         * @return {Ext.lib.Region} a Region object representing the total area
+         *                             the element occupies, including any padding
+         *                             the instance is configured for.
+         * @static
+         */
+        getLocation: function(oDD) {
+            if (! this.isTypeOfDD(oDD)) {
+                return null;
+            }
+
+            var el = oDD.getEl(), pos, x1, x2, y1, y2, t, r, b, l;
+
+            try {
+                pos= Ext.lib.Dom.getXY(el);
+            } catch (e) { }
+
+            if (!pos) {
+                return null;
+            }
+
+            x1 = pos[0];
+            x2 = x1 + el.offsetWidth;
+            y1 = pos[1];
+            y2 = y1 + el.offsetHeight;
+
+            t = y1 - oDD.padding[0];
+            r = x2 + oDD.padding[1];
+            b = y2 + oDD.padding[2];
+            l = x1 - oDD.padding[3];
+
+            return new Ext.lib.Region( t, r, b, l );
+        },
+
+        /**
+         * Checks the cursor location to see if it over the target
+         * @method isOverTarget
+         * @param {Ext.lib.Point} pt The point to evaluate
+         * @param {DragDrop} oTarget the DragDrop object we are inspecting
+         * @return {boolean} true if the mouse is over the target
+         * @private
+         * @static
+         */
+        isOverTarget: function(pt, oTarget, intersect) {
+            // use cache if available
+            var loc = this.locationCache[oTarget.id];
+            if (!loc || !this.useCache) {
+                loc = this.getLocation(oTarget);
+                this.locationCache[oTarget.id] = loc;
+
+            }
+
+            if (!loc) {
+                return false;
+            }
+
+            oTarget.cursorIsOver = loc.contains( pt );
+
+            // DragDrop is using this as a sanity check for the initial mousedown
+            // in this case we are done.  In POINT mode, if the drag obj has no
+            // contraints, we are also done. Otherwise we need to evaluate the
+            // location of the target as related to the actual location of the
+            // dragged element.
+            var dc = this.dragCurrent;
+            if (!dc || !dc.getTargetCoord ||
+                    (!intersect && !dc.constrainX && !dc.constrainY)) {
+                return oTarget.cursorIsOver;
+            }
+
+            oTarget.overlap = null;
+
+            // Get the current location of the drag element, this is the
+            // location of the mouse event less the delta that represents
+            // where the original mousedown happened on the element.  We
+            // need to consider constraints and ticks as well.
+            var pos = dc.getTargetCoord(pt.x, pt.y);
+
+            var el = dc.getDragEl();
+            var curRegion = new Ext.lib.Region( pos.y,
+                                                   pos.x + el.offsetWidth,
+                                                   pos.y + el.offsetHeight,
+                                                   pos.x );
+
+            var overlap = curRegion.intersect(loc);
+
+            if (overlap) {
+                oTarget.overlap = overlap;
+                return (intersect) ? true : oTarget.cursorIsOver;
+            } else {
+                return false;
+            }
+        },
+
+        /**
+         * unload event handler
+         * @method _onUnload
+         * @private
+         * @static
+         */
+        _onUnload: function(e, me) {
+            Ext.dd.DragDropMgr.unregAll();
+        },
+
+        /**
+         * Cleans up the drag and drop events and objects.
+         * @method unregAll
+         * @private
+         * @static
+         */
+        unregAll: function() {
+
+            if (this.dragCurrent) {
+                this.stopDrag();
+                this.dragCurrent = null;
+            }
+
+            this._execOnAll("unreg", []);
+
+            for (var i in this.elementCache) {
+                delete this.elementCache[i];
+            }
+
+            this.elementCache = {};
+            this.ids = {};
+        },
+
+        /**
+         * A cache of DOM elements
+         * @property elementCache
+         * @private
+         * @static
+         */
+        elementCache: {},
+
+        /**
+         * Get the wrapper for the DOM element specified
+         * @method getElWrapper
+         * @param {String} id the id of the element to get
+         * @return {Ext.dd.DDM.ElementWrapper} the wrapped element
+         * @private
+         * @deprecated This wrapper isn't that useful
+         * @static
+         */
+        getElWrapper: function(id) {
+            var oWrapper = this.elementCache[id];
+            if (!oWrapper || !oWrapper.el) {
+                oWrapper = this.elementCache[id] =
+                    new this.ElementWrapper(Ext.getDom(id));
+            }
+            return oWrapper;
+        },
+
+        /**
+         * Returns the actual DOM element
+         * @method getElement
+         * @param {String} id the id of the elment to get
+         * @return {Object} The element
+         * @deprecated use Ext.lib.Ext.getDom instead
+         * @static
+         */
+        getElement: function(id) {
+            return Ext.getDom(id);
+        },
+
+        /**
+         * Returns the style property for the DOM element (i.e.,
+         * document.getElById(id).style)
+         * @method getCss
+         * @param {String} id the id of the elment to get
+         * @return {Object} The style property of the element
+         * @deprecated use Ext.lib.Dom instead
+         * @static
+         */
+        getCss: function(id) {
+            var el = Ext.getDom(id);
+            return (el) ? el.style : null;
+        },
+
+        /**
+         * Inner class for cached elements
+         * @class Ext.dd.DragDropMgr.ElementWrapper
+         * @for DragDropMgr
+         * @private
+         * @deprecated
+         */
+        ElementWrapper: function(el) {
+                /**
+                 * The element
+                 * @property el
+                 */
+                this.el = el || null;
+                /**
+                 * The element id
+                 * @property id
+                 */
+                this.id = this.el && el.id;
+                /**
+                 * A reference to the style property
+                 * @property css
+                 */
+                this.css = this.el && el.style;
+            },
+
+        /**
+         * Returns the X position of an html element
+         * @method getPosX
+         * @param el the element for which to get the position
+         * @return {int} the X coordinate
+         * @for DragDropMgr
+         * @deprecated use Ext.lib.Dom.getX instead
+         * @static
+         */
+        getPosX: function(el) {
+            return Ext.lib.Dom.getX(el);
+        },
+
+        /**
+         * Returns the Y position of an html element
+         * @method getPosY
+         * @param el the element for which to get the position
+         * @return {int} the Y coordinate
+         * @deprecated use Ext.lib.Dom.getY instead
+         * @static
+         */
+        getPosY: function(el) {
+            return Ext.lib.Dom.getY(el);
+        },
+
+        /**
+         * Swap two nodes.  In IE, we use the native method, for others we
+         * emulate the IE behavior
+         * @method swapNode
+         * @param n1 the first node to swap
+         * @param n2 the other node to swap
+         * @static
+         */
+        swapNode: function(n1, n2) {
+            if (n1.swapNode) {
+                n1.swapNode(n2);
+            } else {
+                var p = n2.parentNode;
+                var s = n2.nextSibling;
+
+                if (s == n1) {
+                    p.insertBefore(n1, n2);
+                } else if (n2 == n1.nextSibling) {
+                    p.insertBefore(n2, n1);
+                } else {
+                    n1.parentNode.replaceChild(n2, n1);
+                    p.insertBefore(n1, s);
+                }
+            }
+        },
+
+        /**
+         * Returns the current scroll position
+         * @method getScroll
+         * @private
+         * @static
+         */
+        getScroll: function () {
+            var t, l, dde=document.documentElement, db=document.body;
+            if (dde && (dde.scrollTop || dde.scrollLeft)) {
+                t = dde.scrollTop;
+                l = dde.scrollLeft;
+            } else if (db) {
+                t = db.scrollTop;
+                l = db.scrollLeft;
+            } else {
+
+            }
+            return { top: t, left: l };
+        },
+
+        /**
+         * Returns the specified element style property
+         * @method getStyle
+         * @param {HTMLElement} el          the element
+         * @param {string}      styleProp   the style property
+         * @return {string} The value of the style property
+         * @deprecated use Ext.lib.Dom.getStyle
+         * @static
+         */
+        getStyle: function(el, styleProp) {
+            return Ext.fly(el).getStyle(styleProp);
+        },
+
+        /**
+         * Gets the scrollTop
+         * @method getScrollTop
+         * @return {int} the document's scrollTop
+         * @static
+         */
+        getScrollTop: function () {
+            return this.getScroll().top;
+        },
+
+        /**
+         * Gets the scrollLeft
+         * @method getScrollLeft
+         * @return {int} the document's scrollTop
+         * @static
+         */
+        getScrollLeft: function () {
+            return this.getScroll().left;
+        },
+
+        /**
+         * Sets the x/y position of an element to the location of the
+         * target element.
+         * @method moveToEl
+         * @param {HTMLElement} moveEl      The element to move
+         * @param {HTMLElement} targetEl    The position reference element
+         * @static
+         */
+        moveToEl: function (moveEl, targetEl) {
+            var aCoord = Ext.lib.Dom.getXY(targetEl);
+            Ext.lib.Dom.setXY(moveEl, aCoord);
+        },
+
+        /**
+         * Numeric array sort function
+         * @method numericSort
+         * @static
+         */
+        numericSort: function(a, b) {
+            return (a - b);
+        },
+
+        /**
+         * Internal counter
+         * @property _timeoutCount
+         * @private
+         * @static
+         */
+        _timeoutCount: 0,
+
+        /**
+         * Trying to make the load order less important.  Without this we get
+         * an error if this file is loaded before the Event Utility.
+         * @method _addListeners
+         * @private
+         * @static
+         */
+        _addListeners: function() {
+            var DDM = Ext.dd.DDM;
+            if ( Ext.lib.Event && document ) {
+                DDM._onLoad();
+            } else {
+                if (DDM._timeoutCount > 2000) {
+                } else {
+                    setTimeout(DDM._addListeners, 10);
+                    if (document && document.body) {
+                        DDM._timeoutCount += 1;
+                    }
+                }
+            }
+        },
+
+        /**
+         * Recursively searches the immediate parent and all child nodes for
+         * the handle element in order to determine wheter or not it was
+         * clicked.
+         * @method handleWasClicked
+         * @param node the html element to inspect
+         * @static
+         */
+        handleWasClicked: function(node, id) {
+            if (this.isHandle(id, node.id)) {
+                return true;
+            } else {
+                // check to see if this is a text node child of the one we want
+                var p = node.parentNode;
+
+                while (p) {
+                    if (this.isHandle(id, p.id)) {
+                        return true;
+                    } else {
+                        p = p.parentNode;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+    };
+
+}();
+
+// shorter alias, save a few bytes
+Ext.dd.DDM = Ext.dd.DragDropMgr;
+Ext.dd.DDM._addListeners();
+
+}
+
+/**
+ * @class Ext.dd.DD
+ * A DragDrop implementation where the linked element follows the
+ * mouse cursor during a drag.
+ * @extends Ext.dd.DragDrop
+ * @constructor
+ * @param {String} id the id of the linked element
+ * @param {String} sGroup the group of related DragDrop items
+ * @param {object} config an object containing configurable attributes
+ *                Valid properties for DD:
+ *                    scroll
+ */
+Ext.dd.DD = function(id, sGroup, config) {
+    if (id) {
+        this.init(id, sGroup, config);
+    }
+};
+
+Ext.extend(Ext.dd.DD, Ext.dd.DragDrop, {
+
+    /**
+     * When set to true, the utility automatically tries to scroll the browser
+     * window when a drag and drop element is dragged near the viewport boundary.
+     * Defaults to true.
+     * @property scroll
+     * @type boolean
+     */
+    scroll: true,
+
+    /**
+     * Sets the pointer offset to the distance between the linked element's top
+     * left corner and the location the element was clicked
+     * @method autoOffset
+     * @param {int} iPageX the X coordinate of the click
+     * @param {int} iPageY the Y coordinate of the click
+     */
+    autoOffset: function(iPageX, iPageY) {
+        var x = iPageX - this.startPageX;
+        var y = iPageY - this.startPageY;
+        this.setDelta(x, y);
+    },
+
+    /**
+     * Sets the pointer offset.  You can call this directly to force the
+     * offset to be in a particular location (e.g., pass in 0,0 to set it
+     * to the center of the object)
+     * @method setDelta
+     * @param {int} iDeltaX the distance from the left
+     * @param {int} iDeltaY the distance from the top
+     */
+    setDelta: function(iDeltaX, iDeltaY) {
+        this.deltaX = iDeltaX;
+        this.deltaY = iDeltaY;
+    },
+
+    /**
+     * Sets the drag element to the location of the mousedown or click event,
+     * maintaining the cursor location relative to the location on the element
+     * that was clicked.  Override this if you want to place the element in a
+     * location other than where the cursor is.
+     * @method setDragElPos
+     * @param {int} iPageX the X coordinate of the mousedown or drag event
+     * @param {int} iPageY the Y coordinate of the mousedown or drag event
+     */
+    setDragElPos: function(iPageX, iPageY) {
+        // the first time we do this, we are going to check to make sure
+        // the element has css positioning
+
+        var el = this.getDragEl();
+        this.alignElWithMouse(el, iPageX, iPageY);
+    },
+
+    /**
+     * Sets the element to the location of the mousedown or click event,
+     * maintaining the cursor location relative to the location on the element
+     * that was clicked.  Override this if you want to place the element in a
+     * location other than where the cursor is.
+     * @method alignElWithMouse
+     * @param {HTMLElement} el the element to move
+     * @param {int} iPageX the X coordinate of the mousedown or drag event
+     * @param {int} iPageY the Y coordinate of the mousedown or drag event
+     */
+    alignElWithMouse: function(el, iPageX, iPageY) {
+        var oCoord = this.getTargetCoord(iPageX, iPageY);
+        var fly = el.dom ? el : Ext.fly(el, '_dd');
+        if (!this.deltaSetXY) {
+            var aCoord = [oCoord.x, oCoord.y];
+            fly.setXY(aCoord);
+            var newLeft = fly.getLeft(true);
+            var newTop  = fly.getTop(true);
+            this.deltaSetXY = [ newLeft - oCoord.x, newTop - oCoord.y ];
+        } else {
+            fly.setLeftTop(oCoord.x + this.deltaSetXY[0], oCoord.y + this.deltaSetXY[1]);
+        }
+
+        this.cachePosition(oCoord.x, oCoord.y);
+        this.autoScroll(oCoord.x, oCoord.y, el.offsetHeight, el.offsetWidth);
+        return oCoord;
+    },
+
+    /**
+     * Saves the most recent position so that we can reset the constraints and
+     * tick marks on-demand.  We need to know this so that we can calculate the
+     * number of pixels the element is offset from its original position.
+     * @method cachePosition
+     * @param iPageX the current x position (optional, this just makes it so we
+     * don't have to look it up again)
+     * @param iPageY the current y position (optional, this just makes it so we
+     * don't have to look it up again)
+     */
+    cachePosition: function(iPageX, iPageY) {
+        if (iPageX) {
+            this.lastPageX = iPageX;
+            this.lastPageY = iPageY;
+        } else {
+            var aCoord = Ext.lib.Dom.getXY(this.getEl());
+            this.lastPageX = aCoord[0];
+            this.lastPageY = aCoord[1];
+        }
+    },
+
+    /**
+     * Auto-scroll the window if the dragged object has been moved beyond the
+     * visible window boundary.
+     * @method autoScroll
+     * @param {int} x the drag element's x position
+     * @param {int} y the drag element's y position
+     * @param {int} h the height of the drag element
+     * @param {int} w the width of the drag element
+     * @private
+     */
+    autoScroll: function(x, y, h, w) {
+
+        if (this.scroll) {
+            // The client height
+            var clientH = Ext.lib.Dom.getViewHeight();
+
+            // The client width
+            var clientW = Ext.lib.Dom.getViewWidth();
+
+            // The amt scrolled down
+            var st = this.DDM.getScrollTop();
+
+            // The amt scrolled right
+            var sl = this.DDM.getScrollLeft();
+
+            // Location of the bottom of the element
+            var bot = h + y;
+
+            // Location of the right of the element
+            var right = w + x;
+
+            // The distance from the cursor to the bottom of the visible area,
+            // adjusted so that we don't scroll if the cursor is beyond the
+            // element drag constraints
+            var toBot = (clientH + st - y - this.deltaY);
+
+            // The distance from the cursor to the right of the visible area
+            var toRight = (clientW + sl - x - this.deltaX);
+
+
+            // How close to the edge the cursor must be before we scroll
+            // var thresh = (document.all) ? 100 : 40;
+            var thresh = 40;
+
+            // How many pixels to scroll per autoscroll op.  This helps to reduce
+            // clunky scrolling. IE is more sensitive about this ... it needs this
+            // value to be higher.
+            var scrAmt = (document.all) ? 80 : 30;
+
+            // Scroll down if we are near the bottom of the visible page and the
+            // obj extends below the crease
+            if ( bot > clientH && toBot < thresh ) {
+                window.scrollTo(sl, st + scrAmt);
+            }
+
+            // Scroll up if the window is scrolled down and the top of the object
+            // goes above the top border
+            if ( y < st && st > 0 && y - st < thresh ) {
+                window.scrollTo(sl, st - scrAmt);
+            }
+
+            // Scroll right if the obj is beyond the right border and the cursor is
+            // near the border.
+            if ( right > clientW && toRight < thresh ) {
+                window.scrollTo(sl + scrAmt, st);
+            }
+
+            // Scroll left if the window has been scrolled to the right and the obj
+            // extends past the left border
+            if ( x < sl && sl > 0 && x - sl < thresh ) {
+                window.scrollTo(sl - scrAmt, st);
+            }
+        }
+    },
+
+    /**
+     * Finds the location the element should be placed if we want to move
+     * it to where the mouse location less the click offset would place us.
+     * @method getTargetCoord
+     * @param {int} iPageX the X coordinate of the click
+     * @param {int} iPageY the Y coordinate of the click
+     * @return an object that contains the coordinates (Object.x and Object.y)
+     * @private
+     */
+    getTargetCoord: function(iPageX, iPageY) {
+        var x = iPageX - this.deltaX;
+        var y = iPageY - this.deltaY;
+
+        if (this.constrainX) {
+            if (x < this.minX) { x = this.minX; }
+            if (x > this.maxX) { x = this.maxX; }
+        }
+
+        if (this.constrainY) {
+            if (y < this.minY) { y = this.minY; }
+            if (y > this.maxY) { y = this.maxY; }
+        }
+
+        x = this.getTick(x, this.xTicks);
+        y = this.getTick(y, this.yTicks);
+
+
+        return {x:x, y:y};
+    },
+
+    /**
+     * Sets up config options specific to this class. Overrides
+     * Ext.dd.DragDrop, but all versions of this method through the
+     * inheritance chain are called
+     */
+    applyConfig: function() {
+        Ext.dd.DD.superclass.applyConfig.call(this);
+        this.scroll = (this.config.scroll !== false);
+    },
+
+    /**
+     * Event that fires prior to the onMouseDown event.  Overrides
+     * Ext.dd.DragDrop.
+     */
+    b4MouseDown: function(e) {
+        // this.resetConstraints();
+        this.autoOffset(e.getPageX(),
+                            e.getPageY());
+    },
+
+    /**
+     * Event that fires prior to the onDrag event.  Overrides
+     * Ext.dd.DragDrop.
+     */
+    b4Drag: function(e) {
+        this.setDragElPos(e.getPageX(),
+                            e.getPageY());
+    },
+
+    toString: function() {
+        return ("DD " + this.id);
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Debugging ygDragDrop events that can be overridden
+    //////////////////////////////////////////////////////////////////////////
+    /*
+    startDrag: function(x, y) {
+    },
+
+    onDrag: function(e) {
+    },
+
+    onDragEnter: function(e, id) {
+    },
+
+    onDragOver: function(e, id) {
+    },
+
+    onDragOut: function(e, id) {
+    },
+
+    onDragDrop: function(e, id) {
+    },
+
+    endDrag: function(e) {
+    }
+
+    */
+
+});
+/**
+ * @class Ext.dd.DDProxy
+ * A DragDrop implementation that inserts an empty, bordered div into
+ * the document that follows the cursor during drag operations.  At the time of
+ * the click, the frame div is resized to the dimensions of the linked html
+ * element, and moved to the exact location of the linked element.
+ *
+ * References to the "frame" element refer to the single proxy element that
+ * was created to be dragged in place of all DDProxy elements on the
+ * page.
+ *
+ * @extends Ext.dd.DD
+ * @constructor
+ * @param {String} id the id of the linked html element
+ * @param {String} sGroup the group of related DragDrop objects
+ * @param {object} config an object containing configurable attributes
+ *                Valid properties for DDProxy in addition to those in DragDrop:
+ *                   resizeFrame, centerFrame, dragElId
+ */
+Ext.dd.DDProxy = function(id, sGroup, config) {
+    if (id) {
+        this.init(id, sGroup, config);
+        this.initFrame();
+    }
+};
+
+/**
+ * The default drag frame div id
+ * @property Ext.dd.DDProxy.dragElId
+ * @type String
+ * @static
+ */
+Ext.dd.DDProxy.dragElId = "ygddfdiv";
+
+Ext.extend(Ext.dd.DDProxy, Ext.dd.DD, {
+
+    /**
+     * By default we resize the drag frame to be the same size as the element
+     * we want to drag (this is to get the frame effect).  We can turn it off
+     * if we want a different behavior.
+     * @property resizeFrame
+     * @type boolean
+     */
+    resizeFrame: true,
+
+    /**
+     * By default the frame is positioned exactly where the drag element is, so
+     * we use the cursor offset provided by Ext.dd.DD.  Another option that works only if
+     * you do not have constraints on the obj is to have the drag frame centered
+     * around the cursor.  Set centerFrame to true for this effect.
+     * @property centerFrame
+     * @type boolean
+     */
+    centerFrame: false,
+
+    /**
+     * Creates the proxy element if it does not yet exist
+     * @method createFrame
+     */
+    createFrame: function() {
+        var self = this;
+        var body = document.body;
+
+        if (!body || !body.firstChild) {
+            setTimeout( function() { self.createFrame(); }, 50 );
+            return;
+        }
+
+        var div = this.getDragEl();
+
+        if (!div) {
+            div    = document.createElement("div");
+            div.id = this.dragElId;
+            var s  = div.style;
+
+            s.position   = "absolute";
+            s.visibility = "hidden";
+            s.cursor     = "move";
+            s.border     = "2px solid #aaa";
+            s.zIndex     = 999;
+
+            // appendChild can blow up IE if invoked prior to the window load event
+            // while rendering a table.  It is possible there are other scenarios
+            // that would cause this to happen as well.
+            body.insertBefore(div, body.firstChild);
+        }
+    },
+
+    /**
+     * Initialization for the drag frame element.  Must be called in the
+     * constructor of all subclasses
+     * @method initFrame
+     */
+    initFrame: function() {
+        this.createFrame();
+    },
+
+    applyConfig: function() {
+        Ext.dd.DDProxy.superclass.applyConfig.call(this);
+
+        this.resizeFrame = (this.config.resizeFrame !== false);
+        this.centerFrame = (this.config.centerFrame);
+        this.setDragElId(this.config.dragElId || Ext.dd.DDProxy.dragElId);
+    },
+
+    /**
+     * Resizes the drag frame to the dimensions of the clicked object, positions
+     * it over the object, and finally displays it
+     * @method showFrame
+     * @param {int} iPageX X click position
+     * @param {int} iPageY Y click position
+     * @private
+     */
+    showFrame: function(iPageX, iPageY) {
+        var el = this.getEl();
+        var dragEl = this.getDragEl();
+        var s = dragEl.style;
+
+        this._resizeProxy();
+
+        if (this.centerFrame) {
+            this.setDelta( Math.round(parseInt(s.width,  10)/2),
+                           Math.round(parseInt(s.height, 10)/2) );
+        }
+
+        this.setDragElPos(iPageX, iPageY);
+
+        Ext.fly(dragEl).show();
+    },
+
+    /**
+     * The proxy is automatically resized to the dimensions of the linked
+     * element when a drag is initiated, unless resizeFrame is set to false
+     * @method _resizeProxy
+     * @private
+     */
+    _resizeProxy: function() {
+        if (this.resizeFrame) {
+            var el = this.getEl();
+            Ext.fly(this.getDragEl()).setSize(el.offsetWidth, el.offsetHeight);
+        }
+    },
+
+    // overrides Ext.dd.DragDrop
+    b4MouseDown: function(e) {
+        var x = e.getPageX();
+        var y = e.getPageY();
+        this.autoOffset(x, y);
+        this.setDragElPos(x, y);
+    },
+
+    // overrides Ext.dd.DragDrop
+    b4StartDrag: function(x, y) {
+        // show the drag frame
+        this.showFrame(x, y);
+    },
+
+    // overrides Ext.dd.DragDrop
+    b4EndDrag: function(e) {
+        Ext.fly(this.getDragEl()).hide();
+    },
+
+    // overrides Ext.dd.DragDrop
+    // By default we try to move the element to the last location of the frame.
+    // This is so that the default behavior mirrors that of Ext.dd.DD.
+    endDrag: function(e) {
+
+        var lel = this.getEl();
+        var del = this.getDragEl();
+
+        // Show the drag frame briefly so we can get its position
+        del.style.visibility = "";
+
+        this.beforeMove();
+        // Hide the linked element before the move to get around a Safari
+        // rendering bug.
+        lel.style.visibility = "hidden";
+        Ext.dd.DDM.moveToEl(lel, del);
+        del.style.visibility = "hidden";
+        lel.style.visibility = "";
+
+        this.afterDrag();
+    },
+
+    beforeMove : function(){
+
+    },
+
+    afterDrag : function(){
+
+    },
+
+    toString: function() {
+        return ("DDProxy " + this.id);
+    }
+
+});
+/**
+ * @class Ext.dd.DDTarget
+ * A DragDrop implementation that does not move, but can be a drop
+ * target.  You would get the same result by simply omitting implementation
+ * for the event callbacks, but this way we reduce the processing cost of the
+ * event listener and the callbacks.
+ * @extends Ext.dd.DragDrop
+ * @constructor
+ * @param {String} id the id of the element that is a drop target
+ * @param {String} sGroup the group of related DragDrop objects
+ * @param {object} config an object containing configurable attributes
+ *                 Valid properties for DDTarget in addition to those in
+ *                 DragDrop:
+ *                    none
+ */
+Ext.dd.DDTarget = function(id, sGroup, config) {
+    if (id) {
+        this.initTarget(id, sGroup, config);
+    }
+};
+
+// Ext.dd.DDTarget.prototype = new Ext.dd.DragDrop();
+Ext.extend(Ext.dd.DDTarget, Ext.dd.DragDrop, {
+    /**
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
+     */
+    getDragEl: Ext.emptyFn,
+    /**
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
+     */
+    isValidHandleChild: Ext.emptyFn,
+    /**
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    startDrag: Ext.emptyFn,
     /**
-     * @cfg {Number} pageY
-     * The page level y coordinate for this component if contained within a positioning container.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    endDrag: Ext.emptyFn,
     /**
-     * @cfg {Number} height
-     * The height of this component in pixels (defaults to auto).
-     * Note to express this dimension as a percentage or offset see {@link Ext.Component#anchor}.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onDrag: Ext.emptyFn,
     /**
-     * @cfg {Number} width
-     * The width of this component in pixels (defaults to auto).
-     * Note to express this dimension as a percentage or offset see {@link Ext.Component#anchor}.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onDragDrop: Ext.emptyFn,
     /**
-     * @cfg {Number} boxMinHeight
-     * The minimum value in pixels which this BoxComponent will set its height to.
-     * Warning: This will override any size management applied by layout managers.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onDragEnter: Ext.emptyFn,
     /**
-     * @cfg {Number} boxMinWidth
-     * The minimum value in pixels which this BoxComponent will set its width to.
-     * Warning: This will override any size management applied by layout managers.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onDragOut: Ext.emptyFn,
     /**
-     * @cfg {Number} boxMaxHeight
-     * The maximum value in pixels which this BoxComponent will set its height to.
-     * Warning: This will override any size management applied by layout managers.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onDragOver: Ext.emptyFn,
     /**
-     * @cfg {Number} boxMaxWidth
-     * The maximum value in pixels which this BoxComponent will set its width to.
-     * Warning: This will override any size management applied by layout managers.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onInvalidDrop: Ext.emptyFn,
     /**
-     * @cfg {Boolean} autoHeight
-     * True to use height:'auto', false to use fixed height (or allow it to be managed by its parent
-     * Container's {@link Ext.Container#layout layout manager}. Defaults to false.
-     * Note: Although many components inherit this config option, not all will
-     * function as expected with a height of 'auto'. Setting autoHeight:true means that the
-     * browser will manage height based on the element's contents, and that Ext will not manage it at all.
-     * If the browser is managing the height, be aware that resizes performed by the browser in response
-     * to changes within the structure of the Component cannot be detected. Therefore changes to the height might
-     * result in elements needing to be synchronized with the new height. Example:

-var w = new Ext.Window({
-    title: 'Window',
-    width: 600,
-    autoHeight: true,
-    items: {
-        title: 'Collapse Me',
-        height: 400,
-        collapsible: true,
-        border: false,
-        listeners: {
-            beforecollapse: function() {
-                w.el.shadow.hide();
-            },
-            beforeexpand: function() {
-                w.el.shadow.hide();
-            },
-            collapse: function() {
-                w.syncShadow();
-            },
-            expand: function() {
-                w.syncShadow();
-            }
-        }
-    }
-}).show();
-
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onMouseDown: Ext.emptyFn,
     /**
-     * @cfg {Boolean} autoWidth
-     * True to use width:'auto', false to use fixed width (or allow it to be managed by its parent
-     * Container's {@link Ext.Container#layout layout manager}. Defaults to false.
-     * Note: Although many components  inherit this config option, not all will
-     * function as expected with a width of 'auto'. Setting autoWidth:true means that the
-     * browser will manage width based on the element's contents, and that Ext will not manage it at all.
-     * If the browser is managing the width, be aware that resizes performed by the browser in response
-     * to changes within the structure of the Component cannot be detected. Therefore changes to the width might
-     * result in elements needing to be synchronized with the new width. For example, where the target element is:

-<div id='grid-container' style='margin-left:25%;width:50%'></div>
-
-     * A Panel rendered into that target element must listen for browser window resize in order to relay its
-      * child items when the browser changes its width:
-var myPanel = new Ext.Panel({
-    renderTo: 'grid-container',
-    monitorResize: true, // relay on browser resize
-    title: 'Panel',
-    height: 400,
-    autoWidth: true,
-    layout: 'hbox',
-    layoutConfig: {
-        align: 'stretch'
-    },
-    defaults: {
-        flex: 1
-    },
-    items: [{
-        title: 'Box 1',
-    }, {
-        title: 'Box 2'
-    }, {
-        title: 'Box 3'
-    }],
-});
-
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
+    onMouseUp: Ext.emptyFn,
     /**
-     * @cfg {Boolean} autoScroll
-     * true to use overflow:'auto' on the components layout element and show scroll bars automatically when
-     * necessary, false to clip any overflowing content (defaults to false).
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-
-    /* // private internal config
-     * {Boolean} deferHeight
-     * True to defer height calculations to an external component, false to allow this component to set its own
-     * height (defaults to false).
+    setXConstraint: Ext.emptyFn,
+    /**
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-
-    // private
-    initComponent : function(){
-        Ext.BoxComponent.superclass.initComponent.call(this);
-        this.addEvents(
-            /**
-             * @event resize
-             * Fires after the component is resized.
-             * @param {Ext.Component} this
-             * @param {Number} adjWidth The box-adjusted width that was set
-             * @param {Number} adjHeight The box-adjusted height that was set
-             * @param {Number} rawWidth The width that was originally specified
-             * @param {Number} rawHeight The height that was originally specified
-             */
-            'resize',
-            /**
-             * @event move
-             * Fires after the component is moved.
-             * @param {Ext.Component} this
-             * @param {Number} x The new x position
-             * @param {Number} y The new y position
-             */
-            'move'
-        );
-    },
-
-    // private, set in afterRender to signify that the component has been rendered
-    boxReady : false,
-    // private, used to defer height settings to subclasses
-    deferHeight: false,
-
+    setYConstraint: Ext.emptyFn,
     /**
-     * Sets the width and height of this BoxComponent. This method fires the {@link #resize} event. This method can accept
-     * either width and height as separate arguments, or you can pass a size object like {width:10, height:20}.
-     * @param {Mixed} width The new width to set. This may be one of:
-     * A Number specifying the new width in the {@link #getEl Element}'s {@link Ext.Element#defaultUnit}s (by default, pixels).
-     * A String used to set the CSS width style.
-     * A size object in the format {width: widthValue, height: heightValue}.
-     * undefined to leave the width unchanged.
-     * 
-     * @param {Mixed} height The new height to set (not required if a size object is passed as the first arg).
-     * This may be one of:
-     * A Number specifying the new height in the {@link #getEl Element}'s {@link Ext.Element#defaultUnit}s (by default, pixels).
-     * A String used to set the CSS height style. Animation may not be used.
-     * undefined to leave the height unchanged.
-     * 
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    setSize : function(w, h){
-
-        // support for standard size objects
-        if(typeof w == 'object'){
-            h = w.height, w = w.width;
-        }
-        if (Ext.isDefined(w) && Ext.isDefined(this.boxMinWidth) && (w < this.boxMinWidth)) {
-            w = this.boxMinWidth;
-        }
-        if (Ext.isDefined(h) && Ext.isDefined(this.boxMinHeight) && (h < this.boxMinHeight)) {
-            h = this.boxMinHeight;
-        }
-        if (Ext.isDefined(w) && Ext.isDefined(this.boxMaxWidth) && (w > this.boxMaxWidth)) {
-            w = this.boxMaxWidth;
-        }
-        if (Ext.isDefined(h) && Ext.isDefined(this.boxMaxHeight) && (h > this.boxMaxHeight)) {
-            h = this.boxMaxHeight;
-        }
-        // not rendered
-        if(!this.boxReady){
-            this.width = w, this.height = h;
-            return this;
-        }
-
-        // prevent recalcs when not needed
-        if(this.cacheSizes !== false && this.lastSize && this.lastSize.width == w && this.lastSize.height == h){
-            return this;
-        }
-        this.lastSize = {width: w, height: h};
-        var adj = this.adjustSize(w, h),
-            aw = adj.width,
-            ah = adj.height,
-            rz;
-        if(aw !== undefined || ah !== undefined){ // this code is nasty but performs better with floaters
-            rz = this.getResizeEl();
-            if(!this.deferHeight && aw !== undefined && ah !== undefined){
-                rz.setSize(aw, ah);
-            }else if(!this.deferHeight && ah !== undefined){
-                rz.setHeight(ah);
-            }else if(aw !== undefined){
-                rz.setWidth(aw);
-            }
-            this.onResize(aw, ah, w, h);
-            this.fireEvent('resize', this, aw, ah, w, h);
-        }
-        return this;
-    },
-
+    resetConstraints: Ext.emptyFn,
     /**
-     * Sets the width of the component.  This method fires the {@link #resize} event.
-     * @param {Number} width The new width to setThis may be one of:
-     * A Number specifying the new width in the {@link #getEl Element}'s {@link Ext.Element#defaultUnit}s (by default, pixels).
-     * A String used to set the CSS width style.
-     * 
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    setWidth : function(width){
-        return this.setSize(width);
-    },
-
+    clearConstraints: Ext.emptyFn,
     /**
-     * Sets the height of the component.  This method fires the {@link #resize} event.
-     * @param {Number} height The new height to set. This may be one of:
-     * A Number specifying the new height in the {@link #getEl Element}'s {@link Ext.Element#defaultUnit}s (by default, pixels).
-     * A String used to set the CSS height style.
-     * undefined to leave the height unchanged.
-     * 
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    setHeight : function(height){
-        return this.setSize(undefined, height);
-    },
-
+    clearTicks: Ext.emptyFn,
     /**
-     * Gets the current size of the component's underlying element.
-     * @return {Object} An object containing the element's size {width: (element width), height: (element height)}
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getSize : function(){
-        return this.getResizeEl().getSize();
-    },
-
+    setInitPosition: Ext.emptyFn,
     /**
-     * Gets the current width of the component's underlying element.
-     * @return {Number}
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getWidth : function(){
-        return this.getResizeEl().getWidth();
-    },
-
+    setDragElId: Ext.emptyFn,
     /**
-     * Gets the current height of the component's underlying element.
-     * @return {Number}
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getHeight : function(){
-        return this.getResizeEl().getHeight();
-    },
-
+    setHandleElId: Ext.emptyFn,
     /**
-     * Gets the current size of the component's underlying element, including space taken by its margins.
-     * @return {Object} An object containing the element's size {width: (element width + left/right margins), height: (element height + top/bottom margins)}
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getOuterSize : function(){
-        var el = this.getResizeEl();
-        return {width: el.getWidth() + el.getMargins('lr'),
-                height: el.getHeight() + el.getMargins('tb')};
-    },
-
+    setOuterHandleElId: Ext.emptyFn,
     /**
-     * Gets the current XY position of the component's underlying element.
-     * @param {Boolean} local (optional) If true the element's left and top are returned instead of page XY (defaults to false)
-     * @return {Array} The XY position of the element (e.g., [100, 200])
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getPosition : function(local){
-        var el = this.getPositionEl();
-        if(local === true){
-            return [el.getLeft(true), el.getTop(true)];
-        }
-        return this.xy || el.getXY();
-    },
-
+    addInvalidHandleClass: Ext.emptyFn,
     /**
-     * Gets the current box measurements of the component's underlying element.
-     * @param {Boolean} local (optional) If true the element's left and top are returned instead of page XY (defaults to false)
-     * @return {Object} box An object in the format {x, y, width, height}
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getBox : function(local){
-        var pos = this.getPosition(local);
-        var s = this.getSize();
-        s.x = pos[0];
-        s.y = pos[1];
-        return s;
-    },
-
+    addInvalidHandleId: Ext.emptyFn,
     /**
-     * Sets the current box measurements of the component's underlying element.
-     * @param {Object} box An object in the format {x, y, width, height}
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    updateBox : function(box){
-        this.setSize(box.width, box.height);
-        this.setPagePosition(box.x, box.y);
-        return this;
-    },
-
+    addInvalidHandleType: Ext.emptyFn,
     /**
-     * Returns the outermost Element of this Component which defines the Components overall size.
-     * Usually this will return the same Element as {@link #getEl},
-     * but in some cases, a Component may have some more wrapping Elements around its main
-     * active Element.
-     * An example is a ComboBox. It is encased in a wrapping Element which
-     * contains both the <input> Element (which is what would be returned
-     * by its {@link #getEl} method, and the trigger button Element.
-     * This Element is returned as the resizeEl.
-     * @return {Ext.Element} The Element which is to be resized by size managing layouts.
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    getResizeEl : function(){
-        return this.resizeEl || this.el;
-    },
-
+    removeInvalidHandleClass: Ext.emptyFn,
     /**
-     * Sets the overflow on the content element of the component.
-     * @param {Boolean} scroll True to allow the Component to auto scroll.
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    setAutoScroll : function(scroll){
-        if(this.rendered){
-            this.getContentTarget().setOverflow(scroll ? 'auto' : '');
-        }
-        this.autoScroll = scroll;
-        return this;
-    },
-
+    removeInvalidHandleId: Ext.emptyFn,
     /**
-     * Sets the left and top of the component.  To set the page XY position instead, use {@link #setPagePosition}.
-     * This method fires the {@link #move} event.
-     * @param {Number} left The new left
-     * @param {Number} top The new top
-     * @return {Ext.BoxComponent} this
+     * @hide
+     * Overridden and disabled. A DDTarget does not support being dragged.
+     * @method
      */
-    setPosition : function(x, y){
-        if(x && typeof x[1] == 'number'){
-            y = x[1];
-            x = x[0];
-        }
-        this.x = x;
-        this.y = y;
-        if(!this.boxReady){
-            return this;
-        }
-        var adj = this.adjustPosition(x, y);
-        var ax = adj.x, ay = adj.y;
+    removeInvalidHandleType: Ext.emptyFn,
 
-        var el = this.getPositionEl();
-        if(ax !== undefined || ay !== undefined){
-            if(ax !== undefined && ay !== undefined){
-                el.setLeftTop(ax, ay);
-            }else if(ax !== undefined){
-                el.setLeft(ax);
-            }else if(ay !== undefined){
-                el.setTop(ay);
+    toString: function() {
+        return ("DDTarget " + this.id);
+    }
+});/**
+ * @class Ext.dd.DragTracker
+ * @extends Ext.util.Observable
+ * A DragTracker listens for drag events on an Element and fires events at the start and end of the drag,
+ * as well as during the drag. This is useful for components such as {@link Ext.Slider}, where there is
+ * an element that can be dragged around to change the Slider's value.
+ * DragTracker provides a series of template methods that should be overridden to provide functionality
+ * in response to detected drag operations. These are onBeforeStart, onStart, onDrag and onEnd.
+ * See {@link Ext.Slider}'s initEvents function for an example implementation.
+ */
+Ext.dd.DragTracker = Ext.extend(Ext.util.Observable,  {    
+    /**
+     * @cfg {Boolean} active
+	 * Defaults to false.
+	 */	
+    active: false,
+    /**
+     * @cfg {Number} tolerance
+	 * Number of pixels the drag target must be moved before dragging is considered to have started. Defaults to 5.
+	 */	
+    tolerance: 5,
+    /**
+     * @cfg {Boolean/Number} autoStart
+	 * Defaults to false. Specify true to defer trigger start by 1000 ms.
+	 * Specify a Number for the number of milliseconds to defer trigger start.
+	 */	
+    autoStart: false,
+    
+    constructor : function(config){
+        Ext.apply(this, config);
+	    this.addEvents(
+	        /**
+	         * @event mousedown
+	         * @param {Object} this
+	         * @param {Object} e event object
+	         */
+	        'mousedown',
+	        /**
+	         * @event mouseup
+	         * @param {Object} this
+	         * @param {Object} e event object
+	         */
+	        'mouseup',
+	        /**
+	         * @event mousemove
+	         * @param {Object} this
+	         * @param {Object} e event object
+	         */
+	        'mousemove',
+	        /**
+	         * @event dragstart
+	         * @param {Object} this
+	         * @param {Object} startXY the page coordinates of the event
+	         */
+	        'dragstart',
+	        /**
+	         * @event dragend
+	         * @param {Object} this
+	         * @param {Object} e event object
+	         */
+	        'dragend',
+	        /**
+	         * @event drag
+	         * @param {Object} this
+	         * @param {Object} e event object
+	         */
+	        'drag'
+	    );
+	
+	    this.dragRegion = new Ext.lib.Region(0,0,0,0);
+	
+	    if(this.el){
+	        this.initEl(this.el);
+	    }
+        Ext.dd.DragTracker.superclass.constructor.call(this, config);
+    },
+
+    initEl: function(el){
+        this.el = Ext.get(el);
+        el.on('mousedown', this.onMouseDown, this,
+                this.delegate ? {delegate: this.delegate} : undefined);
+    },
+
+    destroy : function(){
+        this.el.un('mousedown', this.onMouseDown, this);
+    },
+
+    onMouseDown: function(e, target){
+        if(this.fireEvent('mousedown', this, e) !== false && this.onBeforeStart(e) !== false){
+            this.startXY = this.lastXY = e.getXY();
+            this.dragTarget = this.delegate ? target : this.el.dom;
+            if(this.preventDefault !== false){
+                e.preventDefault();
+            }
+            var doc = Ext.getDoc();
+            doc.on('mouseup', this.onMouseUp, this);
+            doc.on('mousemove', this.onMouseMove, this);
+            doc.on('selectstart', this.stopSelect, this);
+            if(this.autoStart){
+                this.timer = this.triggerStart.defer(this.autoStart === true ? 1000 : this.autoStart, this);
             }
-            this.onPosition(ax, ay);
-            this.fireEvent('move', this, ax, ay);
         }
-        return this;
     },
 
-    /**
-     * Sets the page XY position of the component.  To set the left and top instead, use {@link #setPosition}.
-     * This method fires the {@link #move} event.
-     * @param {Number} x The new x position
-     * @param {Number} y The new y position
-     * @return {Ext.BoxComponent} this
-     */
-    setPagePosition : function(x, y){
-        if(x && typeof x[1] == 'number'){
-            y = x[1];
-            x = x[0];
-        }
-        this.pageX = x;
-        this.pageY = y;
-        if(!this.boxReady){
+    onMouseMove: function(e, target){
+        // HACK: IE hack to see if button was released outside of window. */
+        if(this.active && Ext.isIE && !e.browserEvent.button){
+            e.preventDefault();
+            this.onMouseUp(e);
             return;
         }
-        if(x === undefined || y === undefined){ // cannot translate undefined points
-            return;
+
+        e.preventDefault();
+        var xy = e.getXY(), s = this.startXY;
+        this.lastXY = xy;
+        if(!this.active){
+            if(Math.abs(s[0]-xy[0]) > this.tolerance || Math.abs(s[1]-xy[1]) > this.tolerance){
+                this.triggerStart();
+            }else{
+                return;
+            }
         }
-        var p = this.getPositionEl().translatePoints(x, y);
-        this.setPosition(p.left, p.top);
-        return this;
+        this.fireEvent('mousemove', this, e);
+        this.onDrag(e);
+        this.fireEvent('drag', this, e);
     },
 
-    // private
-    afterRender : function(){
-        Ext.BoxComponent.superclass.afterRender.call(this);
-        if(this.resizeEl){
-            this.resizeEl = Ext.get(this.resizeEl);
-        }
-        if(this.positionEl){
-            this.positionEl = Ext.get(this.positionEl);
+    onMouseUp: function(e) {
+        var doc = Ext.getDoc();
+        doc.un('mousemove', this.onMouseMove, this);
+        doc.un('mouseup', this.onMouseUp, this);
+        doc.un('selectstart', this.stopSelect, this);
+        e.preventDefault();
+        this.clearStart();
+        var wasActive = this.active;
+        this.active = false;
+        delete this.elRegion;
+        this.fireEvent('mouseup', this, e);
+        if(wasActive){
+            this.onEnd(e);
+            this.fireEvent('dragend', this, e);
         }
-        this.boxReady = true;
-        Ext.isDefined(this.autoScroll) && this.setAutoScroll(this.autoScroll);
-        this.setSize(this.width, this.height);
-        if(this.x || this.y){
-            this.setPosition(this.x, this.y);
-        }else if(this.pageX || this.pageY){
-            this.setPagePosition(this.pageX, this.pageY);
+    },
+
+    triggerStart: function(isTimer) {
+        this.clearStart();
+        this.active = true;
+        this.onStart(this.startXY);
+        this.fireEvent('dragstart', this, this.startXY);
+    },
+
+    clearStart : function() {
+        if(this.timer){
+            clearTimeout(this.timer);
+            delete this.timer;
         }
     },
 
+    stopSelect : function(e) {
+        e.stopEvent();
+        return false;
+    },
+    
+    /**
+     * Template method which should be overridden by each DragTracker instance. Called when the user first clicks and
+     * holds the mouse button down. Return false to disallow the drag
+     * @param {Ext.EventObject} e The event object
+     */
+    onBeforeStart : function(e) {
+
+    },
+
     /**
-     * Force the component's size to recalculate based on the underlying element's current height and width.
-     * @return {Ext.BoxComponent} this
+     * Template method which should be overridden by each DragTracker instance. Called when a drag operation starts
+     * (e.g. the user has moved the tracked element beyond the specified tolerance)
+     * @param {Array} xy x and y co-ordinates of the original location of the tracked element
      */
-    syncSize : function(){
-        delete this.lastSize;
-        this.setSize(this.autoWidth ? undefined : this.getResizeEl().getWidth(), this.autoHeight ? undefined : this.getResizeEl().getHeight());
-        return this;
+    onStart : function(xy) {
+
     },
 
-    /* // protected
-     * Called after the component is resized, this method is empty by default but can be implemented by any
-     * subclass that needs to perform custom logic after a resize occurs.
-     * @param {Number} adjWidth The box-adjusted width that was set
-     * @param {Number} adjHeight The box-adjusted height that was set
-     * @param {Number} rawWidth The width that was originally specified
-     * @param {Number} rawHeight The height that was originally specified
+    /**
+     * Template method which should be overridden by each DragTracker instance. Called whenever a drag has been detected.
+     * @param {Ext.EventObject} e The event object
      */
-    onResize : function(adjWidth, adjHeight, rawWidth, rawHeight){
+    onDrag : function(e) {
+
     },
 
-    /* // protected
-     * Called after the component is moved, this method is empty by default but can be implemented by any
-     * subclass that needs to perform custom logic after a move occurs.
-     * @param {Number} x The new x position
-     * @param {Number} y The new y position
+    /**
+     * Template method which should be overridden by each DragTracker instance. Called when a drag operation has been completed
+     * (e.g. the user clicked and held the mouse down, dragged the element and then released the mouse button)
+     * @param {Ext.EventObject} e The event object
      */
-    onPosition : function(x, y){
+    onEnd : function(e) {
 
     },
 
-    // private
-    adjustSize : function(w, h){
-        if(this.autoWidth){
-            w = 'auto';
-        }
-        if(this.autoHeight){
-            h = 'auto';
-        }
-        return {width : w, height: h};
+    /**
+     * Returns the drag target
+     * @return {Ext.Element} The element currently being tracked
+     */
+    getDragTarget : function(){
+        return this.dragTarget;
     },
 
-    // private
-    adjustPosition : function(x, y){
-        return {x : x, y: y};
-    }
-});
-Ext.reg('box', Ext.BoxComponent);
+    getDragCt : function(){
+        return this.el;
+    },
+
+    getXY : function(constrain){
+        return constrain ?
+               this.constrainModes[constrain].call(this, this.lastXY) : this.lastXY;
+    },
 
+    getOffset : function(constrain){
+        var xy = this.getXY(constrain);
+        var s = this.startXY;
+        return [s[0]-xy[0], s[1]-xy[1]];
+    },
 
-/**
- * @class Ext.Spacer
- * @extends Ext.BoxComponent
- * 
Used to provide a sizable space in a layout.
- * @constructor
- * @param {Object} config
+    constrainModes: {
+        'point' : function(xy){
+
+            if(!this.elRegion){
+                this.elRegion = this.getDragCt().getRegion();
+            }
+
+            var dr = this.dragRegion;
+
+            dr.left = xy[0];
+            dr.top = xy[1];
+            dr.right = xy[0];
+            dr.bottom = xy[1];
+
+            dr.constrainTo(this.elRegion);
+
+            return [dr.left, dr.top];
+        }
+    }
+});/**
+ * @class Ext.dd.ScrollManager
+ * Provides automatic scrolling of overflow regions in the page during drag operations.
+ * The ScrollManager configs will be used as the defaults for any scroll container registered with it,
+ * but you can also override most of the configs per scroll container by adding a 
+ * ddScrollConfig object to the target element that contains these properties: {@link #hthresh},
+ * {@link #vthresh}, {@link #increment} and {@link #frequency}.  Example usage:
+ * 

+var el = Ext.get('scroll-ct');
+el.ddScrollConfig = {
+    vthresh: 50,
+    hthresh: -1,
+    frequency: 100,
+    increment: 200
+};
+Ext.dd.ScrollManager.register(el);
+
+ * Note: This class uses "Point Mode" and is untested in "Intersect Mode".
+ * @singleton
  */
-Ext.Spacer = Ext.extend(Ext.BoxComponent, {
-    autoEl:'div'
-});
-Ext.reg('spacer', Ext.Spacer);/**
- * @class Ext.SplitBar
- * @extends Ext.util.Observable
- * Creates draggable splitter bar functionality from two elements (element to be dragged and element to be resized).
- * 


- * Usage:
- * 
-var split = new Ext.SplitBar("elementToDrag", "elementToSize",
-                   Ext.SplitBar.HORIZONTAL, Ext.SplitBar.LEFT);
-split.setAdapter(new Ext.SplitBar.AbsoluteLayoutAdapter("container"));
-split.minSize = 100;
-split.maxSize = 600;
-split.animate = true;
-split.on('moved', splitterMoved);
-
- * @constructor
- * Create a new SplitBar
- * @param {Mixed} dragElement The element to be dragged and act as the SplitBar.
- * @param {Mixed} resizingElement The element to be resized based on where the SplitBar element is dragged
- * @param {Number} orientation (optional) Either Ext.SplitBar.HORIZONTAL or Ext.SplitBar.VERTICAL. (Defaults to HORIZONTAL)
- * @param {Number} placement (optional) Either Ext.SplitBar.LEFT or Ext.SplitBar.RIGHT for horizontal or
-                        Ext.SplitBar.TOP or Ext.SplitBar.BOTTOM for vertical. (By default, this is determined automatically by the initial
-                        position of the SplitBar).
- */
-Ext.SplitBar = function(dragElement, resizingElement, orientation, placement, existingProxy){
-
-    /** @private */
-    this.el = Ext.get(dragElement, true);
-    this.el.dom.unselectable = "on";
-    /** @private */
-    this.resizingEl = Ext.get(resizingElement, true);
-
-    /**
-     * @private
-     * The orientation of the split. Either Ext.SplitBar.HORIZONTAL or Ext.SplitBar.VERTICAL. (Defaults to HORIZONTAL)
-     * Note: If this is changed after creating the SplitBar, the placement property must be manually updated
-     * @type Number
-     */
-    this.orientation = orientation || Ext.SplitBar.HORIZONTAL;
-
-    /**
-     * The increment, in pixels by which to move this SplitBar. When undefined, the SplitBar moves smoothly.
-     * @type Number
-     * @property tickSize
-     */
-    /**
-     * The minimum size of the resizing element. (Defaults to 0)
-     * @type Number
-     */
-    this.minSize = 0;
-
-    /**
-     * The maximum size of the resizing element. (Defaults to 2000)
-     * @type Number
-     */
-    this.maxSize = 2000;
-
-    /**
-     * Whether to animate the transition to the new size
-     * @type Boolean
-     */
-    this.animate = false;
-
-    /**
-     * Whether to create a transparent shim that overlays the page when dragging, enables dragging across iframes.
-     * @type Boolean
-     */
-    this.useShim = false;
-
-    /** @private */
-    this.shim = null;
-
-    if(!existingProxy){
-        /** @private */
-        this.proxy = Ext.SplitBar.createProxy(this.orientation);
-    }else{
-        this.proxy = Ext.get(existingProxy).dom;
-    }
-    /** @private */
-    this.dd = new Ext.dd.DDProxy(this.el.dom.id, "XSplitBars", {dragElId : this.proxy.id});
-
-    /** @private */
-    this.dd.b4StartDrag = this.onStartProxyDrag.createDelegate(this);
-
-    /** @private */
-    this.dd.endDrag = this.onEndProxyDrag.createDelegate(this);
-
-    /** @private */
-    this.dragSpecs = {};
-
-    /**
-     * @private The adapter to use to positon and resize elements
-     */
-    this.adapter = new Ext.SplitBar.BasicLayoutAdapter();
-    this.adapter.init(this);
-
-    if(this.orientation == Ext.SplitBar.HORIZONTAL){
-        /** @private */
-        this.placement = placement || (this.el.getX() > this.resizingEl.getX() ? Ext.SplitBar.LEFT : Ext.SplitBar.RIGHT);
-        this.el.addClass("x-splitbar-h");
-    }else{
-        /** @private */
-        this.placement = placement || (this.el.getY() > this.resizingEl.getY() ? Ext.SplitBar.TOP : Ext.SplitBar.BOTTOM);
-        this.el.addClass("x-splitbar-v");
-    }
-
-    this.addEvents(
-        /**
-         * @event resize
-         * Fires when the splitter is moved (alias for {@link #moved})
-         * @param {Ext.SplitBar} this
-         * @param {Number} newSize the new width or height
-         */
-        "resize",
-        /**
-         * @event moved
-         * Fires when the splitter is moved
-         * @param {Ext.SplitBar} this
-         * @param {Number} newSize the new width or height
-         */
-        "moved",
-        /**
-         * @event beforeresize
-         * Fires before the splitter is dragged
-         * @param {Ext.SplitBar} this
-         */
-        "beforeresize",
-
-        "beforeapply"
-    );
-
-    Ext.SplitBar.superclass.constructor.call(this);
-};
-
-Ext.extend(Ext.SplitBar, Ext.util.Observable, {
-    onStartProxyDrag : function(x, y){
-        this.fireEvent("beforeresize", this);
-        this.overlay =  Ext.DomHelper.append(document.body,  {cls: "x-drag-overlay", html: " "}, true);
-        this.overlay.unselectable();
-        this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
-        this.overlay.show();
-        Ext.get(this.proxy).setDisplayed("block");
-        var size = this.adapter.getElementSize(this);
-        this.activeMinSize = this.getMinimumSize();
-        this.activeMaxSize = this.getMaximumSize();
-        var c1 = size - this.activeMinSize;
-        var c2 = Math.max(this.activeMaxSize - size, 0);
-        if(this.orientation == Ext.SplitBar.HORIZONTAL){
-            this.dd.resetConstraints();
-            this.dd.setXConstraint(
-                this.placement == Ext.SplitBar.LEFT ? c1 : c2,
-                this.placement == Ext.SplitBar.LEFT ? c2 : c1,
-                this.tickSize
-            );
-            this.dd.setYConstraint(0, 0);
-        }else{
-            this.dd.resetConstraints();
-            this.dd.setXConstraint(0, 0);
-            this.dd.setYConstraint(
-                this.placement == Ext.SplitBar.TOP ? c1 : c2,
-                this.placement == Ext.SplitBar.TOP ? c2 : c1,
-                this.tickSize
-            );
-         }
-        this.dragSpecs.startSize = size;
-        this.dragSpecs.startPoint = [x, y];
-        Ext.dd.DDProxy.prototype.b4StartDrag.call(this.dd, x, y);
-    },
-
-    /**
-     * @private Called after the drag operation by the DDProxy
-     */
-    onEndProxyDrag : function(e){
-        Ext.get(this.proxy).setDisplayed(false);
-        var endPoint = Ext.lib.Event.getXY(e);
-        if(this.overlay){
-            Ext.destroy(this.overlay);
-            delete this.overlay;
-        }
-        var newSize;
-        if(this.orientation == Ext.SplitBar.HORIZONTAL){
-            newSize = this.dragSpecs.startSize +
-                (this.placement == Ext.SplitBar.LEFT ?
-                    endPoint[0] - this.dragSpecs.startPoint[0] :
-                    this.dragSpecs.startPoint[0] - endPoint[0]
-                );
-        }else{
-            newSize = this.dragSpecs.startSize +
-                (this.placement == Ext.SplitBar.TOP ?
-                    endPoint[1] - this.dragSpecs.startPoint[1] :
-                    this.dragSpecs.startPoint[1] - endPoint[1]
-                );
-        }
-        newSize = Math.min(Math.max(newSize, this.activeMinSize), this.activeMaxSize);
-        if(newSize != this.dragSpecs.startSize){
-            if(this.fireEvent('beforeapply', this, newSize) !== false){
-                this.adapter.setElementSize(this, newSize);
-                this.fireEvent("moved", this, newSize);
-                this.fireEvent("resize", this, newSize);
-            }
-        }
-    },
-
-    /**
-     * Get the adapter this SplitBar uses
-     * @return The adapter object
-     */
-    getAdapter : function(){
-        return this.adapter;
-    },
-
-    /**
-     * Set the adapter this SplitBar uses
-     * @param {Object} adapter A SplitBar adapter object
-     */
-    setAdapter : function(adapter){
-        this.adapter = adapter;
-        this.adapter.init(this);
-    },
-
-    /**
-     * Gets the minimum size for the resizing element
-     * @return {Number} The minimum size
-     */
-    getMinimumSize : function(){
-        return this.minSize;
-    },
-
-    /**
-     * Sets the minimum size for the resizing element
-     * @param {Number} minSize The minimum size
-     */
-    setMinimumSize : function(minSize){
-        this.minSize = minSize;
-    },
-
-    /**
-     * Gets the maximum size for the resizing element
-     * @return {Number} The maximum size
-     */
-    getMaximumSize : function(){
-        return this.maxSize;
-    },
-
-    /**
-     * Sets the maximum size for the resizing element
-     * @param {Number} maxSize The maximum size
-     */
-    setMaximumSize : function(maxSize){
-        this.maxSize = maxSize;
-    },
-
-    /**
-     * Sets the initialize size for the resizing element
-     * @param {Number} size The initial size
-     */
-    setCurrentSize : function(size){
-        var oldAnimate = this.animate;
-        this.animate = false;
-        this.adapter.setElementSize(this, size);
-        this.animate = oldAnimate;
-    },
-
-    /**
-     * Destroy this splitbar.
-     * @param {Boolean} removeEl True to remove the element
-     */
-    destroy : function(removeEl){
-        Ext.destroy(this.shim, Ext.get(this.proxy));
-        this.dd.unreg();
-        if(removeEl){
-            this.el.remove();
-        }
-        this.purgeListeners();
-    }
-});
-
-/**
- * @private static Create our own proxy element element. So it will be the same same size on all browsers, we won't use borders. Instead we use a background color.
- */
-Ext.SplitBar.createProxy = function(dir){
-    var proxy = new Ext.Element(document.createElement("div"));
-    document.body.appendChild(proxy.dom);
-    proxy.unselectable();
-    var cls = 'x-splitbar-proxy';
-    proxy.addClass(cls + ' ' + (dir == Ext.SplitBar.HORIZONTAL ? cls +'-h' : cls + '-v'));
-    return proxy.dom;
-};
-
-/**
- * @class Ext.SplitBar.BasicLayoutAdapter
- * Default Adapter. It assumes the splitter and resizing element are not positioned
- * elements and only gets/sets the width of the element. Generally used for table based layouts.
- */
-Ext.SplitBar.BasicLayoutAdapter = function(){
-};
-
-Ext.SplitBar.BasicLayoutAdapter.prototype = {
-    // do nothing for now
-    init : function(s){
-
-    },
-    /**
-     * Called before drag operations to get the current size of the resizing element.
-     * @param {Ext.SplitBar} s The SplitBar using this adapter
-     */
-     getElementSize : function(s){
-        if(s.orientation == Ext.SplitBar.HORIZONTAL){
-            return s.resizingEl.getWidth();
-        }else{
-            return s.resizingEl.getHeight();
-        }
-    },
-
-    /**
-     * Called after drag operations to set the size of the resizing element.
-     * @param {Ext.SplitBar} s The SplitBar using this adapter
-     * @param {Number} newSize The new size to set
-     * @param {Function} onComplete A function to be invoked when resizing is complete
-     */
-    setElementSize : function(s, newSize, onComplete){
-        if(s.orientation == Ext.SplitBar.HORIZONTAL){
-            if(!s.animate){
-                s.resizingEl.setWidth(newSize);
-                if(onComplete){
-                    onComplete(s, newSize);
-                }
-            }else{
-                s.resizingEl.setWidth(newSize, true, .1, onComplete, 'easeOut');
-            }
-        }else{
-
-            if(!s.animate){
-                s.resizingEl.setHeight(newSize);
-                if(onComplete){
-                    onComplete(s, newSize);
-                }
-            }else{
-                s.resizingEl.setHeight(newSize, true, .1, onComplete, 'easeOut');
-            }
-        }
-    }
-};
-
-/**
- *@class Ext.SplitBar.AbsoluteLayoutAdapter
- * @extends Ext.SplitBar.BasicLayoutAdapter
- * Adapter that  moves the splitter element to align with the resized sizing element.
- * Used with an absolute positioned SplitBar.
- * @param {Mixed} container The container that wraps around the absolute positioned content. If it's
- * document.body, make sure you assign an id to the body element.
- */
-Ext.SplitBar.AbsoluteLayoutAdapter = function(container){
-    this.basic = new Ext.SplitBar.BasicLayoutAdapter();
-    this.container = Ext.get(container);
-};
-
-Ext.SplitBar.AbsoluteLayoutAdapter.prototype = {
-    init : function(s){
-        this.basic.init(s);
-    },
-
-    getElementSize : function(s){
-        return this.basic.getElementSize(s);
-    },
-
-    setElementSize : function(s, newSize, onComplete){
-        this.basic.setElementSize(s, newSize, this.moveSplitter.createDelegate(this, [s]));
-    },
-
-    moveSplitter : function(s){
-        var yes = Ext.SplitBar;
-        switch(s.placement){
-            case yes.LEFT:
-                s.el.setX(s.resizingEl.getRight());
-                break;
-            case yes.RIGHT:
-                s.el.setStyle("right", (this.container.getWidth() - s.resizingEl.getLeft()) + "px");
-                break;
-            case yes.TOP:
-                s.el.setY(s.resizingEl.getBottom());
-                break;
-            case yes.BOTTOM:
-                s.el.setY(s.resizingEl.getTop() - s.el.getHeight());
-                break;
-        }
-    }
-};
-
-/**
- * Orientation constant - Create a vertical SplitBar
- * @static
- * @type Number
- */
-Ext.SplitBar.VERTICAL = 1;
-
-/**
- * Orientation constant - Create a horizontal SplitBar
- * @static
- * @type Number
- */
-Ext.SplitBar.HORIZONTAL = 2;
-
-/**
- * Placement constant - The resizing element is to the left of the splitter element
- * @static
- * @type Number
- */
-Ext.SplitBar.LEFT = 1;
-
-/**
- * Placement constant - The resizing element is to the right of the splitter element
- * @static
- * @type Number
- */
-Ext.SplitBar.RIGHT = 2;
-
-/**
- * Placement constant - The resizing element is positioned above the splitter element
- * @static
- * @type Number
- */
-Ext.SplitBar.TOP = 3;
-
-/**
- * Placement constant - The resizing element is positioned under splitter element
- * @static
- * @type Number
- */
-Ext.SplitBar.BOTTOM = 4;
-/**
- * @class Ext.Container
- * @extends Ext.BoxComponent
- * Base class for any {@link Ext.BoxComponent} that may contain other Components. Containers handle the
- * basic behavior of containing items, namely adding, inserting and removing items.
- *
- * The most commonly used Container classes are {@link Ext.Panel}, {@link Ext.Window} and {@link Ext.TabPanel}.
- * If you do not need the capabilities offered by the aforementioned classes you can create a lightweight
- * Container to be encapsulated by an HTML element to your specifications by using the
- * {@link Ext.Component#autoEl autoEl} config option. This is a useful technique when creating
- * embedded {@link Ext.layout.ColumnLayout column} layouts inside {@link Ext.form.FormPanel FormPanels}
- * for example.
- *
- * The code below illustrates both how to explicitly create a Container, and how to implicitly
- * create one using the 'container' xtype:

-// explicitly create a Container
-var embeddedColumns = new Ext.Container({
-    autoEl: 'div',  // This is the default
-    layout: 'column',
-    defaults: {
-        // implicitly create Container by specifying xtype
-        xtype: 'container',
-        autoEl: 'div', // This is the default.
-        layout: 'form',
-        columnWidth: 0.5,
-        style: {
-            padding: '10px'
+Ext.dd.ScrollManager = function(){
+    var ddm = Ext.dd.DragDropMgr;
+    var els = {};
+    var dragEl = null;
+    var proc = {};
+    
+    var onStop = function(e){
+        dragEl = null;
+        clearProc();
+    };
+    
+    var triggerRefresh = function(){
+        if(ddm.dragCurrent){
+             ddm.refreshCache(ddm.dragCurrent.groups);
         }
-    },
-//  The two items below will be Ext.Containers, each encapsulated by a <DIV> element.
-    items: [{
-        items: {
-            xtype: 'datefield',
-            name: 'startDate',
-            fieldLabel: 'Start date'
+    };
+    
+    var doScroll = function(){
+        if(ddm.dragCurrent){
+            var dds = Ext.dd.ScrollManager;
+            var inc = proc.el.ddScrollConfig ?
+                      proc.el.ddScrollConfig.increment : dds.increment;
+            if(!dds.animate){
+                if(proc.el.scroll(proc.dir, inc)){
+                    triggerRefresh();
+                }
+            }else{
+                proc.el.scroll(proc.dir, inc, true, dds.animDuration, triggerRefresh);
+            }
         }
-    }, {
-        items: {
-            xtype: 'datefield',
-            name: 'endDate',
-            fieldLabel: 'End date'
+    };
+    
+    var clearProc = function(){
+        if(proc.id){
+            clearInterval(proc.id);
         }
-    }]
-});

- *
- * Layout
- * Container classes delegate the rendering of child Components to a layout
- * manager class which must be configured into the Container using the
- * {@link #layout} configuration property.
- * When either specifying child {@link #items} of a Container,
- * or dynamically {@link #add adding} Components to a Container, remember to
- * consider how you wish the Container to arrange those child elements, and
- * whether those child elements need to be sized using one of Ext's built-in
- * {@link #layout} schemes. By default, Containers use the
- * {@link Ext.layout.ContainerLayout ContainerLayout} scheme which only
- * renders child components, appending them one after the other inside the
- * Container, and does not apply any sizing at all.
- * A common mistake is when a developer neglects to specify a
- * {@link #layout} (e.g. widgets like GridPanels or
- * TreePanels are added to Containers for which no {@link #layout}
- * has been specified). If a Container is left to use the default
- * {@link Ext.layout.ContainerLayout ContainerLayout} scheme, none of its
- * child components will be resized, or changed in any way when the Container
- * is resized.
- * Certain layout managers allow dynamic addition of child components.
- * Those that do include {@link Ext.layout.CardLayout},
- * {@link Ext.layout.AnchorLayout}, {@link Ext.layout.FormLayout}, and
- * {@link Ext.layout.TableLayout}. For example:

-//  Create the GridPanel.
-var myNewGrid = new Ext.grid.GridPanel({
-    store: myStore,
-    columns: myColumnModel,
-    title: 'Results', // the title becomes the title of the tab
-});
+        proc.id = 0;
+        proc.el = null;
+        proc.dir = "";
+    };
+    
+    var startProc = function(el, dir){
+        clearProc();
+        proc.el = el;
+        proc.dir = dir;
+        var freq = (el.ddScrollConfig && el.ddScrollConfig.frequency) ? 
+                el.ddScrollConfig.frequency : Ext.dd.ScrollManager.frequency;
+        proc.id = setInterval(doScroll, freq);
+    };
+    
+    var onFire = function(e, isDrop){
+        if(isDrop || !ddm.dragCurrent){ return; }
+        var dds = Ext.dd.ScrollManager;
+        if(!dragEl || dragEl != ddm.dragCurrent){
+            dragEl = ddm.dragCurrent;
+            // refresh regions on drag start
+            dds.refreshCache();
+        }
+        
+        var xy = Ext.lib.Event.getXY(e);
+        var pt = new Ext.lib.Point(xy[0], xy[1]);
+        for(var id in els){
+            var el = els[id], r = el._region;
+            var c = el.ddScrollConfig ? el.ddScrollConfig : dds;
+            if(r && r.contains(pt) && el.isScrollable()){
+                if(r.bottom - pt.y <= c.vthresh){
+                    if(proc.el != el){
+                        startProc(el, "down");
+                    }
+                    return;
+                }else if(r.right - pt.x <= c.hthresh){
+                    if(proc.el != el){
+                        startProc(el, "left");
+                    }
+                    return;
+                }else if(pt.y - r.top <= c.vthresh){
+                    if(proc.el != el){
+                        startProc(el, "up");
+                    }
+                    return;
+                }else if(pt.x - r.left <= c.hthresh){
+                    if(proc.el != el){
+                        startProc(el, "right");
+                    }
+                    return;
+                }
+            }
+        }
+        clearProc();
+    };
+    
+    ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm);
+    ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm);
+    
+    return {
+        /**
+         * Registers new overflow element(s) to auto scroll
+         * @param {Mixed/Array} el The id of or the element to be scrolled or an array of either
+         */
+        register : function(el){
+            if(Ext.isArray(el)){
+                for(var i = 0, len = el.length; i < len; i++) {
+                	this.register(el[i]);
+                }
+            }else{
+                el = Ext.get(el);
+                els[el.id] = el;
+            }
+        },
+        
+        /**
+         * Unregisters overflow element(s) so they are no longer scrolled
+         * @param {Mixed/Array} el The id of or the element to be removed or an array of either
+         */
+        unregister : function(el){
+            if(Ext.isArray(el)){
+                for(var i = 0, len = el.length; i < len; i++) {
+                	this.unregister(el[i]);
+                }
+            }else{
+                el = Ext.get(el);
+                delete els[el.id];
+            }
+        },
+        
+        /**
+         * The number of pixels from the top or bottom edge of a container the pointer needs to be to
+         * trigger scrolling (defaults to 25)
+         * @type Number
+         */
+        vthresh : 25,
+        /**
+         * The number of pixels from the right or left edge of a container the pointer needs to be to
+         * trigger scrolling (defaults to 25)
+         * @type Number
+         */
+        hthresh : 25,
 
-myTabPanel.add(myNewGrid); // {@link Ext.TabPanel} implicitly uses {@link Ext.layout.CardLayout CardLayout}
-myTabPanel.{@link Ext.TabPanel#setActiveTab setActiveTab}(myNewGrid);
- * 

- * The example above adds a newly created GridPanel to a TabPanel. Note that
- * a TabPanel uses {@link Ext.layout.CardLayout} as its layout manager which
- * means all its child items are sized to {@link Ext.layout.FitLayout fit}
- * exactly into its client area.
- * 
Overnesting is a common problem.
- * An example of overnesting occurs when a GridPanel is added to a TabPanel
- * by wrapping the GridPanel inside a wrapping Panel (that has no
- * {@link #layout} specified) and then add that wrapping Panel
- * to the TabPanel. The point to realize is that a GridPanel is a
- * Component which can be added directly to a Container. If the wrapping Panel
- * has no {@link #layout} configuration, then the overnested
- * GridPanel will not be sized as expected.

- *
- * 
Adding via remote configuration
- *
- * A server side script can be used to add Components which are generated dynamically on the server.
- * An example of adding a GridPanel to a TabPanel where the GridPanel is generated by the server
- * based on certain parameters:
- * 

-// execute an Ajax request to invoke server side script:
-Ext.Ajax.request({
-    url: 'gen-invoice-grid.php',
-    // send additional parameters to instruct server script
-    params: {
-        startDate: Ext.getCmp('start-date').getValue(),
-        endDate: Ext.getCmp('end-date').getValue()
-    },
-    // process the response object to add it to the TabPanel:
-    success: function(xhr) {
-        var newComponent = eval(xhr.responseText); // see discussion below
-        myTabPanel.add(newComponent); // add the component to the TabPanel
-        myTabPanel.setActiveTab(newComponent);
-    },
-    failure: function() {
-        Ext.Msg.alert("Grid create failed", "Server communication failure");
-    }
-});
-
- * The server script needs to return an executable Javascript statement which, when processed
- * using eval(), will return either a config object with an {@link Ext.Component#xtype xtype},
- * or an instantiated Component. The server might return this for example:

-(function() {
-    function formatDate(value){
-        return value ? value.dateFormat('M d, Y') : '';
+        /**
+         * The number of pixels to scroll in each scroll increment (defaults to 50)
+         * @type Number
+         */
+        increment : 100,
+        
+        /**
+         * The frequency of scrolls in milliseconds (defaults to 500)
+         * @type Number
+         */
+        frequency : 500,
+        
+        /**
+         * True to animate the scroll (defaults to true)
+         * @type Boolean
+         */
+        animate: true,
+        
+        /**
+         * The animation duration in seconds - 
+         * MUST BE less than Ext.dd.ScrollManager.frequency! (defaults to .4)
+         * @type Number
+         */
+        animDuration: .4,
+        
+        /**
+         * Manually trigger a cache refresh.
+         */
+        refreshCache : function(){
+            for(var id in els){
+                if(typeof els[id] == 'object'){ // for people extending the object prototype
+                    els[id]._region = els[id].getRegion();
+                }
+            }
+        }
     };
+}();/**
+ * @class Ext.dd.Registry
+ * Provides easy access to all drag drop components that are registered on a page.  Items can be retrieved either
+ * directly by DOM node id, or by passing in the drag drop event that occurred and looking up the event target.
+ * @singleton
+ */
+Ext.dd.Registry = function(){
+    var elements = {}; 
+    var handles = {}; 
+    var autoIdSeed = 0;
 
-    var store = new Ext.data.Store({
-        url: 'get-invoice-data.php',
-        baseParams: {
-            startDate: '01/01/2008',
-            endDate: '01/31/2008'
+    var getId = function(el, autogen){
+        if(typeof el == "string"){
+            return el;
+        }
+        var id = el.id;
+        if(!id && autogen !== false){
+            id = "extdd-" + (++autoIdSeed);
+            el.id = id;
+        }
+        return id;
+    };
+    
+    return {
+    /**
+     * Resgister a drag drop element
+     * @param {String/HTMLElement} element The id or DOM node to register
+     * @param {Object} data (optional) An custom data object that will be passed between the elements that are involved
+     * in drag drop operations.  You can populate this object with any arbitrary properties that your own code
+     * knows how to interpret, plus there are some specific properties known to the Registry that should be
+     * populated in the data object (if applicable):
+     * +Value      Description

+---------  ------------------------------------------

+handles    Array of DOM nodes that trigger dragging

+           for the element being registered

+isHandle   True if the element passed in triggers

+           dragging itself, else false
+
+     */
+        register : function(el, data){
+            data = data || {};
+            if(typeof el == "string"){
+                el = document.getElementById(el);
+            }
+            data.ddel = el;
+            elements[getId(el)] = data;
+            if(data.isHandle !== false){
+                handles[data.ddel.id] = data;
+            }
+            if(data.handles){
+                var hs = data.handles;
+                for(var i = 0, len = hs.length; i < len; i++){
+                	handles[getId(hs[i])] = data;
+                }
+            }
         },
-        reader: new Ext.data.JsonReader({
-            record: 'transaction',
-            idProperty: 'id',
-            totalRecords: 'total'
-        }, [
-           'customer',
-           'invNo',
-           {name: 'date', type: 'date', dateFormat: 'm/d/Y'},
-           {name: 'value', type: 'float'}
-        ])
-    });
 
-    var grid = new Ext.grid.GridPanel({
-        title: 'Invoice Report',
-        bbar: new Ext.PagingToolbar(store),
-        store: store,
-        columns: [
-            {header: "Customer", width: 250, dataIndex: 'customer', sortable: true},
-            {header: "Invoice Number", width: 120, dataIndex: 'invNo', sortable: true},
-            {header: "Invoice Date", width: 100, dataIndex: 'date', renderer: formatDate, sortable: true},
-            {header: "Value", width: 120, dataIndex: 'value', renderer: 'usMoney', sortable: true}
-        ],
-    });
-    store.load();
-    return grid;  // return instantiated component
-})();
-
- * When the above code fragment is passed through the eval function in the success handler
- * of the Ajax request, the code is executed by the Javascript processor, and the anonymous function
- * runs, and returns the instantiated grid component.
- * Note: since the code above is generated by a server script, the baseParams for
- * the Store, the metadata to allow generation of the Record layout, and the ColumnModel
- * can all be generated into the code since these are all known on the server.
- *
- * @xtype container
- */
-Ext.Container = Ext.extend(Ext.BoxComponent, {
     /**
-     * @cfg {Boolean} monitorResize
-     * True to automatically monitor window resize events to handle anything that is sensitive to the current size
-     * of the viewport.  This value is typically managed by the chosen {@link #layout} and should not need
-     * to be set manually.
+     * Unregister a drag drop element
+     * @param {String/HTMLElement} element The id or DOM node to unregister
      */
+        unregister : function(el){
+            var id = getId(el, false);
+            var data = elements[id];
+            if(data){
+                delete elements[id];
+                if(data.handles){
+                    var hs = data.handles;
+                    for(var i = 0, len = hs.length; i < len; i++){
+                    	delete handles[getId(hs[i], false)];
+                    }
+                }
+            }
+        },
+
     /**
-     * @cfg {String/Object} layout
-     * *Important: In order for child items to be correctly sized and
-     * positioned, typically a layout manager must be specified through
-     * the layout configuration option.
-     * 
The sizing and positioning of child {@link items} is the responsibility of
-     * the Container's layout manager which creates and manages the type of layout
-     * you have in mind.  For example:

-new Ext.Window({
-    width:300, height: 300,
-    layout: 'fit', // explicitly set layout manager: override the default (layout:'auto')
-    items: [{
-        title: 'Panel inside a Window'
-    }]
-}).show();
-     * 
-     * If the {@link #layout} configuration is not explicitly specified for
-     * a general purpose container (e.g. Container or Panel) the
-     * {@link Ext.layout.ContainerLayout default layout manager} will be used
-     * which does nothing but render child components sequentially into the
-     * Container (no sizing or positioning will be performed in this situation).
-     * Some container classes implicitly specify a default layout
-     * (e.g. FormPanel specifies layout:'form'). Other specific
-     * purpose classes internally specify/manage their internal layout (e.g.
-     * GridPanel, TabPanel, TreePanel, Toolbar, Menu, etc.).
-     * 
layout may be specified as either as an Object or
-     * as a String:

-     *
-     * Specify as an Object
-     * 
-     * Example usage:
-
-layout: {
-    type: 'vbox',
-    padding: '5',
-    align: 'left'
-}
-
-     *
-     * type
-     * 
The layout type to be used for this container.  If not specified,
-     * a default {@link Ext.layout.ContainerLayout} will be created and used.
-     * 
Valid layout type values are:
-     * 
-     * {@link Ext.layout.AbsoluteLayout absolute}
-     * {@link Ext.layout.AccordionLayout accordion}
-     * {@link Ext.layout.AnchorLayout anchor}
-     * {@link Ext.layout.ContainerLayout auto}     Default
-     * {@link Ext.layout.BorderLayout border}
-     * {@link Ext.layout.CardLayout card}
-     * {@link Ext.layout.ColumnLayout column}
-     * {@link Ext.layout.FitLayout fit}
-     * {@link Ext.layout.FormLayout form}
-     * {@link Ext.layout.HBoxLayout hbox}
-     * {@link Ext.layout.MenuLayout menu}
-     * {@link Ext.layout.TableLayout table}
-     * {@link Ext.layout.ToolbarLayout toolbar}
-     * {@link Ext.layout.VBoxLayout vbox}
-     * 
-     *
-     * Layout specific configuration properties
-     * 
Additional layout specific configuration properties may also be
-     * specified. For complete details regarding the valid config options for
-     * each layout type, see the layout class corresponding to the type
-     * specified.
-     *
-     * 
-     *
-     * Specify as a String
-     * 
-     * Example usage:
-
-layout: 'vbox',
-layoutConfig: {
-    padding: '5',
-    align: 'left'
-}
-
-     * layout
-     * 
The layout type to be used for this container (see list
-     * of valid layout type values above).


-     * {@link #layoutConfig}
-     * 
Additional layout specific configuration properties. For complete
-     * details regarding the valid config options for each layout type, see the
-     * layout class corresponding to the layout specified.
-     * 
+     * Returns the handle registered for a DOM Node by id
+     * @param {String/HTMLElement} id The DOM node or id to look up
+     * @return {Object} handle The custom handle data
      */
+        getHandle : function(id){
+            if(typeof id != "string"){ // must be element?
+                id = id.id;
+            }
+            return handles[id];
+        },
+
     /**
-     * @cfg {Object} layoutConfig
-     * This is a config object containing properties specific to the chosen
-     * {@link #layout} if {@link #layout}
-     * has been specified as a string.
+     * Returns the handle that is registered for the DOM node that is the target of the event
+     * @param {Event} e The event
+     * @return {Object} handle The custom handle data
      */
+        getHandleFromEvent : function(e){
+            var t = Ext.lib.Event.getTarget(e);
+            return t ? handles[t.id] : null;
+        },
+
     /**
-     * @cfg {Boolean/Number} bufferResize
-     * When set to true (50 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer
-     * the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers
-     * with a large quantity of sub-components for which frequent layout calls would be expensive. Defaults to 50.
+     * Returns a custom data object that is registered for a DOM node by id
+     * @param {String/HTMLElement} id The DOM node or id to look up
+     * @return {Object} data The custom data
      */
-    // Deprecated - will be removed in 3.2.x
-    bufferResize: 50,
+        getTarget : function(id){
+            if(typeof id != "string"){ // must be element?
+                id = id.id;
+            }
+            return elements[id];
+        },
 
     /**
-     * @cfg {String/Number} activeItem
-     * A string component id or the numeric index of the component that should be initially activated within the
-     * container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first
-     * item in the container's collection).  activeItem only applies to layout styles that can display
-     * items one at a time (like {@link Ext.layout.AccordionLayout}, {@link Ext.layout.CardLayout} and
-     * {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
+     * Returns a custom data object that is registered for the DOM node that is the target of the event
+     * @param {Event} e The event
+     * @return {Object} data The custom data
      */
+        getTargetFromEvent : function(e){
+            var t = Ext.lib.Event.getTarget(e);
+            return t ? elements[t.id] || handles[t.id] : null;
+        }
+    };
+}();/**
+ * @class Ext.dd.StatusProxy
+ * A specialized drag proxy that supports a drop status icon, {@link Ext.Layer} styles and auto-repair.  This is the
+ * default drag proxy used by all Ext.dd components.
+ * @constructor
+ * @param {Object} config
+ */
+Ext.dd.StatusProxy = function(config){
+    Ext.apply(this, config);
+    this.id = this.id || Ext.id();
+    this.el = new Ext.Layer({
+        dh: {
+            id: this.id, tag: "div", cls: "x-dd-drag-proxy "+this.dropNotAllowed, children: [
+                {tag: "div", cls: "x-dd-drop-icon"},
+                {tag: "div", cls: "x-dd-drag-ghost"}
+            ]
+        }, 
+        shadow: !config || config.shadow !== false
+    });
+    this.ghost = Ext.get(this.el.dom.childNodes[1]);
+    this.dropStatus = this.dropNotAllowed;
+};
+
+Ext.dd.StatusProxy.prototype = {
     /**
-     * @cfg {Object/Array} items
-     * ** IMPORTANT: be sure to {@link #layout specify a layout} if needed ! **
-     * A single item, or an array of child Components to be added to this container,
-     * for example:
-     * 
-// specifying a single item
-items: {...},
-layout: 'fit',    // specify a layout!
+     * @cfg {String} dropAllowed
+     * The CSS class to apply to the status element when drop is allowed (defaults to "x-dd-drop-ok").
+     */
+    dropAllowed : "x-dd-drop-ok",
+    /**
+     * @cfg {String} dropNotAllowed
+     * The CSS class to apply to the status element when drop is not allowed (defaults to "x-dd-drop-nodrop").
+     */
+    dropNotAllowed : "x-dd-drop-nodrop",
 
-// specifying multiple items
-items: [{...}, {...}],
-layout: 'anchor', // specify a layout!
-     * 
-     * Each item may be:
-     * 
-     * any type of object based on {@link Ext.Component}
-     * a fully instanciated object or
-     * an object literal that:
-     * 
-     * has a specified {@link Ext.Component#xtype xtype}
-     * the {@link Ext.Component#xtype} specified is associated with the Component
-     * desired and should be chosen from one of the available xtypes as listed
-     * in {@link Ext.Component}.
-     * If an {@link Ext.Component#xtype xtype} is not explicitly
-     * specified, the {@link #defaultType} for that Container is used.
-     * will be "lazily instanciated", avoiding the overhead of constructing a fully
-     * instanciated Component object
-     * 
-     * Notes:
-     * 
-     * Ext uses lazy rendering. Child Components will only be rendered
-     * should it become necessary. Items are automatically laid out when they are first
-     * shown (no sizing is done while hidden), or in response to a {@link #doLayout} call.
-     * Do not specify {@link Ext.Panel#contentEl contentEl}/
-     * {@link Ext.Panel#html html} with items.
-     * 
+    /**
+     * Updates the proxy's visual element to indicate the status of whether or not drop is allowed
+     * over the current target element.
+     * @param {String} cssClass The css class for the new drop status indicator image
      */
+    setStatus : function(cssClass){
+        cssClass = cssClass || this.dropNotAllowed;
+        if(this.dropStatus != cssClass){
+            this.el.replaceClass(this.dropStatus, cssClass);
+            this.dropStatus = cssClass;
+        }
+    },
+
     /**
-     * @cfg {Object|Function} defaults
-     * This option is a means of applying default settings to all added items whether added through the {@link #items}
-     * config or via the {@link #add} or {@link #insert} methods.
-     * If an added item is a config object, and not an instantiated Component, then the default properties are
-     * unconditionally applied. If the added item is an instantiated Component, then the default properties are
-     * applied conditionally so as not to override existing properties in the item.
-     * If the defaults option is specified as a function, then the function will be called using this Container as the
-     * scope (this reference) and passing the added item as the first parameter. Any resulting object
-     * from that call is then applied to the item as default properties.
-     * For example, to automatically apply padding to the body of each of a set of
-     * contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.
-     * Usage:

-defaults: {               // defaults are applied to items, not the container
-    autoScroll:true
-},
-items: [
-    {
-        xtype: 'panel',   // defaults do not have precedence over
-        id: 'panel1',     // options in config objects, so the defaults
-        autoScroll: false // will not be applied here, panel1 will be autoScroll:false
+     * Resets the status indicator to the default dropNotAllowed value
+     * @param {Boolean} clearGhost True to also remove all content from the ghost, false to preserve it
+     */
+    reset : function(clearGhost){
+        this.el.dom.className = "x-dd-drag-proxy " + this.dropNotAllowed;
+        this.dropStatus = this.dropNotAllowed;
+        if(clearGhost){
+            this.ghost.update("");
+        }
     },
-    new Ext.Panel({       // defaults do have precedence over options
-        id: 'panel2',     // options in components, so the defaults
-        autoScroll: false // will be applied here, panel2 will be autoScroll:true.
-    })
-]
-     * 
+
+    /**
+     * Updates the contents of the ghost element
+     * @param {String/HTMLElement} html The html that will replace the current innerHTML of the ghost element, or a
+     * DOM node to append as the child of the ghost element (in which case the innerHTML will be cleared first).
      */
+    update : function(html){
+        if(typeof html == "string"){
+            this.ghost.update(html);
+        }else{
+            this.ghost.update("");
+            html.style.margin = "0";
+            this.ghost.dom.appendChild(html);
+        }
+        var el = this.ghost.dom.firstChild; 
+        if(el){
+            Ext.fly(el).setStyle('float', 'none');
+        }
+    },
 
+    /**
+     * Returns the underlying proxy {@link Ext.Layer}
+     * @return {Ext.Layer} el
+    */
+    getEl : function(){
+        return this.el;
+    },
 
-    /** @cfg {Boolean} autoDestroy
-     * If true the container will automatically destroy any contained component that is removed from it, else
-     * destruction must be handled manually (defaults to true).
+    /**
+     * Returns the ghost element
+     * @return {Ext.Element} el
      */
-    autoDestroy : true,
+    getGhost : function(){
+        return this.ghost;
+    },
 
-    /** @cfg {Boolean} forceLayout
-     * If true the container will force a layout initially even if hidden or collapsed. This option
-     * is useful for forcing forms to render in collapsed or hidden containers. (defaults to false).
+    /**
+     * Hides the proxy
+     * @param {Boolean} clear True to reset the status and clear the ghost contents, false to preserve them
      */
-    forceLayout: false,
+    hide : function(clear){
+        this.el.hide();
+        if(clear){
+            this.reset(true);
+        }
+    },
 
-    /** @cfg {Boolean} hideBorders
-     * True to hide the borders of each contained component, false to defer to the component's existing
-     * border settings (defaults to false).
+    /**
+     * Stops the repair animation if it's currently running
      */
-    /** @cfg {String} defaultType
-     * The default {@link Ext.Component xtype} of child Components to create in this Container when
-     * a child item is specified as a raw configuration object, rather than as an instantiated Component.
-     * Defaults to 'panel', except {@link Ext.menu.Menu} which defaults to 'menuitem',
-     * and {@link Ext.Toolbar} and {@link Ext.ButtonGroup} which default to 'button'.
+    stop : function(){
+        if(this.anim && this.anim.isAnimated && this.anim.isAnimated()){
+            this.anim.stop();
+        }
+    },
+
+    /**
+     * Displays this proxy
      */
-    defaultType : 'panel',
+    show : function(){
+        this.el.show();
+    },
 
-    /** @cfg {String} resizeEvent
-     * The event to listen to for resizing in layouts. Defaults to 'resize'.
+    /**
+     * Force the Layer to sync its shadow and shim positions to the element
      */
-    resizeEvent: 'resize',
+    sync : function(){
+        this.el.sync();
+    },
 
     /**
-     * @cfg {Array} bubbleEvents
-     * An array of events that, when fired, should be bubbled to any parent container.
-     * See {@link Ext.util.Observable#enableBubble}.
-     * Defaults to ['add', 'remove'].
+     * Causes the proxy to return to its position of origin via an animation.  Should be called after an
+     * invalid drop operation by the item being dragged.
+     * @param {Array} xy The XY position of the element ([x, y])
+     * @param {Function} callback The function to call after the repair is complete.
+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window.
      */
-    bubbleEvents: ['add', 'remove'],
+    repair : function(xy, callback, scope){
+        this.callback = callback;
+        this.scope = scope;
+        if(xy && this.animRepair !== false){
+            this.el.addClass("x-dd-drag-repair");
+            this.el.hideUnders(true);
+            this.anim = this.el.shift({
+                duration: this.repairDuration || .5,
+                easing: 'easeOut',
+                xy: xy,
+                stopFx: true,
+                callback: this.afterRepair,
+                scope: this
+            });
+        }else{
+            this.afterRepair();
+        }
+    },
 
     // private
-    initComponent : function(){
-        Ext.Container.superclass.initComponent.call(this);
+    afterRepair : function(){
+        this.hide(true);
+        if(typeof this.callback == "function"){
+            this.callback.call(this.scope || this);
+        }
+        this.callback = null;
+        this.scope = null;
+    },
+    
+    destroy: function(){
+        Ext.destroy(this.ghost, this.el);    
+    }
+};/**
+ * @class Ext.dd.DragSource
+ * @extends Ext.dd.DDProxy
+ * A simple class that provides the basic implementation needed to make any element draggable.
+ * @constructor
+ * @param {Mixed} el The container element
+ * @param {Object} config
+ */
+Ext.dd.DragSource = function(el, config){
+    this.el = Ext.get(el);
+    if(!this.dragData){
+        this.dragData = {};
+    }
+    
+    Ext.apply(this, config);
+    
+    if(!this.proxy){
+        this.proxy = new Ext.dd.StatusProxy();
+    }
+    Ext.dd.DragSource.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, 
+          {dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true});
+    
+    this.dragging = false;
+};
 
-        this.addEvents(
-            /**
-             * @event afterlayout
-             * Fires when the components in this container are arranged by the associated layout manager.
-             * @param {Ext.Container} this
-             * @param {ContainerLayout} layout The ContainerLayout implementation for this container
-             */
-            'afterlayout',
-            /**
-             * @event beforeadd
-             * Fires before any {@link Ext.Component} is added or inserted into the container.
-             * A handler can return false to cancel the add.
-             * @param {Ext.Container} this
-             * @param {Ext.Component} component The component being added
-             * @param {Number} index The index at which the component will be added to the container's items collection
-             */
-            'beforeadd',
-            /**
-             * @event beforeremove
-             * Fires before any {@link Ext.Component} is removed from the container.  A handler can return
-             * false to cancel the remove.
-             * @param {Ext.Container} this
-             * @param {Ext.Component} component The component being removed
-             */
-            'beforeremove',
-            /**
-             * @event add
-             * @bubbles
-             * Fires after any {@link Ext.Component} is added or inserted into the container.
-             * @param {Ext.Container} this
-             * @param {Ext.Component} component The component that was added
-             * @param {Number} index The index at which the component was added to the container's items collection
-             */
-            'add',
-            /**
-             * @event remove
-             * @bubbles
-             * Fires after any {@link Ext.Component} is removed from the container.
-             * @param {Ext.Container} this
-             * @param {Ext.Component} component The component that was removed
-             */
-            'remove'
-        );
+Ext.extend(Ext.dd.DragSource, Ext.dd.DDProxy, {
+    /**
+     * @cfg {String} ddGroup
+     * A named drag drop group to which this object belongs.  If a group is specified, then this object will only
+     * interact with other drag drop objects in the same group (defaults to undefined).
+     */
+    /**
+     * @cfg {String} dropAllowed
+     * The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
+     */
+    dropAllowed : "x-dd-drop-ok",
+    /**
+     * @cfg {String} dropNotAllowed
+     * The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
+     */
+    dropNotAllowed : "x-dd-drop-nodrop",
 
-        this.enableBubble(this.bubbleEvents);
+    /**
+     * Returns the data object associated with this drag source
+     * @return {Object} data An object containing arbitrary data
+     */
+    getDragData : function(e){
+        return this.dragData;
+    },
 
-        /**
-         * The collection of components in this container as a {@link Ext.util.MixedCollection}
-         * @type MixedCollection
-         * @property items
-         */
-        var items = this.items;
-        if(items){
-            delete this.items;
-            this.add(items);
+    // private
+    onDragEnter : function(e, id){
+        var target = Ext.dd.DragDropMgr.getDDById(id);
+        this.cachedTarget = target;
+        if(this.beforeDragEnter(target, e, id) !== false){
+            if(target.isNotifyTarget){
+                var status = target.notifyEnter(this, e, this.dragData);
+                this.proxy.setStatus(status);
+            }else{
+                this.proxy.setStatus(this.dropAllowed);
+            }
+            
+            if(this.afterDragEnter){
+                /**
+                 * An empty function by default, but provided so that you can perform a custom action
+                 * when the dragged item enters the drop target by providing an implementation.
+                 * @param {Ext.dd.DragDrop} target The drop target
+                 * @param {Event} e The event object
+                 * @param {String} id The id of the dragged element
+                 * @method afterDragEnter
+                 */
+                this.afterDragEnter(target, e, id);
+            }
         }
     },
 
+    /**
+     * An empty function by default, but provided so that you can perform a custom action
+     * before the dragged item enters the drop target and optionally cancel the onDragEnter.
+     * @param {Ext.dd.DragDrop} target The drop target
+     * @param {Event} e The event object
+     * @param {String} id The id of the dragged element
+     * @return {Boolean} isValid True if the drag event is valid, else false to cancel
+     */
+    beforeDragEnter : function(target, e, id){
+        return true;
+    },
+
     // private
-    initItems : function(){
-        if(!this.items){
-            this.items = new Ext.util.MixedCollection(false, this.getComponentId);
-            this.getLayout(); // initialize the layout
+    alignElWithMouse: function() {
+        Ext.dd.DragSource.superclass.alignElWithMouse.apply(this, arguments);
+        this.proxy.sync();
+    },
+
+    // private
+    onDragOver : function(e, id){
+        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
+        if(this.beforeDragOver(target, e, id) !== false){
+            if(target.isNotifyTarget){
+                var status = target.notifyOver(this, e, this.dragData);
+                this.proxy.setStatus(status);
+            }
+
+            if(this.afterDragOver){
+                /**
+                 * An empty function by default, but provided so that you can perform a custom action
+                 * while the dragged item is over the drop target by providing an implementation.
+                 * @param {Ext.dd.DragDrop} target The drop target
+                 * @param {Event} e The event object
+                 * @param {String} id The id of the dragged element
+                 * @method afterDragOver
+                 */
+                this.afterDragOver(target, e, id);
+            }
         }
     },
 
+    /**
+     * An empty function by default, but provided so that you can perform a custom action
+     * while the dragged item is over the drop target and optionally cancel the onDragOver.
+     * @param {Ext.dd.DragDrop} target The drop target
+     * @param {Event} e The event object
+     * @param {String} id The id of the dragged element
+     * @return {Boolean} isValid True if the drag event is valid, else false to cancel
+     */
+    beforeDragOver : function(target, e, id){
+        return true;
+    },
+
     // private
-    setLayout : function(layout){
-        if(this.layout && this.layout != layout){
-            this.layout.setContainer(null);
+    onDragOut : function(e, id){
+        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
+        if(this.beforeDragOut(target, e, id) !== false){
+            if(target.isNotifyTarget){
+                target.notifyOut(this, e, this.dragData);
+            }
+            this.proxy.reset();
+            if(this.afterDragOut){
+                /**
+                 * An empty function by default, but provided so that you can perform a custom action
+                 * after the dragged item is dragged out of the target without dropping.
+                 * @param {Ext.dd.DragDrop} target The drop target
+                 * @param {Event} e The event object
+                 * @param {String} id The id of the dragged element
+                 * @method afterDragOut
+                 */
+                this.afterDragOut(target, e, id);
+            }
         }
-        this.initItems();
-        this.layout = layout;
-        layout.setContainer(this);
+        this.cachedTarget = null;
     },
 
-    afterRender: function(){
-        // Render this Container, this should be done before setLayout is called which
-        // will hook onResize
-        Ext.Container.superclass.afterRender.call(this);
-        if(!this.layout){
-            this.layout = 'auto';
+    /**
+     * An empty function by default, but provided so that you can perform a custom action before the dragged
+     * item is dragged out of the target without dropping, and optionally cancel the onDragOut.
+     * @param {Ext.dd.DragDrop} target The drop target
+     * @param {Event} e The event object
+     * @param {String} id The id of the dragged element
+     * @return {Boolean} isValid True if the drag event is valid, else false to cancel
+     */
+    beforeDragOut : function(target, e, id){
+        return true;
+    },
+    
+    // private
+    onDragDrop : function(e, id){
+        var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id);
+        if(this.beforeDragDrop(target, e, id) !== false){
+            if(target.isNotifyTarget){
+                if(target.notifyDrop(this, e, this.dragData)){ // valid drop?
+                    this.onValidDrop(target, e, id);
+                }else{
+                    this.onInvalidDrop(target, e, id);
+                }
+            }else{
+                this.onValidDrop(target, e, id);
+            }
+            
+            if(this.afterDragDrop){
+                /**
+                 * An empty function by default, but provided so that you can perform a custom action
+                 * after a valid drag drop has occurred by providing an implementation.
+                 * @param {Ext.dd.DragDrop} target The drop target
+                 * @param {Event} e The event object
+                 * @param {String} id The id of the dropped element
+                 * @method afterDragDrop
+                 */
+                this.afterDragDrop(target, e, id);
+            }
         }
-        if(Ext.isObject(this.layout) && !this.layout.layout){
-            this.layoutConfig = this.layout;
-            this.layout = this.layoutConfig.type;
+        delete this.cachedTarget;
+    },
+
+    /**
+     * An empty function by default, but provided so that you can perform a custom action before the dragged
+     * item is dropped onto the target and optionally cancel the onDragDrop.
+     * @param {Ext.dd.DragDrop} target The drop target
+     * @param {Event} e The event object
+     * @param {String} id The id of the dragged element
+     * @return {Boolean} isValid True if the drag drop event is valid, else false to cancel
+     */
+    beforeDragDrop : function(target, e, id){
+        return true;
+    },
+
+    // private
+    onValidDrop : function(target, e, id){
+        this.hideProxy();
+        if(this.afterValidDrop){
+            /**
+             * An empty function by default, but provided so that you can perform a custom action
+             * after a valid drop has occurred by providing an implementation.
+             * @param {Object} target The target DD 
+             * @param {Event} e The event object
+             * @param {String} id The id of the dropped element
+             * @method afterInvalidDrop
+             */
+            this.afterValidDrop(target, e, id);
         }
-        if(Ext.isString(this.layout)){
-            this.layout = new Ext.Container.LAYOUTS[this.layout.toLowerCase()](this.layoutConfig);
+    },
+
+    // private
+    getRepairXY : function(e, data){
+        return this.el.getXY();  
+    },
+
+    // private
+    onInvalidDrop : function(target, e, id){
+        this.beforeInvalidDrop(target, e, id);
+        if(this.cachedTarget){
+            if(this.cachedTarget.isNotifyTarget){
+                this.cachedTarget.notifyOut(this, e, this.dragData);
+            }
+            this.cacheTarget = null;
         }
-        this.setLayout(this.layout);
+        this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this);
 
-        // If a CardLayout, the active item set
-        if(this.activeItem !== undefined){
-            var item = this.activeItem;
-            delete this.activeItem;
-            this.layout.setActiveItem(item);
+        if(this.afterInvalidDrop){
+            /**
+             * An empty function by default, but provided so that you can perform a custom action
+             * after an invalid drop has occurred by providing an implementation.
+             * @param {Event} e The event object
+             * @param {String} id The id of the dropped element
+             * @method afterInvalidDrop
+             */
+            this.afterInvalidDrop(e, id);
         }
+    },
 
-        // If we have no ownerCt, render and size all children
-        if(!this.ownerCt){
-            this.doLayout(false, true);
+    // private
+    afterRepair : function(){
+        if(Ext.enableFx){
+            this.el.highlight(this.hlColor || "c3daf9");
         }
+        this.dragging = false;
+    },
 
-        // This is a manually configured flag set by users in conjunction with renderTo.
-        // Not to be confused with the flag by the same name used in Layouts.
-        if(this.monitorResize === true){
-            Ext.EventManager.onWindowResize(this.doLayout, this, [false]);
+    /**
+     * An empty function by default, but provided so that you can perform a custom action after an invalid
+     * drop has occurred.
+     * @param {Ext.dd.DragDrop} target The drop target
+     * @param {Event} e The event object
+     * @param {String} id The id of the dragged element
+     * @return {Boolean} isValid True if the invalid drop should proceed, else false to cancel
+     */
+    beforeInvalidDrop : function(target, e, id){
+        return true;
+    },
+
+    // private
+    handleMouseDown : function(e){
+        if(this.dragging) {
+            return;
         }
+        var data = this.getDragData(e);
+        if(data && this.onBeforeDrag(data, e) !== false){
+            this.dragData = data;
+            this.proxy.stop();
+            Ext.dd.DragSource.superclass.handleMouseDown.apply(this, arguments);
+        } 
     },
 
     /**
-     * 
Returns the Element to be used to contain the child Components of this Container.
-     * An implementation is provided which returns the Container's {@link #getEl Element}, but
-     * if there is a more complex structure to a Container, this may be overridden to return
-     * the element into which the {@link #layout layout} renders child Components.
-     * @return {Ext.Element} The Element to render child Components into.
+     * An empty function by default, but provided so that you can perform a custom action before the initial
+     * drag event begins and optionally cancel it.
+     * @param {Object} data An object containing arbitrary data to be shared with drop targets
+     * @param {Event} e The event object
+     * @return {Boolean} isValid True if the drag event is valid, else false to cancel
      */
-    getLayoutTarget : function(){
-        return this.el;
+    onBeforeDrag : function(data, e){
+        return true;
     },
 
-    // private - used as the key lookup function for the items collection
-    getComponentId : function(comp){
-        return comp.getItemId();
+    /**
+     * An empty function by default, but provided so that you can perform a custom action once the initial
+     * drag event has begun.  The drag cannot be canceled from this function.
+     * @param {Number} x The x position of the click on the dragged object
+     * @param {Number} y The y position of the click on the dragged object
+     */
+    onStartDrag : Ext.emptyFn,
+
+    // private override
+    startDrag : function(x, y){
+        this.proxy.reset();
+        this.dragging = true;
+        this.proxy.update("");
+        this.onInitDrag(x, y);
+        this.proxy.show();
+    },
+
+    // private
+    onInitDrag : function(x, y){
+        var clone = this.el.dom.cloneNode(true);
+        clone.id = Ext.id(); // prevent duplicate ids
+        this.proxy.update(clone);
+        this.onStartDrag(x, y);
+        return true;
     },
 
     /**
-     * Adds {@link Ext.Component Component}(s) to this Container.
-     * 
Description :
-     * 

-     * Fires the {@link #beforeadd} event before adding
-     * The Container's {@link #defaults default config values} will be applied
-     * accordingly (see {@link #defaults} for details).
-     * Fires the {@link #add} event after the component has been added.
-     * 
-     * 
Notes :
-     * 

-     * If the Container is already rendered when add
-     * is called, you may need to call {@link #doLayout} to refresh the view which causes
-     * any unrendered child Components to be rendered. This is required so that you can
-     * add multiple child components if needed while only refreshing the layout
-     * once. For example:
-var tb = new {@link Ext.Toolbar}();
-tb.render(document.body);  // toolbar is rendered
-tb.add({text:'Button 1'}); // add multiple items ({@link #defaultType} for {@link Ext.Toolbar Toolbar} is 'button')
-tb.add({text:'Button 2'});
-tb.{@link #doLayout}();             // refresh the layout
-     * 
-     * Warning: Containers directly managed by the BorderLayout layout manager
-     * may not be removed or added.  See the Notes for {@link Ext.layout.BorderLayout BorderLayout}
-     * for more details.
-     * 
-     * @param {Object/Array} component
-     * Either a single component or an Array of components to add.  See
-     * {@link #items} for additional information.
-     * @param {Object} (Optional) component_2
-     * @param {Object} (Optional) component_n
-     * @return {Ext.Component} component The Component (or config object) that was added.
+     * Returns the drag source's underlying {@link Ext.dd.StatusProxy}
+     * @return {Ext.dd.StatusProxy} proxy The StatusProxy
      */
-    add : function(comp){
-        this.initItems();
-        var args = arguments.length > 1;
-        if(args || Ext.isArray(comp)){
-            var result = [];
-            Ext.each(args ? arguments : comp, function(c){
-                result.push(this.add(c));
-            }, this);
-            return result;
-        }
-        var c = this.lookupComponent(this.applyDefaults(comp));
-        var index = this.items.length;
-        if(this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false){
-            this.items.add(c);
-            // *onAdded
-            c.onAdded(this, index);
-            this.onAdd(c);
-            this.fireEvent('add', this, c, index);
-        }
-        return c;
+    getProxy : function(){
+        return this.proxy;  
     },
 
-    onAdd : function(c){
-        // Empty template method
+    /**
+     * Hides the drag source's {@link Ext.dd.StatusProxy}
+     */
+    hideProxy : function(){
+        this.proxy.hide();  
+        this.proxy.reset(true);
+        this.dragging = false;
     },
 
     // private
-    onAdded : function(container, pos) {
-        //overridden here so we can cascade down, not worth creating a template method.
-        this.ownerCt = container;
-        this.initRef();
-        //initialize references for child items
-        this.cascade(function(c){
-            c.initRef();
-        });
-        this.fireEvent('added', this, container, pos);
+    triggerCacheRefresh : function(){
+        Ext.dd.DDM.refreshCache(this.groups);
+    },
+
+    // private - override to prevent hiding
+    b4EndDrag: function(e) {
+    },
+
+    // private - override to prevent moving
+    endDrag : function(e){
+        this.onEndDrag(this.dragData, e);
     },
 
+    // private
+    onEndDrag : function(data, e){
+    },
+    
+    // private - pin to cursor
+    autoOffset : function(x, y) {
+        this.setDelta(-12, -20);
+    },
+    
+    destroy: function(){
+        Ext.dd.DragSource.superclass.destroy.call(this);
+        Ext.destroy(this.proxy);
+    }
+});/**
+ * @class Ext.dd.DropTarget
+ * @extends Ext.dd.DDTarget
+ * A simple class that provides the basic implementation needed to make any element a drop target that can have
+ * draggable items dropped onto it.  The drop has no effect until an implementation of notifyDrop is provided.
+ * @constructor
+ * @param {Mixed} el The container element
+ * @param {Object} config
+ */
+Ext.dd.DropTarget = function(el, config){
+    this.el = Ext.get(el);
+    
+    Ext.apply(this, config);
+    
+    if(this.containerScroll){
+        Ext.dd.ScrollManager.register(this.el);
+    }
+    
+    Ext.dd.DropTarget.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, 
+          {isTarget: true});
+
+};
+
+Ext.extend(Ext.dd.DropTarget, Ext.dd.DDTarget, {
     /**
-     * Inserts a Component into this Container at a specified index. Fires the
-     * {@link #beforeadd} event before inserting, then fires the {@link #add} event after the
-     * Component has been inserted.
-     * @param {Number} index The index at which the Component will be inserted
-     * into the Container's items collection
-     * @param {Ext.Component} component The child Component to insert.


-     * Ext uses lazy rendering, and will only render the inserted Component should
-     * it become necessary.


-     * A Component config object may be passed in order to avoid the overhead of
-     * constructing a real Component object if lazy rendering might mean that the
-     * inserted Component will not be rendered immediately. To take advantage of
-     * this 'lazy instantiation', set the {@link Ext.Component#xtype} config
-     * property to the registered type of the Component wanted.


-     * For a list of all available xtypes, see {@link Ext.Component}.
-     * @return {Ext.Component} component The Component (or config object) that was
-     * inserted with the Container's default config values applied.
+     * @cfg {String} ddGroup
+     * A named drag drop group to which this object belongs.  If a group is specified, then this object will only
+     * interact with other drag drop objects in the same group (defaults to undefined).
      */
-    insert : function(index, comp){
-        this.initItems();
-        var a = arguments, len = a.length;
-        if(len > 2){
-            var result = [];
-            for(var i = len-1; i >= 1; --i) {
-                result.push(this.insert(index, a[i]));
-            }
-            return result;
+    /**
+     * @cfg {String} overClass
+     * The CSS class applied to the drop target element while the drag source is over it (defaults to "").
+     */
+    /**
+     * @cfg {String} dropAllowed
+     * The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok").
+     */
+    dropAllowed : "x-dd-drop-ok",
+    /**
+     * @cfg {String} dropNotAllowed
+     * The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop").
+     */
+    dropNotAllowed : "x-dd-drop-nodrop",
+
+    // private
+    isTarget : true,
+
+    // private
+    isNotifyTarget : true,
+
+    /**
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the source is now over the
+     * target.  This default implementation adds the CSS class specified by overClass (if any) to the drop element
+     * and returns the dropAllowed config value.  This method should be overridden if drop validation is required.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
+     */
+    notifyEnter : function(dd, e, data){
+        if(this.overClass){
+            this.el.addClass(this.overClass);
         }
-        var c = this.lookupComponent(this.applyDefaults(comp));
-        index = Math.min(index, this.items.length);
-        if(this.fireEvent('beforeadd', this, c, index) !== false && this.onBeforeAdd(c) !== false){
-            if(c.ownerCt == this){
-                this.items.remove(c);
-            }
-            this.items.insert(index, c);
-            c.onAdded(this, index);
-            this.onAdd(c);
-            this.fireEvent('add', this, c, index);
+        return this.dropAllowed;
+    },
+
+    /**
+     * The function a {@link Ext.dd.DragSource} calls continuously while it is being dragged over the target.
+     * This method will be called on every mouse movement while the drag source is over the drop target.
+     * This default implementation simply returns the dropAllowed config value.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
+     */
+    notifyOver : function(dd, e, data){
+        return this.dropAllowed;
+    },
+
+    /**
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the source has been dragged
+     * out of the target without dropping.  This default implementation simply removes the CSS class specified by
+     * overClass (if any) from the drop element.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     */
+    notifyOut : function(dd, e, data){
+        if(this.overClass){
+            this.el.removeClass(this.overClass);
         }
-        return c;
     },
 
-    // private
-    applyDefaults : function(c){
-        var d = this.defaults;
-        if(d){
-            if(Ext.isFunction(d)){
-                d = d.call(this, c);
-            }
-            if(Ext.isString(c)){
-                c = Ext.ComponentMgr.get(c);
-                Ext.apply(c, d);
-            }else if(!c.events){
-                Ext.applyIf(c, d);
-            }else{
-                Ext.apply(c, d);
+    /**
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the dragged item has
+     * been dropped on it.  This method has no default implementation and returns false, so you must provide an
+     * implementation that does something to process the drop event and returns true so that the drag source's
+     * repair action does not run.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {Boolean} True if the drop was valid, else false
+     */
+    notifyDrop : function(dd, e, data){
+        return false;
+    }
+});/**
+ * @class Ext.dd.DragZone
+ * @extends Ext.dd.DragSource
+ * This class provides a container DD instance that allows dragging of multiple child source nodes.
+ * This class does not move the drag target nodes, but a proxy element which may contain
+ * any DOM structure you wish. The DOM element to show in the proxy is provided by either a
+ * provided implementation of {@link #getDragData}, or by registered draggables registered with {@link Ext.dd.Registry}
+ * If you wish to provide draggability for an arbitrary number of DOM nodes, each of which represent some
+ * application object (For example nodes in a {@link Ext.DataView DataView}) then use of this class
+ * is the most efficient way to "activate" those nodes.
+ * By default, this class requires that draggable child nodes are registered with {@link Ext.dd.Registry}.
+ * However a simpler way to allow a DragZone to manage any number of draggable elements is to configure
+ * the DragZone with  an implementation of the {@link #getDragData} method which interrogates the passed
+ * mouse event to see if it has taken place within an element, or class of elements. This is easily done
+ * by using the event's {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a
+ * {@link Ext.DomQuery} selector. For example, to make the nodes of a DataView draggable, use the following
+ * technique. Knowledge of the use of the DataView is required:

+myDataView.on('render', function(v) {
+    myDataView.dragZone = new Ext.dd.DragZone(v.getEl(), {
+
+//      On receipt of a mousedown event, see if it is within a DataView node.
+//      Return a drag data object if so.
+        getDragData: function(e) {
+
+//          Use the DataView's own itemSelector (a mandatory property) to
+//          test if the mousedown is within one of the DataView's nodes.
+            var sourceEl = e.getTarget(v.itemSelector, 10);
+
+//          If the mousedown is within a DataView node, clone the node to produce
+//          a ddel element for use by the drag proxy. Also add application data
+//          to the returned data object.
+            if (sourceEl) {
+                d = sourceEl.cloneNode(true);
+                d.id = Ext.id();
+                return {
+                    ddel: d,
+                    sourceEl: sourceEl,
+                    repairXY: Ext.fly(sourceEl).getXY(),
+                    sourceStore: v.store,
+                    draggedRecord: v.{@link Ext.DataView#getRecord getRecord}(sourceEl)
+                }
             }
+        },
+
+//      Provide coordinates for the proxy to slide back to on failed drag.
+//      This is the original XY coordinates of the draggable element captured
+//      in the getDragData method.
+        getRepairXY: function() {
+            return this.dragData.repairXY;
         }
-        return c;
-    },
+    });
+});
+ * See the {@link Ext.dd.DropZone DropZone} documentation for details about building a DropZone which
+ * cooperates with this DragZone.
+ * @constructor
+ * @param {Mixed} el The container element
+ * @param {Object} config
+ */
+Ext.dd.DragZone = function(el, config){
+    Ext.dd.DragZone.superclass.constructor.call(this, el, config);
+    if(this.containerScroll){
+        Ext.dd.ScrollManager.register(this.el);
+    }
+};
 
-    // private
-    onBeforeAdd : function(item){
-        if(item.ownerCt){
-            item.ownerCt.remove(item, false);
+Ext.extend(Ext.dd.DragZone, Ext.dd.DragSource, {
+    /**
+     * This property contains the data representing the dragged object. This data is set up by the implementation
+     * of the {@link #getDragData} method. It must contain a ddel property, but can contain
+     * any other data according to the application's needs.
+     * @type Object
+     * @property dragData
+     */
+    /**
+     * @cfg {Boolean} containerScroll True to register this container with the Scrollmanager
+     * for auto scrolling during drag operations.
+     */
+    /**
+     * @cfg {String} hlColor The color to use when visually highlighting the drag source in the afterRepair
+     * method after a failed drop (defaults to "c3daf9" - light blue)
+     */
+
+    /**
+     * Called when a mousedown occurs in this container. Looks in {@link Ext.dd.Registry}
+     * for a valid target to drag based on the mouse down. Override this method
+     * to provide your own lookup logic (e.g. finding a child by class name). Make sure your returned
+     * object has a "ddel" attribute (with an HTML Element) for other functions to work.
+     * @param {EventObject} e The mouse down event
+     * @return {Object} The dragData
+     */
+    getDragData : function(e){
+        return Ext.dd.Registry.getHandleFromEvent(e);
+    },
+    
+    /**
+     * Called once drag threshold has been reached to initialize the proxy element. By default, it clones the
+     * this.dragData.ddel
+     * @param {Number} x The x position of the click on the dragged object
+     * @param {Number} y The y position of the click on the dragged object
+     * @return {Boolean} true to continue the drag, false to cancel
+     */
+    onInitDrag : function(x, y){
+        this.proxy.update(this.dragData.ddel.cloneNode(true));
+        this.onStartDrag(x, y);
+        return true;
+    },
+    
+    /**
+     * Called after a repair of an invalid drop. By default, highlights this.dragData.ddel 
+     */
+    afterRepair : function(){
+        if(Ext.enableFx){
+            Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9");
         }
-        if(this.hideBorders === true){
-            item.border = (item.border === true);
+        this.dragging = false;
+    },
+
+    /**
+     * Called before a repair of an invalid drop to get the XY to animate to. By default returns
+     * the XY of this.dragData.ddel
+     * @param {EventObject} e The mouse up event
+     * @return {Array} The xy location (e.g. [100, 200])
+     */
+    getRepairXY : function(e){
+        return Ext.Element.fly(this.dragData.ddel).getXY();  
+    }
+});/**
+ * @class Ext.dd.DropZone
+ * @extends Ext.dd.DropTarget
+ * This class provides a container DD instance that allows dropping on multiple child target nodes.
+ * By default, this class requires that child nodes accepting drop are registered with {@link Ext.dd.Registry}.
+ * However a simpler way to allow a DropZone to manage any number of target elements is to configure the
+ * DropZone with an implementation of {@link #getTargetFromEvent} which interrogates the passed
+ * mouse event to see if it has taken place within an element, or class of elements. This is easily done
+ * by using the event's {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a
+ * {@link Ext.DomQuery} selector.
+ * Once the DropZone has detected through calling getTargetFromEvent, that the mouse is over
+ * a drop target, that target is passed as the first parameter to {@link #onNodeEnter}, {@link #onNodeOver},
+ * {@link #onNodeOut}, {@link #onNodeDrop}. You may configure the instance of DropZone with implementations
+ * of these methods to provide application-specific behaviour for these events to update both
+ * application state, and UI state.
+ * For example to make a GridPanel a cooperating target with the example illustrated in
+ * {@link Ext.dd.DragZone DragZone}, the following technique might be used:

+myGridPanel.on('render', function() {
+    myGridPanel.dropZone = new Ext.dd.DropZone(myGridPanel.getView().scroller, {
+
+//      If the mouse is over a grid row, return that node. This is
+//      provided as the "target" parameter in all "onNodeXXXX" node event handling functions
+        getTargetFromEvent: function(e) {
+            return e.getTarget(myGridPanel.getView().rowSelector);
+        },
+
+//      On entry into a target node, highlight that node.
+        onNodeEnter : function(target, dd, e, data){ 
+            Ext.fly(target).addClass('my-row-highlight-class');
+        },
+
+//      On exit from a target node, unhighlight that node.
+        onNodeOut : function(target, dd, e, data){ 
+            Ext.fly(target).removeClass('my-row-highlight-class');
+        },
+
+//      While over a target node, return the default drop allowed class which
+//      places a "tick" icon into the drag proxy.
+        onNodeOver : function(target, dd, e, data){ 
+            return Ext.dd.DropZone.prototype.dropAllowed;
+        },
+
+//      On node drop we can interrogate the target to find the underlying
+//      application object that is the real target of the dragged data.
+//      In this case, it is a Record in the GridPanel's Store.
+//      We can use the data set up by the DragZone's getDragData method to read
+//      any data we decided to attach in the DragZone's getDragData method.
+        onNodeDrop : function(target, dd, e, data){
+            var rowIndex = myGridPanel.getView().findRowIndex(target);
+            var r = myGridPanel.getStore().getAt(rowIndex);
+            Ext.Msg.alert('Drop gesture', 'Dropped Record id ' + data.draggedRecord.id +
+                ' on Record id ' + r.id);
+            return true;
         }
+    });
+}
+
+ * See the {@link Ext.dd.DragZone DragZone} documentation for details about building a DragZone which
+ * cooperates with this DropZone.
+ * @constructor
+ * @param {Mixed} el The container element
+ * @param {Object} config
+ */
+Ext.dd.DropZone = function(el, config){
+    Ext.dd.DropZone.superclass.constructor.call(this, el, config);
+};
+
+Ext.extend(Ext.dd.DropZone, Ext.dd.DropTarget, {
+    /**
+     * Returns a custom data object associated with the DOM node that is the target of the event.  By default
+     * this looks up the event target in the {@link Ext.dd.Registry}, although you can override this method to
+     * provide your own custom lookup.
+     * @param {Event} e The event
+     * @return {Object} data The custom data
+     */
+    getTargetFromEvent : function(e){
+        return Ext.dd.Registry.getTargetFromEvent(e);
+    },
+
+    /**
+     * Called when the DropZone determines that a {@link Ext.dd.DragSource} has entered a drop node
+     * that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}.
+     * This method has no default implementation and should be overridden to provide
+     * node-specific processing if necessary.
+     * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from 
+     * {@link #getTargetFromEvent} for this node)
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     */
+    onNodeEnter : function(n, dd, e, data){
+        
+    },
+
+    /**
+     * Called while the DropZone determines that a {@link Ext.dd.DragSource} is over a drop node
+     * that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}.
+     * The default implementation returns this.dropNotAllowed, so it should be
+     * overridden to provide the proper feedback.
+     * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from
+     * {@link #getTargetFromEvent} for this node)
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
+     */
+    onNodeOver : function(n, dd, e, data){
+        return this.dropAllowed;
+    },
+
+    /**
+     * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dragged out of
+     * the drop node without dropping.  This method has no default implementation and should be overridden to provide
+     * node-specific processing if necessary.
+     * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from
+     * {@link #getTargetFromEvent} for this node)
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     */
+    onNodeOut : function(n, dd, e, data){
+        
     },
 
     /**
-     * Removes a component from this container.  Fires the {@link #beforeremove} event before removing, then fires
-     * the {@link #remove} event after the component has been removed.
-     * @param {Component/String} component The component reference or id to remove.
-     * @param {Boolean} autoDestroy (optional) True to automatically invoke the removed Component's {@link Ext.Component#destroy} function.
-     * Defaults to the value of this Container's {@link #autoDestroy} config.
-     * @return {Ext.Component} component The Component that was removed.
+     * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped onto
+     * the drop node.  The default implementation returns false, so it should be overridden to provide the
+     * appropriate processing of the drop event and return true so that the drag source's repair action does not run.
+     * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from
+     * {@link #getTargetFromEvent} for this node)
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {Boolean} True if the drop was valid, else false
      */
-    remove : function(comp, autoDestroy){
-        this.initItems();
-        var c = this.getComponent(comp);
-        if(c && this.fireEvent('beforeremove', this, c) !== false){
-            this.doRemove(c, autoDestroy);
-            this.fireEvent('remove', this, c);
-        }
-        return c;
+    onNodeDrop : function(n, dd, e, data){
+        return false;
     },
 
-    onRemove: function(c){
-        // Empty template method
+    /**
+     * Called while the DropZone determines that a {@link Ext.dd.DragSource} is being dragged over it,
+     * but not over any of its registered drop nodes.  The default implementation returns this.dropNotAllowed, so
+     * it should be overridden to provide the proper feedback if necessary.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
+     */
+    onContainerOver : function(dd, e, data){
+        return this.dropNotAllowed;
     },
 
-    // private
-    doRemove: function(c, autoDestroy){
-        var l = this.layout,
-            hasLayout = l && this.rendered;
+    /**
+     * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped on it,
+     * but not on any of its registered drop nodes.  The default implementation returns false, so it should be
+     * overridden to provide the appropriate processing of the drop event if you need the drop zone itself to
+     * be able to accept drops.  It should return true when valid so that the drag source's repair action does not run.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {Boolean} True if the drop was valid, else false
+     */
+    onContainerDrop : function(dd, e, data){
+        return false;
+    },
 
-        if(hasLayout){
-            l.onRemove(c);
-        }
-        this.items.remove(c);
-        c.onRemoved();
-        this.onRemove(c);
-        if(autoDestroy === true || (autoDestroy !== false && this.autoDestroy)){
-            c.destroy();
-        }
-        if(hasLayout){
-            l.afterRemove(c);
-        }
+    /**
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source is now over
+     * the zone.  The default implementation returns this.dropNotAllowed and expects that only registered drop
+     * nodes can process drag drop operations, so if you need the drop zone itself to be able to process drops
+     * you should override this method and provide a custom implementation.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
+     */
+    notifyEnter : function(dd, e, data){
+        return this.dropNotAllowed;
     },
 
     /**
-     * Removes all components from this container.
-     * @param {Boolean} autoDestroy (optional) True to automatically invoke the removed Component's {@link Ext.Component#destroy} function.
-     * Defaults to the value of this Container's {@link #autoDestroy} config.
-     * @return {Array} Array of the destroyed components
+     * The function a {@link Ext.dd.DragSource} calls continuously while it is being dragged over the drop zone.
+     * This method will be called on every mouse movement while the drag source is over the drop zone.
+     * It will call {@link #onNodeOver} while the drag source is over a registered node, and will also automatically
+     * delegate to the appropriate node-specific methods as necessary when the drag source enters and exits
+     * registered nodes ({@link #onNodeEnter}, {@link #onNodeOut}). If the drag source is not currently over a
+     * registered node, it will call {@link #onContainerOver}.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {String} status The CSS class that communicates the drop status back to the source so that the
+     * underlying {@link Ext.dd.StatusProxy} can be updated
      */
-    removeAll: function(autoDestroy){
-        this.initItems();
-        var item, rem = [], items = [];
-        this.items.each(function(i){
-            rem.push(i);
-        });
-        for (var i = 0, len = rem.length; i < len; ++i){
-            item = rem[i];
-            this.remove(item, autoDestroy);
-            if(item.ownerCt !== this){
-                items.push(item);
+    notifyOver : function(dd, e, data){
+        var n = this.getTargetFromEvent(e);
+        if(!n){ // not over valid drop target
+            if(this.lastOverNode){
+                this.onNodeOut(this.lastOverNode, dd, e, data);
+                this.lastOverNode = null;
             }
+            return this.onContainerOver(dd, e, data);
         }
-        return items;
+        if(this.lastOverNode != n){
+            if(this.lastOverNode){
+                this.onNodeOut(this.lastOverNode, dd, e, data);
+            }
+            this.onNodeEnter(n, dd, e, data);
+            this.lastOverNode = n;
+        }
+        return this.onNodeOver(n, dd, e, data);
     },
 
     /**
-     * Examines this container's {@link #items} property
-     * and gets a direct child component of this container.
-     * @param {String/Number} comp This parameter may be any of the following:
-     * 
-     * a String : representing the {@link Ext.Component#itemId itemId}
-     * or {@link Ext.Component#id id} of the child component 
-     * a Number : representing the position of the child component
-     * within the {@link #items} property
-     * 
-     * For additional information see {@link Ext.util.MixedCollection#get}.
-     * @return Ext.Component The component (if found).
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source has been dragged
+     * out of the zone without dropping.  If the drag source is currently over a registered node, the notification
+     * will be delegated to {@link #onNodeOut} for node-specific handling, otherwise it will be ignored.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag zone
      */
-    getComponent : function(comp){
-        if(Ext.isObject(comp)){
-            comp = comp.getItemId();
+    notifyOut : function(dd, e, data){
+        if(this.lastOverNode){
+            this.onNodeOut(this.lastOverNode, dd, e, data);
+            this.lastOverNode = null;
         }
-        return this.items.get(comp);
     },
 
-    // private
-    lookupComponent : function(comp){
-        if(Ext.isString(comp)){
-            return Ext.ComponentMgr.get(comp);
-        }else if(!comp.events){
-            return this.createComponent(comp);
+    /**
+     * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the dragged item has
+     * been dropped on it.  The drag zone will look up the target node based on the event passed in, and if there
+     * is a node registered for that event, it will delegate to {@link #onNodeDrop} for node-specific handling,
+     * otherwise it will call {@link #onContainerDrop}.
+     * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone
+     * @param {Event} e The event
+     * @param {Object} data An object containing arbitrary data supplied by the drag source
+     * @return {Boolean} True if the drop was valid, else false
+     */
+    notifyDrop : function(dd, e, data){
+        if(this.lastOverNode){
+            this.onNodeOut(this.lastOverNode, dd, e, data);
+            this.lastOverNode = null;
         }
-        return comp;
+        var n = this.getTargetFromEvent(e);
+        return n ?
+            this.onNodeDrop(n, dd, e, data) :
+            this.onContainerDrop(dd, e, data);
     },
 
     // private
-    createComponent : function(config, defaultType){
-        // add in ownerCt at creation time but then immediately
-        // remove so that onBeforeAdd can handle it
-        var c = config.render ? config : Ext.create(Ext.apply({
-            ownerCt: this
-        }, config), defaultType || this.defaultType);
-        delete c.ownerCt;
-        return c;
+    triggerCacheRefresh : function(){
+        Ext.dd.DDM.refreshCache(this.groups);
+    }  
+});/**
+ * @class Ext.Element
+ */
+Ext.Element.addMethods({
+    /**
+     * Initializes a {@link Ext.dd.DD} drag drop object for this element.
+     * @param {String} group The group the DD object is member of
+     * @param {Object} config The DD config object
+     * @param {Object} overrides An object containing methods to override/implement on the DD object
+     * @return {Ext.dd.DD} The DD object
+     */
+    initDD : function(group, config, overrides){
+        var dd = new Ext.dd.DD(Ext.id(this.dom), group, config);
+        return Ext.apply(dd, overrides);
     },
 
     /**
-    * We can only lay out if there is a view area in which to layout.
-    * display:none on the layout target, *or any of its parent elements* will mean it has no view area.
-    */
-
-    // private
-    canLayout : function() {
-        var el = this.getVisibilityEl();
-        return el && el.dom && !el.isStyle("display", "none");
+     * Initializes a {@link Ext.dd.DDProxy} object for this element.
+     * @param {String} group The group the DDProxy object is member of
+     * @param {Object} config The DDProxy config object
+     * @param {Object} overrides An object containing methods to override/implement on the DDProxy object
+     * @return {Ext.dd.DDProxy} The DDProxy object
+     */
+    initDDProxy : function(group, config, overrides){
+        var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config);
+        return Ext.apply(dd, overrides);
     },
 
     /**
-     * Force this container's layout to be recalculated. A call to this function is required after adding a new component
-     * to an already rendered container, or possibly after changing sizing/position properties of child components.
-     * @param {Boolean} shallow (optional) True to only calc the layout of this component, and let child components auto
-     * calc layouts as required (defaults to false, which calls doLayout recursively for each subcontainer)
-     * @param {Boolean} force (optional) True to force a layout to occur, even if the item is hidden.
-     * @return {Ext.Container} this
+     * Initializes a {@link Ext.dd.DDTarget} object for this element.
+     * @param {String} group The group the DDTarget object is member of
+     * @param {Object} config The DDTarget config object
+     * @param {Object} overrides An object containing methods to override/implement on the DDTarget object
+     * @return {Ext.dd.DDTarget} The DDTarget object
      */
+    initDDTarget : function(group, config, overrides){
+        var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config);
+        return Ext.apply(dd, overrides);
+    }
+});
+/**
+ * @class Ext.data.Api
+ * @extends Object
+ * Ext.data.Api is a singleton designed to manage the data API including methods
+ * for validating a developer's DataProxy API.  Defines variables for CRUD actions
+ * create, read, update and destroy in addition to a mapping of RESTful HTTP methods
+ * GET, POST, PUT and DELETE to CRUD actions.
+ * @singleton
+ */
+Ext.data.Api = (function() {
 
-    doLayout : function(shallow, force){
-        var rendered = this.rendered,
-            forceLayout = force || this.forceLayout;
+    // private validActions.  validActions is essentially an inverted hash of Ext.data.Api.actions, where value becomes the key.
+    // Some methods in this singleton (e.g.: getActions, getVerb) will loop through actions with the code for (var verb in this.actions)
+    // For efficiency, some methods will first check this hash for a match.  Those methods which do acces validActions will cache their result here.
+    // We cannot pre-define this hash since the developer may over-ride the actions at runtime.
+    var validActions = {};
 
-        if(this.collapsed || !this.canLayout()){
-            this.deferLayout = this.deferLayout || !shallow;
-            if(!forceLayout){
-                return;
+    return {
+        /**
+         * Defined actions corresponding to remote actions:
+         * 

+actions: {
+    create  : 'create',  // Text representing the remote-action to create records on server.
+    read    : 'read',    // Text representing the remote-action to read/load data from server.
+    update  : 'update',  // Text representing the remote-action to update records on server.
+    destroy : 'destroy'  // Text representing the remote-action to destroy records on server.
+}
+         * 
+         * @property actions
+         * @type Object
+         */
+        actions : {
+            create  : 'create',
+            read    : 'read',
+            update  : 'update',
+            destroy : 'destroy'
+        },
+
+        /**
+         * Defined {CRUD action}:{HTTP method} pairs to associate HTTP methods with the
+         * corresponding actions for {@link Ext.data.DataProxy#restful RESTful proxies}.
+         * Defaults to:
+         * 
+restActions : {
+    create  : 'POST',
+    read    : 'GET',
+    update  : 'PUT',
+    destroy : 'DELETE'
+},
+         * 
+         */
+        restActions : {
+            create  : 'POST',
+            read    : 'GET',
+            update  : 'PUT',
+            destroy : 'DELETE'
+        },
+
+        /**
+         * Returns true if supplied action-name is a valid API action defined in {@link #actions} constants
+         * @param {String} action Action to test for availability.
+         * @return {Boolean}
+         */
+        isAction : function(action) {
+            return (Ext.data.Api.actions[action]) ? true : false;
+        },
+
+        /**
+         * Returns the actual CRUD action KEY "create", "read", "update" or "destroy" from the supplied action-name.  This method is used internally and shouldn't generally
+         * need to be used directly.  The key/value pair of Ext.data.Api.actions will often be identical but this is not necessarily true.  A developer can override this naming
+         * convention if desired.  However, the framework internally calls methods based upon the KEY so a way of retreiving the the words "create", "read", "update" and "destroy" is
+         * required.  This method will cache discovered KEYS into the private validActions hash.
+         * @param {String} name The runtime name of the action.
+         * @return {String||null} returns the action-key, or verb of the user-action or null if invalid.
+         * @nodoc
+         */
+        getVerb : function(name) {
+            if (validActions[name]) {
+                return validActions[name];  // <-- found in cache.  return immediately.
             }
-            shallow = shallow && !this.deferLayout;
-        } else {
-            delete this.deferLayout;
-        }
-        if(rendered && this.layout){
-            this.layout.layout();
-        }
-        if(shallow !== true && this.items){
-            var cs = this.items.items;
-            for(var i = 0, len = cs.length; i < len; i++){
-                var c = cs[i];
-                if(c.doLayout){
-                    c.doLayout(false, forceLayout);
+            for (var verb in this.actions) {
+                if (this.actions[verb] === name) {
+                    validActions[name] = verb;
+                    break;
                 }
             }
-        }
-        if(rendered){
-            this.onLayout(shallow, forceLayout);
-        }
-        // Initial layout completed
-        this.hasLayout = true;
-        delete this.forceLayout;
-    },
+            return (validActions[name] !== undefined) ? validActions[name] : null;
+        },
 
-    onLayout : Ext.emptyFn,
+        /**
+         * Returns true if the supplied API is valid; that is, check that all keys match defined actions
+         * otherwise returns an array of mistakes.
+         * @return {String[]|true}
+         */
+        isValid : function(api){
+            var invalid = [];
+            var crud = this.actions; // <-- cache a copy of the actions.
+            for (var action in api) {
+                if (!(action in crud)) {
+                    invalid.push(action);
+                }
+            }
+            return (!invalid.length) ? true : invalid;
+        },
 
-    // private
-    shouldBufferLayout: function(){
-        /*
-         * Returns true if the container should buffer a layout.
-         * This is true only if the container has previously been laid out
-         * and has a parent container that is pending a layout.
+        /**
+         * Returns true if the supplied verb upon the supplied proxy points to a unique url in that none of the other api-actions
+         * point to the same url.  The question is important for deciding whether to insert the "xaction" HTTP parameter within an
+         * Ajax request.  This method is used internally and shouldn't generally need to be called directly.
+         * @param {Ext.data.DataProxy} proxy
+         * @param {String} verb
+         * @return {Boolean}
          */
-        var hl = this.hasLayout;
-        if(this.ownerCt){
-            // Only ever buffer if we've laid out the first time and we have one pending.
-            return hl ? !this.hasLayoutPending() : false;
-        }
-        // Never buffer initial layout
-        return hl;
-    },
+        hasUniqueUrl : function(proxy, verb) {
+            var url = (proxy.api[verb]) ? proxy.api[verb].url : null;
+            var unique = true;
+            for (var action in proxy.api) {
+                if ((unique = (action === verb) ? true : (proxy.api[action].url != url) ? true : false) === false) {
+                    break;
+                }
+            }
+            return unique;
+        },
 
-    // private
-    hasLayoutPending: function(){
-        // Traverse hierarchy to see if any parent container has a pending layout.
-        var pending = false;
-        this.ownerCt.bubble(function(c){
-            if(c.layoutPending){
-                pending = true;
-                return false;
+        /**
+         * This method is used internally by {@link Ext.data.DataProxy DataProxy} and should not generally need to be used directly.
+         * Each action of a DataProxy api can be initially defined as either a String or an Object.  When specified as an object,
+         * one can explicitly define the HTTP method (GET|POST) to use for each CRUD action.  This method will prepare the supplied API, setting
+         * each action to the Object form.  If your API-actions do not explicitly define the HTTP method, the "method" configuration-parameter will
+         * be used.  If the method configuration parameter is not specified, POST will be used.
+         
+new Ext.data.HttpProxy({
+    method: "POST",     // <-- default HTTP method when not specified.
+    api: {
+        create: 'create.php',
+        load: 'read.php',
+        save: 'save.php',
+        destroy: 'destroy.php'
+    }
+});
+
+// Alternatively, one can use the object-form to specify the API
+new Ext.data.HttpProxy({
+    api: {
+        load: {url: 'read.php', method: 'GET'},
+        create: 'create.php',
+        destroy: 'destroy.php',
+        save: 'update.php'
+    }
+});
+        
+         *
+         * @param {Ext.data.DataProxy} proxy
+         */
+        prepare : function(proxy) {
+            if (!proxy.api) {
+                proxy.api = {}; // <-- No api?  create a blank one.
             }
-        });
-        return pending;
-    },
+            for (var verb in this.actions) {
+                var action = this.actions[verb];
+                proxy.api[action] = proxy.api[action] || proxy.url || proxy.directFn;
+                if (typeof(proxy.api[action]) == 'string') {
+                    proxy.api[action] = {
+                        url: proxy.api[action],
+                        method: (proxy.restful === true) ? Ext.data.Api.restActions[action] : undefined
+                    };
+                }
+            }
+        },
 
-    onShow : function(){
-        // removes css classes that were added to hide
-        Ext.Container.superclass.onShow.call(this);
-        // If we were sized during the time we were hidden, layout.
-        if(Ext.isDefined(this.deferLayout)){
-            delete this.deferLayout;
-            this.doLayout(true);
-        }
-    },
+        /**
+         * Prepares a supplied Proxy to be RESTful.  Sets the HTTP method for each api-action to be one of
+         * GET, POST, PUT, DELETE according to the defined {@link #restActions}.
+         * @param {Ext.data.DataProxy} proxy
+         */
+        restify : function(proxy) {
+            proxy.restful = true;
+            for (var verb in this.restActions) {
+                proxy.api[this.actions[verb]].method ||
+                    (proxy.api[this.actions[verb]].method = this.restActions[verb]);
+            }
+            // TODO: perhaps move this interceptor elsewhere?  like into DataProxy, perhaps?  Placed here
+            // to satisfy initial 3.0 final release of REST features.
+            proxy.onWrite = proxy.onWrite.createInterceptor(function(action, o, response, rs) {
+                var reader = o.reader;
+                var res = new Ext.data.Response({
+                    action: action,
+                    raw: response
+                });
 
-    /**
-     * Returns the layout currently in use by the container.  If the container does not currently have a layout
-     * set, a default {@link Ext.layout.ContainerLayout} will be created and set as the container's layout.
-     * @return {ContainerLayout} layout The container's layout
-     */
-    getLayout : function(){
-        if(!this.layout){
-            var layout = new Ext.layout.ContainerLayout(this.layoutConfig);
-            this.setLayout(layout);
+                switch (response.status) {
+                    case 200:   // standard 200 response, send control back to HttpProxy#onWrite by returning true from this intercepted #onWrite
+                        return true;
+                        break;
+                    case 201:   // entity created but no response returned
+                        if (Ext.isEmpty(res.raw.responseText)) {
+                          res.success = true;
+                        } else {
+                          //if the response contains data, treat it like a 200
+                          return true;
+                        }
+                        break;
+                    case 204:  // no-content.  Create a fake response.
+                        res.success = true;
+                        res.data = null;
+                        break;
+                    default:
+                        return true;
+                        break;
+                }
+                if (res.success === true) {
+                    this.fireEvent("write", this, action, res.data, res, rs, o.request.arg);
+                } else {
+                    this.fireEvent('exception', this, 'remote', action, o, res, rs);
+                }
+                o.request.callback.call(o.request.scope, res.data, res, res.success);
+
+                return false;   // <-- false to prevent intercepted function from running.
+            }, proxy);
         }
-        return this.layout;
+    };
+})();
+
+/**
+ * Ext.data.Response
+ * Experimental.  Do not use directly.
+ */
+Ext.data.Response = function(params, response) {
+    Ext.apply(this, params, {
+        raw: response
+    });
+};
+Ext.data.Response.prototype = {
+    message : null,
+    success : false,
+    status : null,
+    root : null,
+    raw : null,
+
+    getMessage : function() {
+        return this.message;
+    },
+    getSuccess : function() {
+        return this.success;
+    },
+    getStatus : function() {
+        return this.status;
+    },
+    getRoot : function() {
+        return this.root;
     },
+    getRawResponse : function() {
+        return this.raw;
+    }
+};
 
-    // private
-    beforeDestroy : function(){
-        var c;
-        if(this.items){
-            while(c = this.items.first()){
-                this.doRemove(c, true);
-            }
-        }
-        if(this.monitorResize){
-            Ext.EventManager.removeResizeListener(this.doLayout, this);
-        }
-        Ext.destroy(this.layout);
-        Ext.Container.superclass.beforeDestroy.call(this);
+/**
+ * @class Ext.data.Api.Error
+ * @extends Ext.Error
+ * Error class for Ext.data.Api errors
+ */
+Ext.data.Api.Error = Ext.extend(Ext.Error, {
+    constructor : function(message, arg) {
+        this.arg = arg;
+        Ext.Error.call(this, message);
     },
+    name: 'Ext.data.Api'
+});
+Ext.apply(Ext.data.Api.Error.prototype, {
+    lang: {
+        'action-url-undefined': 'No fallback url defined for this action.  When defining a DataProxy api, please be sure to define an url for each CRUD action in Ext.data.Api.actions or define a default url in addition to your api-configuration.',
+        'invalid': 'received an invalid API-configuration.  Please ensure your proxy API-configuration contains only the actions defined in Ext.data.Api.actions',
+        'invalid-url': 'Invalid url.  Please review your proxy configuration.',
+        'execute': 'Attempted to execute an unknown action.  Valid API actions are defined in Ext.data.Api.actions"'
+    }
+});
 
+
+
+/**
+ * @class Ext.data.SortTypes
+ * @singleton
+ * Defines the default sorting (casting?) comparison functions used when sorting data.
+ */
+Ext.data.SortTypes = {
     /**
-     * Bubbles up the component/container heirarchy, calling the specified function with each component. The scope (this) of
-     * function call will be the scope provided or the current component. The arguments to the function
-     * will be the args provided or the current component. If the function returns false at any point,
-     * the bubble is stopped.
-     * @param {Function} fn The function to call
-     * @param {Object} scope (optional) The scope of the function (defaults to current node)
-     * @param {Array} args (optional) The args to call the function with (default to passing the current component)
-     * @return {Ext.Container} this
+     * Default sort that does nothing
+     * @param {Mixed} s The value being converted
+     * @return {Mixed} The comparison value
      */
-    bubble : function(fn, scope, args){
-        var p = this;
-        while(p){
-            if(fn.apply(scope || p, args || [p]) === false){
-                break;
-            }
-            p = p.ownerCt;
-        }
-        return this;
+    none : function(s){
+        return s;
     },
-
+    
     /**
-     * Cascades down the component/container heirarchy from this component (called first), calling the specified function with
-     * each component. The scope (this) of
-     * function call will be the scope provided or the current component. The arguments to the function
-     * will be the args provided or the current component. If the function returns false at any point,
-     * the cascade is stopped on that branch.
-     * @param {Function} fn The function to call
-     * @param {Object} scope (optional) The scope of the function (defaults to current component)
-     * @param {Array} args (optional) The args to call the function with (defaults to passing the current component)
-     * @return {Ext.Container} this
+     * The regular expression used to strip tags
+     * @type {RegExp}
+     * @property
      */
-    cascade : function(fn, scope, args){
-        if(fn.apply(scope || this, args || [this]) !== false){
-            if(this.items){
-                var cs = this.items.items;
-                for(var i = 0, len = cs.length; i < len; i++){
-                    if(cs[i].cascade){
-                        cs[i].cascade(fn, scope, args);
-                    }else{
-                        fn.apply(scope || cs[i], args || [cs[i]]);
-                    }
-                }
-            }
-        }
-        return this;
+    stripTagsRE : /<\/?[^>]+>/gi,
+    
+    /**
+     * Strips all HTML tags to sort on text only
+     * @param {Mixed} s The value being converted
+     * @return {String} The comparison value
+     */
+    asText : function(s){
+        return String(s).replace(this.stripTagsRE, "");
     },
-
+    
     /**
-     * Find a component under this container at any level by id
-     * @param {String} id
-     * @return Ext.Component
+     * Strips all HTML tags to sort on text only - Case insensitive
+     * @param {Mixed} s The value being converted
+     * @return {String} The comparison value
      */
-    findById : function(id){
-        var m, ct = this;
-        this.cascade(function(c){
-            if(ct != c && c.id === id){
-                m = c;
-                return false;
-            }
-        });
-        return m || null;
+    asUCText : function(s){
+        return String(s).toUpperCase().replace(this.stripTagsRE, "");
     },
-
+    
     /**
-     * Find a component under this container at any level by xtype or class
-     * @param {String/Class} xtype The xtype string for a component, or the class of the component directly
-     * @param {Boolean} shallow (optional) False to check whether this Component is descended from the xtype (this is
-     * the default), or true to check whether this Component is directly of the specified xtype.
-     * @return {Array} Array of Ext.Components
+     * Case insensitive string
+     * @param {Mixed} s The value being converted
+     * @return {String} The comparison value
      */
-    findByType : function(xtype, shallow){
-        return this.findBy(function(c){
-            return c.isXType(xtype, shallow);
-        });
+    asUCString : function(s) {
+    	return String(s).toUpperCase();
     },
-
+    
     /**
-     * Find a component under this container at any level by property
-     * @param {String} prop
-     * @param {String} value
-     * @return {Array} Array of Ext.Components
+     * Date sorting
+     * @param {Mixed} s The value being converted
+     * @return {Number} The comparison value
      */
-    find : function(prop, value){
-        return this.findBy(function(c){
-            return c[prop] === value;
-        });
+    asDate : function(s) {
+        if(!s){
+            return 0;
+        }
+        if(Ext.isDate(s)){
+            return s.getTime();
+        }
+    	return Date.parse(String(s));
     },
-
+    
     /**
-     * Find a component under this container at any level by a custom function. If the passed function returns
-     * true, the component will be included in the results. The passed function is called with the arguments (component, this container).
-     * @param {Function} fn The function to call
-     * @param {Object} scope (optional)
-     * @return {Array} Array of Ext.Components
+     * Float sorting
+     * @param {Mixed} s The value being converted
+     * @return {Float} The comparison value
      */
-    findBy : function(fn, scope){
-        var m = [], ct = this;
-        this.cascade(function(c){
-            if(ct != c && fn.call(scope || c, c, ct) === true){
-                m.push(c);
-            }
-        });
-        return m;
+    asFloat : function(s) {
+    	var val = parseFloat(String(s).replace(/,/g, ""));
+    	return isNaN(val) ? 0 : val;
     },
-
+    
     /**
-     * Get a component contained by this container (alias for items.get(key))
-     * @param {String/Number} key The index or id of the component
-     * @return {Ext.Component} Ext.Component
+     * Integer sorting
+     * @param {Mixed} s The value being converted
+     * @return {Number} The comparison value
      */
-    get : function(key){
-        return this.items.get(key);
+    asInt : function(s) {
+        var val = parseInt(String(s).replace(/,/g, ""), 10);
+        return isNaN(val) ? 0 : val;
     }
-});
+};/**
+ * @class Ext.data.Record
+ * Instances of this class encapsulate both Record definition information, and Record
+ * value information for use in {@link Ext.data.Store} objects, or any code which needs
+ * to access Records cached in an {@link Ext.data.Store} object.
+ * Constructors for this class are generated by passing an Array of field definition objects to {@link #create}.
+ * Instances are usually only created by {@link Ext.data.Reader} implementations when processing unformatted data
+ * objects.
+ * Note that an instance of a Record class may only belong to one {@link Ext.data.Store Store} at a time.
+ * In order to copy data from one Store to another, use the {@link #copy} method to create an exact
+ * copy of the Record, and insert the new instance into the other Store.
+ * When serializing a Record for submission to the server, be aware that it contains many private
+ * properties, and also a reference to its owning Store which in turn holds references to its Records.
+ * This means that a whole Record may not be encoded using {@link Ext.util.JSON.encode}. Instead, use the
+ * {@link #data} and {@link #id} properties.
+ * Record objects generated by this constructor inherit all the methods of Ext.data.Record listed below.
+ * @constructor
+ * This constructor should not be used to create Record objects. Instead, use {@link #create} to
+ * generate a subclass of Ext.data.Record configured with information about its constituent fields.

+ * 
The generated constructor has the same signature as this constructor.
+ * @param {Object} data (Optional) An object, the properties of which provide values for the new Record's
+ * fields. If not specified the {@link Ext.data.Field#defaultValue defaultValue}
+ * for each field will be assigned.
+ * @param {Object} id (Optional) The id of the Record. The id is used by the
+ * {@link Ext.data.Store} object which owns the Record to index its collection
+ * of Records (therefore this id should be unique within each store). If an
+ * id is not specified a {@link #phantom}
+ * Record will be created with an {@link #Record.id automatically generated id}.
+ */
+Ext.data.Record = function(data, id){
+    // if no id, call the auto id method
+    this.id = (id || id === 0) ? id : Ext.data.Record.id(this);
+    this.data = data || {};
+};
 
-Ext.Container.LAYOUTS = {};
-Ext.reg('container', Ext.Container);
 /**
- * @class Ext.layout.ContainerLayout
- * This class is intended to be extended or created via the {@link Ext.Container#layout layout}
- * configuration property.  See {@link Ext.Container#layout} for additional details.
+ * Generate a constructor for a specific Record layout.
+ * @param {Array} o An Array of {@link Ext.data.Field Field} definition objects.
+ * The constructor generated by this method may be used to create new Record instances. The data
+ * object must contain properties named after the {@link Ext.data.Field field}
+ * {@link Ext.data.Field#name}s.  Example usage:
+// create a Record constructor from a description of the fields
+var TopicRecord = Ext.data.Record.create([ // creates a subclass of Ext.data.Record
+    {{@link Ext.data.Field#name name}: 'title', {@link Ext.data.Field#mapping mapping}: 'topic_title'},
+    {name: 'author', mapping: 'username', allowBlank: false},
+    {name: 'totalPosts', mapping: 'topic_replies', type: 'int'},
+    {name: 'lastPost', mapping: 'post_time', type: 'date'},
+    {name: 'lastPoster', mapping: 'user2'},
+    {name: 'excerpt', mapping: 'post_text', allowBlank: false},
+    // In the simplest case, if no properties other than name are required,
+    // a field definition may consist of just a String for the field name.
+    'signature'
+]);
+
+// create Record instance
+var myNewRecord = new TopicRecord(
+    {
+        title: 'Do my job please',
+        author: 'noobie',
+        totalPosts: 1,
+        lastPost: new Date(),
+        lastPoster: 'Animal',
+        excerpt: 'No way dude!',
+        signature: ''
+    },
+    id // optionally specify the id of the record otherwise {@link #Record.id one is auto-assigned}
+);
+myStore.{@link Ext.data.Store#add add}(myNewRecord);
+
+ * @method create
+ * @return {Function} A constructor which is used to create new Records according
+ * to the definition. The constructor has the same signature as {@link #Record}.
+ * @static
  */
-Ext.layout.ContainerLayout = Ext.extend(Object, {
+Ext.data.Record.create = function(o){
+    var f = Ext.extend(Ext.data.Record, {});
+    var p = f.prototype;
+    p.fields = new Ext.util.MixedCollection(false, function(field){
+        return field.name;
+    });
+    for(var i = 0, len = o.length; i < len; i++){
+        p.fields.add(new Ext.data.Field(o[i]));
+    }
+    f.getField = function(name){
+        return p.fields.get(name);
+    };
+    return f;
+};
+
+Ext.data.Record.PREFIX = 'ext-record';
+Ext.data.Record.AUTO_ID = 1;
+Ext.data.Record.EDIT = 'edit';
+Ext.data.Record.REJECT = 'reject';
+Ext.data.Record.COMMIT = 'commit';
+
+
+/**
+ * Generates a sequential id. This method is typically called when a record is {@link #create}d
+ * and {@link #Record no id has been specified}. The returned id takes the form:
+ * {PREFIX}-{AUTO_ID}.
+ * PREFIX : StringExt.data.Record.PREFIX
+ * (defaults to 'ext-record')
+ * AUTO_ID : StringExt.data.Record.AUTO_ID
+ * (defaults to 1 initially)
+ * 
+ * @param {Record} rec The record being created.  The record does not exist, it's a {@link #phantom}.
+ * @return {String} auto-generated string id, "ext-record-i++';
+ */
+Ext.data.Record.id = function(rec) {
+    rec.phantom = true;
+    return [Ext.data.Record.PREFIX, '-', Ext.data.Record.AUTO_ID++].join('');
+};
+
+Ext.data.Record.prototype = {
     /**
-     * @cfg {String} extraCls
-     * An optional extra CSS class that will be added to the container. This can be useful for adding
-     * customized styles to the container or any of its children using standard CSS rules. See
-     * {@link Ext.Component}.{@link Ext.Component#ctCls ctCls} also.
-     * Note: extraCls defaults to '' except for the following classes
-     * which assign a value by default:
-     * 

-     * {@link Ext.layout.AbsoluteLayout Absolute Layout} : 'x-abs-layout-item'
-     * {@link Ext.layout.Box Box Layout} : 'x-box-item'
-     * {@link Ext.layout.ColumnLayout Column Layout} : 'x-column'
-     * 
-     * To configure the above Classes with an extra CSS class append to the default.  For example,
-     * for ColumnLayout:
-     * extraCls: 'x-column custom-class'
-     * 
-     * 
+     * This property is stored in the Record definition's prototype
+     * A MixedCollection containing the defined {@link Ext.data.Field Field}s for this Record.  Read-only.
+     * @property fields
+     * @type Ext.util.MixedCollection
      */
     /**
-     * @cfg {Boolean} renderHidden
-     * True to hide each contained item on render (defaults to false).
+     * An object hash representing the data for this Record. Every field name in the Record definition
+     * is represented by a property of that name in this object. Note that unless you specified a field
+     * with {@link Ext.data.Field#name name} "id" in the Record definition, this will not contain
+     * an id property.
+     * @property data
+     * @type {Object}
      */
-
     /**
-     * A reference to the {@link Ext.Component} that is active.  For example, 
-     * if(myPanel.layout.activeItem.id == 'item-1') { ... }
-     * 
-     * activeItem only applies to layout styles that can display items one at a time
-     * (like {@link Ext.layout.AccordionLayout}, {@link Ext.layout.CardLayout}
-     * and {@link Ext.layout.FitLayout}).  Read-only.  Related to {@link Ext.Container#activeItem}.
-     * @type {Ext.Component}
-     * @property activeItem
+     * The unique ID of the Record {@link #Record as specified at construction time}.
+     * @property id
+     * @type {Object}
+     */
+    /**
+     * Only present if this Record was created by an {@link Ext.data.XmlReader XmlReader}.
+     * The XML element which was the source of the data for this Record.
+     * @property node
+     * @type {XMLElement}
+     */
+    /**
+     * Only present if this Record was created by an {@link Ext.data.ArrayReader ArrayReader} or a {@link Ext.data.JsonReader JsonReader}.
+     * The Array or object which was the source of the data for this Record.
+     * @property json
+     * @type {Array|Object}
+     */
+    /**
+     * Readonly flag - true if this Record has been modified.
+     * @type Boolean
+     */
+    dirty : false,
+    editing : false,
+    error : null,
+    /**
+     * This object contains a key and value storing the original values of all modified
+     * fields or is null if no fields have been modified.
+     * @property modified
+     * @type {Object}
+     */
+    modified : null,
+    /**
+     * true when the record does not yet exist in a server-side database (see
+     * {@link #markDirty}).  Any record which has a real database pk set as its id property
+     * is NOT a phantom -- it's real.
+     * @property phantom
+     * @type {Boolean}
      */
+    phantom : false,
 
     // private
-    monitorResize:false,
-    // private
-    activeItem : null,
-
-    constructor : function(config){
-        this.id = Ext.id(null, 'ext-layout-');
-        Ext.apply(this, config);
+    join : function(store){
+        /**
+         * The {@link Ext.data.Store} to which this Record belongs.
+         * @property store
+         * @type {Ext.data.Store}
+         */
+        this.store = store;
     },
 
-    type: 'container',
+    /**
+     * Set the {@link Ext.data.Field#name named field} to the specified value.  For example:
+     * 
+// record has a field named 'firstname'
+var Employee = Ext.data.Record.{@link #create}([
+    {name: 'firstname'},
+    ...
+]);
 
-    /* Workaround for how IE measures autoWidth elements.  It prefers bottom-up measurements
-      whereas other browser prefer top-down.  We will hide all target child elements before we measure and
-      put them back to get an accurate measurement.
-    */
-    IEMeasureHack : function(target, viewFlag) {
-        var tChildren = target.dom.childNodes, tLen = tChildren.length, c, d = [], e, i, ret;
-        for (i = 0 ; i < tLen ; i++) {
-            c = tChildren[i];
-            e = Ext.get(c);
-            if (e) {
-                d[i] = e.getStyle('display');
-                e.setStyle({display: 'none'});
-            }
+// update the 2nd record in the store:
+var rec = myStore.{@link Ext.data.Store#getAt getAt}(1);
+
+// set the value (shows dirty flag):
+rec.set('firstname', 'Betty');
+
+// commit the change (removes dirty flag):
+rec.{@link #commit}();
+
+// update the record in the store, bypass setting dirty flag,
+// and do not store the change in the {@link Ext.data.Store#getModifiedRecords modified records}
+rec.{@link #data}['firstname'] = 'Wilma'; // updates record, but not the view
+rec.{@link #commit}(); // updates the view
+     * 
+     * Notes:
+     * If the store has a writer and autoSave=true, each set()
+     * will execute an XHR to the server.
+     * Use {@link #beginEdit} to prevent the store's update
+     * event firing while using set().
+     * Use {@link #endEdit} to have the store's update
+     * event fire.
+     * 
+     * @param {String} name The {@link Ext.data.Field#name name of the field} to set.
+     * @param {String/Object/Array} value The value to set the field to.
+     */
+    set : function(name, value){
+        var encode = Ext.isPrimitive(value) ? String : Ext.encode;
+        if(encode(this.data[name]) == encode(value)) {
+            return;
+        }        
+        this.dirty = true;
+        if(!this.modified){
+            this.modified = {};
         }
-        ret = target ? target.getViewSize(viewFlag) : {};
-        for (i = 0 ; i < tLen ; i++) {
-            c = tChildren[i];
-            e = Ext.get(c);
-            if (e) {
-                e.setStyle({display: d[i]});
-            }
+        if(this.modified[name] === undefined){
+            this.modified[name] = this.data[name];
+        }
+        this.data[name] = value;
+        if(!this.editing){
+            this.afterEdit();
         }
-        return ret;
     },
 
-    // Placeholder for the derived layouts
-    getLayoutTargetSize : Ext.EmptyFn,
-
     // private
-    layout : function(){
-        var ct = this.container, target = ct.getLayoutTarget();
-        if(!(this.hasLayout || Ext.isEmpty(this.targetCls))){
-            target.addClass(this.targetCls);
+    afterEdit : function(){
+        if (this.store != undefined && typeof this.store.afterEdit == "function") {
+            this.store.afterEdit(this);
         }
-        this.onLayout(ct, target);
-        ct.fireEvent('afterlayout', ct, this);
     },
 
     // private
-    onLayout : function(ct, target){
-        this.renderAll(ct, target);
+    afterReject : function(){
+        if(this.store){
+            this.store.afterReject(this);
+        }
     },
 
     // private
-    isValidParent : function(c, target){
-        return target && c.getPositionEl().dom.parentNode == (target.dom || target);
+    afterCommit : function(){
+        if(this.store){
+            this.store.afterCommit(this);
+        }
     },
 
-    // private
-    renderAll : function(ct, target){
-        var items = ct.items.items, i, c, len = items.length;
-        for(i = 0; i < len; i++) {
-            c = items[i];
-            if(c && (!c.rendered || !this.isValidParent(c, target))){
-                this.renderItem(c, i, target);
-            }
-        }
+    /**
+     * Get the value of the {@link Ext.data.Field#name named field}.
+     * @param {String} name The {@link Ext.data.Field#name name of the field} to get the value of.
+     * @return {Object} The value of the field.
+     */
+    get : function(name){
+        return this.data[name];
     },
 
-    // private
-    renderItem : function(c, position, target){
-        if(c){
-            if(!c.rendered){
-                c.render(target, position);
-                this.configureItem(c, position);
-            }else if(!this.isValidParent(c, target)){
-                if(Ext.isNumber(position)){
-                    position = target.dom.childNodes[position];
-                }
-                target.dom.insertBefore(c.getPositionEl().dom, position || null);
-                c.container = target;
-                this.configureItem(c, position);
-            }
-        }
+    /**
+     * Begin an edit. While in edit mode, no events (e.g.. the update event)
+     * are relayed to the containing store.
+     * See also: {@link #endEdit} and {@link #cancelEdit}.
+     */
+    beginEdit : function(){
+        this.editing = true;
+        this.modified = this.modified || {};
     },
 
-    // private.
-    // Get all rendered items to lay out.
-    getRenderedItems: function(ct){
-        var t = ct.getLayoutTarget(), cti = ct.items.items, len = cti.length, i, c, items = [];
-        for (i = 0; i < len; i++) {
-            if((c = cti[i]).rendered && this.isValidParent(c, t)){
-                items.push(c);
-            }
-        };
-        return items;
+    /**
+     * Cancels all changes made in the current edit operation.
+     */
+    cancelEdit : function(){
+        this.editing = false;
+        delete this.modified;
     },
 
-    // private
-    configureItem: function(c, position){
-        if(this.extraCls){
-            var t = c.getPositionEl ? c.getPositionEl() : c;
-            t.addClass(this.extraCls);
+    /**
+     * End an edit. If any data was modified, the containing store is notified
+     * (ie, the store's update event will fire).
+     */
+    endEdit : function(){
+        this.editing = false;
+        if(this.dirty){
+            this.afterEdit();
         }
-        // If we are forcing a layout, do so *before* we hide so elements have height/width
-        if(c.doLayout && this.forceLayout){
-            c.doLayout();
+    },
+
+    /**
+     * Usually called by the {@link Ext.data.Store} which owns the Record.
+     * Rejects all changes made to the Record since either creation, or the last commit operation.
+     * Modified fields are reverted to their original values.
+     * Developers should subscribe to the {@link Ext.data.Store#update} event
+     * to have their code notified of reject operations.
+     * @param {Boolean} silent (optional) True to skip notification of the owning
+     * store of the change (defaults to false)
+     */
+    reject : function(silent){
+        var m = this.modified;
+        for(var n in m){
+            if(typeof m[n] != "function"){
+                this.data[n] = m[n];
+            }
         }
-        if (this.renderHidden && c != this.activeItem) {
-            c.hide();
+        this.dirty = false;
+        delete this.modified;
+        this.editing = false;
+        if(silent !== true){
+            this.afterReject();
         }
     },
 
-    onRemove: function(c){
-         if(this.activeItem == c){
-            delete this.activeItem;
-         }
-         if(c.rendered && this.extraCls){
-            var t = c.getPositionEl ? c.getPositionEl() : c;
-            t.removeClass(this.extraCls);
+    /**
+     * Usually called by the {@link Ext.data.Store} which owns the Record.
+     * Commits all changes made to the Record since either creation, or the last commit operation.
+     * Developers should subscribe to the {@link Ext.data.Store#update} event
+     * to have their code notified of commit operations.
+     * @param {Boolean} silent (optional) True to skip notification of the owning
+     * store of the change (defaults to false)
+     */
+    commit : function(silent){
+        this.dirty = false;
+        delete this.modified;
+        this.editing = false;
+        if(silent !== true){
+            this.afterCommit();
         }
     },
 
-    afterRemove: function(c){
-        if(c.removeRestore){
-            c.removeMode = 'container';
-            delete c.removeRestore;
+    /**
+     * Gets a hash of only the fields that have been modified since this Record was created or commited.
+     * @return Object
+     */
+    getChanges : function(){
+        var m = this.modified, cs = {};
+        for(var n in m){
+            if(m.hasOwnProperty(n)){
+                cs[n] = this.data[n];
+            }
         }
+        return cs;
     },
 
     // private
-    onResize: function(){
-        var ct = this.container,
-            b;
-        if(ct.collapsed){
-            return;
-        }
-        if(b = ct.bufferResize){
-            // Only allow if we should buffer the layout
-            if(ct.shouldBufferLayout()){
-                if(!this.resizeTask){
-                    this.resizeTask = new Ext.util.DelayedTask(this.runLayout, this);
-                    this.resizeBuffer = Ext.isNumber(b) ? b : 50;
-                }
-                ct.layoutPending = true;
-                this.resizeTask.delay(this.resizeBuffer);
-            }
-        }else{
-            this.runLayout();
-        }
+    hasError : function(){
+        return this.error !== null;
+    },
+
+    // private
+    clearError : function(){
+        this.error = null;
+    },
+
+    /**
+     * Creates a copy (clone) of this Record.
+     * @param {String} id (optional) A new Record id, defaults to the id
+     * of the record being copied. See {@link #id}. 
+     * To generate a phantom record with a new id use:
+var rec = record.copy(); // clone the record
+Ext.data.Record.id(rec); // automatically generate a unique sequential id
+     * 
+     * @return {Record}
+     */
+    copy : function(newId) {
+        return new this.constructor(Ext.apply({}, this.data), newId || this.id);
     },
 
-    runLayout: function(){
-        var ct = this.container;
-        // AutoLayout is known to require the recursive doLayout call, others need this currently (BorderLayout for example)
-        // but shouldn't.  A more extensive review will take place for 3.2 which requires a ContainerMgr with hierarchy lookups.
-        //this.layout();
-        //ct.onLayout();
-        ct.doLayout();
-        delete ct.layoutPending;
+    /**
+     * Returns true if the passed field name has been {@link #modified}
+     * since the load or last commit.
+     * @param {String} fieldName {@link Ext.data.Field.{@link Ext.data.Field#name}
+     * @return {Boolean}
+     */
+    isModified : function(fieldName){
+        return !!(this.modified && this.modified.hasOwnProperty(fieldName));
     },
 
-    // private
-    setContainer : function(ct){
-        if (!Ext.LayoutManager) {
-            Ext.LayoutManager = {};
-        }
-
-        /* This monitorResize flag will be renamed soon as to avoid confusion
-        * with the Container version which hooks onWindowResize to doLayout
-        *
-        * monitorResize flag in this context attaches the resize event between
-        * a container and it's layout
-        */
-
-        if(this.monitorResize && ct != this.container){
-            var old = this.container;
-            if(old){
-                old.un(old.resizeEvent, this.onResize, this);
-            }
-            if(ct){
-                ct.on(ct.resizeEvent, this.onResize, this);
-            }
-        }
-        this.container = ct;
+    /**
+     * By default returns false if any {@link Ext.data.Field field} within the
+     * record configured with {@link Ext.data.Field#allowBlank} = false returns
+     * true from an {@link Ext}.{@link Ext#isEmpty isempty} test.
+     * @return {Boolean}
+     */
+    isValid : function() {
+        return this.fields.find(function(f) {
+            return (f.allowBlank === false && Ext.isEmpty(this.data[f.name])) ? true : false;
+        },this) ? false : true;
     },
 
-    // private
-    parseMargins : function(v){
-        if(Ext.isNumber(v)){
-            v = v.toString();
+    /**
+     * Marks this Record as {@link #dirty}.  This method
+     * is used interally when adding {@link #phantom} records to a
+     * {@link Ext.data.Store#writer writer enabled store}.
+     * 
Marking a record {@link #dirty} causes the phantom to
+     * be returned by {@link Ext.data.Store#getModifiedRecords} where it will
+     * have a create action composed for it during {@link Ext.data.Store#save store save}
+     * operations.
+     */
+    markDirty : function(){
+        this.dirty = true;
+        if(!this.modified){
+            this.modified = {};
         }
-        var ms = v.split(' ');
-        var len = ms.length;
-        if(len == 1){
-            ms[1] = ms[2] = ms[3] = ms[0];
-        } else if(len == 2){
-            ms[2] = ms[0];
-            ms[3] = ms[1];
-        } else if(len == 3){
-            ms[3] = ms[1];
+        this.fields.each(function(f) {
+            this.modified[f.name] = this.data[f.name];
+        },this);
+    }
+};
+/**
+ * @class Ext.StoreMgr
+ * @extends Ext.util.MixedCollection
+ * The default global group of stores.
+ * @singleton
+ */
+Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), {
+    /**
+     * @cfg {Object} listeners @hide
+     */
+
+    /**
+     * Registers one or more Stores with the StoreMgr. You do not normally need to register stores
+     * manually.  Any store initialized with a {@link Ext.data.Store#storeId} will be auto-registered. 
+     * @param {Ext.data.Store} store1 A Store instance
+     * @param {Ext.data.Store} store2 (optional)
+     * @param {Ext.data.Store} etc... (optional)
+     */
+    register : function(){
+        for(var i = 0, s; (s = arguments[i]); i++){
+            this.add(s);
         }
-        return {
-            top:parseInt(ms[0], 10) || 0,
-            right:parseInt(ms[1], 10) || 0,
-            bottom:parseInt(ms[2], 10) || 0,
-            left:parseInt(ms[3], 10) || 0
-        };
     },
 
     /**
-     * The {@link Ext.Template Ext.Template} used by Field rendering layout classes (such as
-     * {@link Ext.layout.FormLayout}) to create the DOM structure of a fully wrapped,
-     * labeled and styled form Field. A default Template is supplied, but this may be
-     * overriden to create custom field structures. The template processes values returned from
-     * {@link Ext.layout.FormLayout#getTemplateArgs}.
-     * @property fieldTpl
-     * @type Ext.Template
+     * Unregisters one or more Stores with the StoreMgr
+     * @param {String/Object} id1 The id of the Store, or a Store instance
+     * @param {String/Object} id2 (optional)
+     * @param {String/Object} etc... (optional)
      */
-    fieldTpl: (function() {
-        var t = new Ext.Template(
-            '',
-                '{label}{labelSeparator}',
-                '',
-                '
',
-            ''
-        );
-        t.disableFormats = true;
-        return t.compile();
-    })(),
+    unregister : function(){
+        for(var i = 0, s; (s = arguments[i]); i++){
+            this.remove(this.lookup(s));
+        }
+    },
 
-    /*
-     * Destroys this layout. This is a template method that is empty by default, but should be implemented
-     * by subclasses that require explicit destruction to purge event handlers or remove DOM nodes.
-     * @protected
+    /**
+     * Gets a registered Store by id
+     * @param {String/Object} id The id of the Store, or a Store instance
+     * @return {Ext.data.Store}
      */
-    destroy : function(){
-        if(!Ext.isEmpty(this.targetCls)){
-            var target = this.container.getLayoutTarget();
-            if(target){
-                target.removeClass(this.targetCls);
+    lookup : function(id){
+        if(Ext.isArray(id)){
+            var fields = ['field1'], expand = !Ext.isArray(id[0]);
+            if(!expand){
+                for(var i = 2, len = id[0].length; i <= len; ++i){
+                    fields.push('field' + i);
+                }
             }
+            return new Ext.data.ArrayStore({
+                fields: fields,
+                data: id,
+                expandData: expand,
+                autoDestroy: true,
+                autoCreated: true
+
+            });
         }
+        return Ext.isObject(id) ? (id.events ? id : Ext.create(id, 'store')) : this.get(id);
+    },
+
+    // getKey implementation for MixedCollection
+    getKey : function(o){
+         return o.storeId;
     }
 });/**
- * @class Ext.layout.AutoLayout
- * The AutoLayout is the default layout manager delegated by {@link Ext.Container} to
- * render any child Components when no {@link Ext.Container#layout layout} is configured into
- * a {@link Ext.Container Container}. ContainerLayout provides the basic foundation for all other layout
- * classes in Ext. It simply renders all child Components into the Container, performing no sizing or
- * positioning services. To utilize a layout that provides sizing and positioning of child Components,
- * specify an appropriate {@link Ext.Container#layout layout}.
- */
-Ext.layout.AutoLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    runLayout: function(){
-        var ct = this.container;
-        ct.doLayout();
-        delete ct.layoutPending;
-    }
+ * @class Ext.data.Store
+ * @extends Ext.util.Observable
+ * The Store class encapsulates a client side cache of {@link Ext.data.Record Record}
+ * objects which provide input data for Components such as the {@link Ext.grid.GridPanel GridPanel},
+ * the {@link Ext.form.ComboBox ComboBox}, or the {@link Ext.DataView DataView}.
+ * Retrieving Data
+ * A Store object may access a data object using:

+ * {@link #proxy configured implementation} of {@link Ext.data.DataProxy DataProxy}
+ * {@link #data} to automatically pass in data
+ * {@link #loadData} to manually pass in data
+ * 

+ * Reading Data
+ * A Store object has no inherent knowledge of the format of the data object (it could be
+ * an Array, XML, or JSON). A Store object uses an appropriate {@link #reader configured implementation}
+ * of a {@link Ext.data.DataReader DataReader} to create {@link Ext.data.Record Record} instances from the data
+ * object.
+ * Store Types
+ * There are several implementations of Store available which are customized for use with
+ * a specific DataReader implementation.  Here is an example using an ArrayStore which implicitly
+ * creates a reader commensurate to an Array data object.
+ * 
+var myStore = new Ext.data.ArrayStore({
+    fields: ['fullname', 'first'],
+    idIndex: 0 // id for each record will be the first element
 });
-
-Ext.Container.LAYOUTS['auto'] = Ext.layout.AutoLayout;
-/**
- * @class Ext.layout.FitLayout
- * @extends Ext.layout.ContainerLayout
- * This is a base class for layouts that contain a single item that automatically expands to fill the layout's
- * container.  This class is intended to be extended or created via the layout:'fit' {@link Ext.Container#layout}
- * config, and should generally not need to be created directly via the new keyword.
- * FitLayout does not have any direct config options (other than inherited ones).  To fit a panel to a container
- * using FitLayout, simply set layout:'fit' on the container and add a single panel to it.  If the container has
- * multiple panels, only the first one will be displayed.  Example usage:
- * 
-var p = new Ext.Panel({
-    title: 'Fit Layout',
-    layout:'fit',
-    items: {
-        title: 'Inner Panel',
-        html: '<p>This is the inner panel content</p>',
-        border: false
-    }
-});
-
- */
-Ext.layout.FitLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    // private
-    monitorResize:true,
-
-    type: 'fit',
-
-    getLayoutTargetSize : function() {
-        var target = this.container.getLayoutTarget();
-        if (!target) {
-            return {};
-        }
-        // Style Sized (scrollbars not included)
-        return target.getStyleSize();
-    },
-
-    // private
-    onLayout : function(ct, target){
-        Ext.layout.FitLayout.superclass.onLayout.call(this, ct, target);
-        if(!ct.collapsed){
-            this.setItemSize(this.activeItem || ct.items.itemAt(0), this.getLayoutTargetSize());
-        }
-    },
-
-    // private
-    setItemSize : function(item, size){
-        if(item && size.height > 0){ // display none?
-            item.setSize(size);
-        }
-    }
-});
-Ext.Container.LAYOUTS['fit'] = Ext.layout.FitLayout;/**
- * @class Ext.layout.CardLayout
- * @extends Ext.layout.FitLayout
- * This layout manages multiple child Components, each fitted to the Container, where only a single child Component can be
- * visible at any given time.  This layout style is most commonly used for wizards, tab implementations, etc.
- * This class is intended to be extended or created via the layout:'card' {@link Ext.Container#layout} config,
- * and should generally not need to be created directly via the new keyword.
- * The CardLayout's focal method is {@link #setActiveItem}.  Since only one panel is displayed at a time,
- * the only way to move from one Component to the next is by calling setActiveItem, passing the id or index of
- * the next panel to display.  The layout itself does not provide a user interface for handling this navigation,
- * so that functionality must be provided by the developer.
- * In the following example, a simplistic wizard setup is demonstrated.  A button bar is added
- * to the footer of the containing panel to provide navigation buttons.  The buttons will be handled by a
- * common navigation routine -- for this example, the implementation of that routine has been ommitted since
- * it can be any type of custom logic.  Note that other uses of a CardLayout (like a tab control) would require a
- * completely different implementation.  For serious implementations, a better approach would be to extend
- * CardLayout to provide the custom functionality needed.  Example usage:
- * 
-var navHandler = function(direction){
-    // This routine could contain business logic required to manage the navigation steps.
-    // It would call setActiveItem as needed, manage navigation button state, handle any
-    // branching logic that might be required, handle alternate actions like cancellation
-    // or finalization, etc.  A complete wizard implementation could get pretty
-    // sophisticated depending on the complexity required, and should probably be
-    // done as a subclass of CardLayout in a real-world implementation.
-};
-
-var card = new Ext.Panel({
-    title: 'Example Wizard',
-    layout:'card',
-    activeItem: 0, // make sure the active item is set on the container config!
-    bodyStyle: 'padding:15px',
-    defaults: {
-        // applied to each contained panel
-        border:false
-    },
-    // just an example of one possible navigation scheme, using buttons
-    bbar: [
-        {
-            id: 'move-prev',
-            text: 'Back',
-            handler: navHandler.createDelegate(this, [-1]),
-            disabled: true
-        },
-        '->', // greedy spacer so that the buttons are aligned to each side
-        {
-            id: 'move-next',
-            text: 'Next',
-            handler: navHandler.createDelegate(this, [1])
-        }
-    ],
-    // the panels (or "cards") within the layout
-    items: [{
-        id: 'card-0',
-        html: '<h1>Welcome to the Wizard!</h1><p>Step 1 of 3</p>'
-    },{
-        id: 'card-1',
-        html: '<p>Step 2 of 3</p>'
-    },{
-        id: 'card-2',
-        html: '<h1>Congratulations!</h1><p>Step 3 of 3 - Complete</p>'
-    }]
-});
-
- */
-Ext.layout.CardLayout = Ext.extend(Ext.layout.FitLayout, {
-    /**
-     * @cfg {Boolean} deferredRender
-     * True to render each contained item at the time it becomes active, false to render all contained items
-     * as soon as the layout is rendered (defaults to false).  If there is a significant amount of content or
-     * a lot of heavy controls being rendered into panels that are not displayed by default, setting this to
-     * true might improve performance.
-     */
-    deferredRender : false,
-
-    /**
-     * @cfg {Boolean} layoutOnCardChange
-     * True to force a layout of the active item when the active card is changed. Defaults to false.
-     */
-    layoutOnCardChange : false,
-
-    /**
-     * @cfg {Boolean} renderHidden @hide
-     */
-    // private
-    renderHidden : true,
-
-    type: 'card',
-
-    constructor: function(config){
-        Ext.layout.CardLayout.superclass.constructor.call(this, config);
-    },
-
-    /**
-     * Sets the active (visible) item in the layout.
-     * @param {String/Number} item The string component id or numeric index of the item to activate
-     */
-    setActiveItem : function(item){
-        var ai = this.activeItem,
-            ct = this.container;
-        item = ct.getComponent(item);
-
-        // Is this a valid, different card?
-        if(item && ai != item){
-
-            // Changing cards, hide the current one
-            if(ai){
-                ai.hide();
-                if (ai.hidden !== true) {
-                    return false;
-                }
-                ai.fireEvent('deactivate', ai);
-            }
-            // Change activeItem reference
-            this.activeItem = item;
-
-            // The container is about to get a recursive layout, remove any deferLayout reference
-            // because it will trigger a redundant layout.
-            delete item.deferLayout;
-
-            // Show the new component
-            item.show();
-
-            this.layout();
-
-            if(item.doLayout){
-                item.doLayout();
-            }
-            item.fireEvent('activate', item);
-        }
-    },
-
-    // private
-    renderAll : function(ct, target){
-        if(this.deferredRender){
-            this.renderItem(this.activeItem, undefined, target);
-        }else{
-            Ext.layout.CardLayout.superclass.renderAll.call(this, ct, target);
-        }
-    }
-});
-Ext.Container.LAYOUTS['card'] = Ext.layout.CardLayout;/**
- * @class Ext.layout.AnchorLayout
- * @extends Ext.layout.ContainerLayout
- * This is a layout that enables anchoring of contained elements relative to the container's dimensions.
- * If the container is resized, all anchored items are automatically rerendered according to their
- * {@link #anchor} rules.
- * This class is intended to be extended or created via the layout:'anchor' {@link Ext.Container#layout}
- * config, and should generally not need to be created directly via the new keyword.
- * AnchorLayout does not have any direct config options (other than inherited ones). By default,
- * AnchorLayout will calculate anchor measurements based on the size of the container itself. However, the
- * container using the AnchorLayout can supply an anchoring-specific config property of anchorSize.
- * If anchorSize is specifed, the layout will use it as a virtual container for the purposes of calculating
- * anchor measurements based on it instead, allowing the container to be sized independently of the anchoring
- * logic if necessary.  For example:
+ * 
+ * For custom implementations create a basic {@link Ext.data.Store} configured as needed:
  * 
-var viewport = new Ext.Viewport({
-    layout:'anchor',
-    anchorSize: {width:800, height:600},
-    items:[{
-        title:'Item 1',
-        html:'Content 1',
-        width:800,
-        anchor:'right 20%'
-    },{
-        title:'Item 2',
-        html:'Content 2',
-        width:300,
-        anchor:'50% 30%'
-    },{
-        title:'Item 3',
-        html:'Content 3',
-        width:600,
-        anchor:'-100 50%'
-    }]
+// create a {@link Ext.data.Record Record} constructor:
+var rt = Ext.data.Record.create([
+    {name: 'fullname'},
+    {name: 'first'}
+]);
+var myStore = new Ext.data.Store({
+    // explicitly create reader
+    reader: new Ext.data.ArrayReader(
+        {
+            idIndex: 0  // id for each record will be the first element
+        },
+        rt // recordType
+    )
 });
  * 
+ * Load some data into store (note the data object is an array which corresponds to the reader):
+ * 
+var myData = [
+    [1, 'Fred Flintstone', 'Fred'],  // note that id for the record is the first element
+    [2, 'Barney Rubble', 'Barney']
+];
+myStore.loadData(myData);
+ * 
+ * Records are cached and made available through accessor functions.  An example of adding
+ * a record to the store:
+ * 
+var defaultData = {
+    fullname: 'Full Name',
+    first: 'First Name'
+};
+var recId = 100; // provide unique id for the record
+var r = new myStore.recordType(defaultData, ++recId); // create new record
+myStore.{@link #insert}(0, r); // insert a new record into the store (also see {@link #add})
+ * 
+ * Writing Data
+ * And new in Ext version 3, use the new {@link Ext.data.DataWriter DataWriter} to create an automated, Writable Store
+ * along with RESTful features.
+ * @constructor
+ * Creates a new Store.
+ * @param {Object} config A config object containing the objects needed for the Store to access data,
+ * and read the data into Records.
+ * @xtype store
  */
-Ext.layout.AnchorLayout = Ext.extend(Ext.layout.ContainerLayout, {
+Ext.data.Store = Ext.extend(Ext.util.Observable, {
     /**
-     * @cfg {String} anchor
-     * 
This configuation option is to be applied to child items of a container managed by
-     * this layout (ie. configured with layout:'anchor').


-     *
-     * This value is what tells the layout how an item should be anchored to the container. items
-     * added to an AnchorLayout accept an anchoring-specific config property of anchor which is a string
-     * containing two values: the horizontal anchor value and the vertical anchor value (for example, '100% 50%').
-     * The following types of anchor values are supported:

-     *
-     * Percentage : Any value between 1 and 100, expressed as a percentage.
-     * The first anchor is the percentage width that the item should take up within the container, and the
-     * second is the percentage height.  For example:
-// two values specified
-anchor: '100% 50%' // render item complete width of the container and
-                   // 1/2 height of the container
-// one value specified
-anchor: '100%'     // the width value; the height will default to auto
-     * 
-     *
-     * Offsets : Any positive or negative integer value.
-     * This is a raw adjustment where the first anchor is the offset from the right edge of the container,
-     * and the second is the offset from the bottom edge. For example:
-// two values specified
-anchor: '-50 -100' // render item the complete width of the container
-                   // minus 50 pixels and
-                   // the complete height minus 100 pixels.
-// one value specified
-anchor: '-50'      // anchor value is assumed to be the right offset value
-                   // bottom offset will default to 0
-     * 
-     *
-     * Sides : Valid values are 'right' (or 'r') and 'bottom'
-     * (or 'b').
-     * Either the container must have a fixed size or an anchorSize config value defined at render time in
-     * order for these to have any effect.
-     *
-     * Mixed : 
-     * Anchor values can also be mixed as needed.  For example, to render the width offset from the container
-     * right edge by 50 pixels and 75% of the container's height use:
-     * 
-anchor: '-50 75%'
-     * 
-     *
-     *
-     * 
+     * @cfg {String} storeId If passed, the id to use to register with the {@link Ext.StoreMgr StoreMgr}.
+     * Note: if a (deprecated) {@link #id} is specified it will supersede the storeId
+     * assignment.
      */
+    /**
+     * @cfg {String} url If a {@link #proxy} is not specified the url will be used to
+     * implicitly configure a {@link Ext.data.HttpProxy HttpProxy} if an url is specified.
+     * Typically this option, or the {@link #data} option will be specified.
+     */
+    /**
+     * @cfg {Boolean/Object} autoLoad If {@link #data} is not specified, and if autoLoad
+     * is true or an Object, this store's {@link #load} method is automatically called
+     * after creation. If the value of autoLoad is an Object, this Object will
+     * be passed to the store's {@link #load} method.
+     */
+    /**
+     * @cfg {Ext.data.DataProxy} proxy The {@link Ext.data.DataProxy DataProxy} object which provides
+     * access to a data object.  See {@link #url}.
+     */
+    /**
+     * @cfg {Array} data An inline data object readable by the {@link #reader}.
+     * Typically this option, or the {@link #url} option will be specified.
+     */
+    /**
+     * @cfg {Ext.data.DataReader} reader The {@link Ext.data.DataReader Reader} object which processes the
+     * data object and returns an Array of {@link Ext.data.Record} objects which are cached keyed by their
+     * {@link Ext.data.Record#id id} property.
+     */
+    /**
+     * @cfg {Ext.data.DataWriter} writer
+     * The {@link Ext.data.DataWriter Writer} object which processes a record object for being written
+     * to the server-side database.
+     * 
When a writer is installed into a Store the {@link #add}, {@link #remove}, and {@link #update}
+     * events on the store are monitored in order to remotely {@link #createRecords create records},
+     * {@link #destroyRecord destroy records}, or {@link #updateRecord update records}.
+     * 
The proxy for this store will relay any {@link #writexception} events to this store.
+     * 
Sample implementation:
+     * 

+var writer = new {@link Ext.data.JsonWriter}({
+    encode: true,
+    writeAllFields: true // write all fields, not just those that changed
+});
 
-    // private
-    monitorResize:true,
-    type: 'anchor',
-
-    getLayoutTargetSize : function() {
-        var target = this.container.getLayoutTarget();
-        if (!target) {
-            return {};
-        }
-        // Style Sized (scrollbars not included)
-        return target.getStyleSize();
-    },
-
-    // private
-    onLayout : function(ct, target){
-        Ext.layout.AnchorLayout.superclass.onLayout.call(this, ct, target);
-        var size = this.getLayoutTargetSize();
-
-        var w = size.width, h = size.height;
+// Typical Store collecting the Proxy, Reader and Writer together.
+var store = new Ext.data.Store({
+    storeId: 'user',
+    root: 'records',
+    proxy: proxy,
+    reader: reader,
+    writer: writer,     // <-- plug a DataWriter into the store just as you would a Reader
+    paramsAsHash: true,
+    autoSave: false    // <-- false to delay executing create, update, destroy requests
+                        //     until specifically told to do so.
+});
+     * 

+     */
+    writer : undefined,
+    /**
+     * @cfg {Object} baseParams
+     * An object containing properties which are to be sent as parameters
+     * for every HTTP request.
+     * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}.
+     * Note: baseParams may be superseded by any params
+     * specified in a {@link #load} request, see {@link #load}
+     * for more details.
+     * This property may be modified after creation using the {@link #setBaseParam}
+     * method.
+     * @property
+     */
+    /**
+     * @cfg {Object} sortInfo A config object to specify the sort order in the request of a Store's
+     * {@link #load} operation.  Note that for local sorting, the direction property is
+     * case-sensitive. See also {@link #remoteSort} and {@link #paramNames}.
+     * For example:
+sortInfo: {
+    field: 'fieldName',
+    direction: 'ASC' // or 'DESC' (case sensitive for local sorting)
+}
+
+     */
+    /**
+     * @cfg {boolean} remoteSort true if sorting is to be handled by requesting the {@link #proxy Proxy}
+     * to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache
+     * in place (defaults to false).
+     * If remoteSort is true, then clicking on a {@link Ext.grid.Column Grid Column}'s
+     * {@link Ext.grid.Column#header header} causes the current page to be requested from the server appending
+     * the following two parameters to the {@link #load params}:

+     * sort : StringThe name (as specified in the Record's
+     * {@link Ext.data.Field Field definition}) of the field to sort on.
+     * dir : StringThe direction of the sort, 'ASC' or 'DESC' (case-sensitive).
+     * 

+     */
+    remoteSort : false,
 
-        if(w < 20 && h < 20){
-            return;
-        }
+    /**
+     * @cfg {Boolean} autoDestroy true to destroy the store when the component the store is bound
+     * to is destroyed (defaults to false).
+     * Note: this should be set to true when using stores that are bound to only 1 component.
+     */
+    autoDestroy : false,
 
-        // find the container anchoring size
-        var aw, ah;
-        if(ct.anchorSize){
-            if(typeof ct.anchorSize == 'number'){
-                aw = ct.anchorSize;
-            }else{
-                aw = ct.anchorSize.width;
-                ah = ct.anchorSize.height;
-            }
-        }else{
-            aw = ct.initialConfig.width;
-            ah = ct.initialConfig.height;
-        }
+    /**
+     * @cfg {Boolean} pruneModifiedRecords true to clear all modified record information each time
+     * the store is loaded or when a record is removed (defaults to false). See {@link #getModifiedRecords}
+     * for the accessor method to retrieve the modified records.
+     */
+    pruneModifiedRecords : false,
 
-        var cs = this.getRenderedItems(ct), len = cs.length, i, c, a, cw, ch, el, vs;
-        for(i = 0; i < len; i++){
-            c = cs[i];
-            el = c.getPositionEl();
-            if(c.anchor){
-                a = c.anchorSpec;
-                if(!a){ // cache all anchor values
-                    vs = c.anchor.split(' ');
-                    c.anchorSpec = a = {
-                        right: this.parseAnchor(vs[0], c.initialConfig.width, aw),
-                        bottom: this.parseAnchor(vs[1], c.initialConfig.height, ah)
-                    };
-                }
-                cw = a.right ? this.adjustWidthAnchor(a.right(w) - el.getMargins('lr'), c) : undefined;
-                ch = a.bottom ? this.adjustHeightAnchor(a.bottom(h) - el.getMargins('tb'), c) : undefined;
+    /**
+     * Contains the last options object used as the parameter to the {@link #load} method. See {@link #load}
+     * for the details of what this may contain. This may be useful for accessing any params which were used
+     * to load the current Record cache.
+     * @property
+     */
+    lastOptions : null,
 
-                if(cw || ch){
-                    c.setSize(cw || undefined, ch || undefined);
-                }
-            }
-        }
-    },
+    /**
+     * @cfg {Boolean} autoSave
+     * Defaults to true causing the store to automatically {@link #save} records to
+     * the server when a record is modified (ie: becomes 'dirty'). Specify false to manually call {@link #save}
+     * to send all modifiedRecords to the server.
+     * 
Note: each CRUD action will be sent as a separate request.
+     */
+    autoSave : true,
 
-    // private
-    parseAnchor : function(a, start, cstart){
-        if(a && a != 'none'){
-            var last;
-            if(/^(r|right|b|bottom)$/i.test(a)){   // standard anchor
-                var diff = cstart - start;
-                return function(v){
-                    if(v !== last){
-                        last = v;
-                        return v - diff;
-                    }
-                }
-            }else if(a.indexOf('%') != -1){
-                var ratio = parseFloat(a.replace('%', ''))*.01;   // percentage
-                return function(v){
-                    if(v !== last){
-                        last = v;
-                        return Math.floor(v*ratio);
-                    }
-                }
-            }else{
-                a = parseInt(a, 10);
-                if(!isNaN(a)){                            // simple offset adjustment
-                    return function(v){
-                        if(v !== last){
-                            last = v;
-                            return v + a;
-                        }
-                    }
-                }
-            }
-        }
-        return false;
-    },
+    /**
+     * @cfg {Boolean} batch
+     * Defaults to true (unless {@link #restful}:true). Multiple
+     * requests for each CRUD action (CREATE, READ, UPDATE and DESTROY) will be combined
+     * and sent as one transaction. Only applies when {@link #autoSave} is set
+     * to false.
+     * 
If Store is RESTful, the DataProxy is also RESTful, and a unique transaction is
+     * generated for each record.
+     */
+    batch : true,
 
-    // private
-    adjustWidthAnchor : function(value, comp){
-        return value;
+    /**
+     * @cfg {Boolean} restful
+     * Defaults to false.  Set to true to have the Store and the set
+     * Proxy operate in a RESTful manner. The store will automatically generate GET, POST,
+     * PUT and DELETE requests to the server. The HTTP method used for any given CRUD
+     * action is described in {@link Ext.data.Api#restActions}.  For additional information
+     * see {@link Ext.data.DataProxy#restful}.
+     * Note: if {@link #restful}:true batch will
+     * internally be set to false.
+     */
+    restful: false,
+
+    /**
+     * @cfg {Object} paramNames
+     * An object containing properties which specify the names of the paging and
+     * sorting parameters passed to remote servers when loading blocks of data. By default, this
+     * object takes the following form:

+{
+    start : 'start',  // The parameter name which specifies the start row
+    limit : 'limit',  // The parameter name which specifies number of rows to return
+    sort : 'sort',    // The parameter name which specifies the column to sort on
+    dir : 'dir'       // The parameter name which specifies the sort direction
+}
+
+     * The server must produce the requested data block upon receipt of these parameter names.
+     * If different parameter names are required, this property can be overriden using a configuration
+     * property.
+     * A {@link Ext.PagingToolbar PagingToolbar} bound to this Store uses this property to determine
+     * the parameter names to use in its {@link #load requests}.
+     */
+    paramNames : undefined,
+
+    /**
+     * @cfg {Object} defaultParamNames
+     * Provides the default values for the {@link #paramNames} property. To globally modify the parameters
+     * for all stores, this object should be changed on the store prototype.
+     */
+    defaultParamNames : {
+        start : 'start',
+        limit : 'limit',
+        sort : 'sort',
+        dir : 'dir'
     },
 
-    // private
-    adjustHeightAnchor : function(value, comp){
-        return value;
-    }
+    /**
+     * @property isDestroyed
+     * @type Boolean
+     * True if the store has been destroyed already. Read only
+     */
+    isDestroyed: false,
 
     /**
-     * @property activeItem
-     * @hide
+     * @property hasMultiSort
+     * @type Boolean
+     * True if this store is currently sorted by more than one field/direction combination.
      */
-});
-Ext.Container.LAYOUTS['anchor'] = Ext.layout.AnchorLayout;
-/**
- * @class Ext.layout.ColumnLayout
- * @extends Ext.layout.ContainerLayout
- * 
This is the layout style of choice for creating structural layouts in a multi-column format where the width of
- * each column can be specified as a percentage or fixed width, but the height is allowed to vary based on the content.
- * This class is intended to be extended or created via the layout:'column' {@link Ext.Container#layout} config,
- * and should generally not need to be created directly via the new keyword.
- * ColumnLayout does not have any direct config options (other than inherited ones), but it does support a
- * specific config property of columnWidth that can be included in the config of any panel added to it.  The
- * layout will use the columnWidth (if present) or width of each panel during layout to determine how to size each panel.
- * If width or columnWidth is not specified for a given panel, its width will default to the panel's width (or auto).
- * The width property is always evaluated as pixels, and must be a number greater than or equal to 1.
- * The columnWidth property is always evaluated as a percentage, and must be a decimal value greater than 0 and
- * less than 1 (e.g., .25).
- * The basic rules for specifying column widths are pretty simple.  The logic makes two passes through the
- * set of contained panels.  During the first layout pass, all panels that either have a fixed width or none
- * specified (auto) are skipped, but their widths are subtracted from the overall container width.  During the second
- * pass, all panels with columnWidths are assigned pixel widths in proportion to their percentages based on
- * the total remaining container width.  In other words, percentage width panels are designed to fill the space
- * left over by all the fixed-width and/or auto-width panels.  Because of this, while you can specify any number of columns
- * with different percentages, the columnWidths must always add up to 1 (or 100%) when added together, otherwise your
- * layout may not render as expected.  Example usage:
- * 
-// All columns are percentages -- they must add up to 1
-var p = new Ext.Panel({
-    title: 'Column Layout - Percentage Only',
-    layout:'column',
-    items: [{
-        title: 'Column 1',
-        columnWidth: .25
-    },{
-        title: 'Column 2',
-        columnWidth: .6
-    },{
-        title: 'Column 3',
-        columnWidth: .15
-    }]
-});
-
-// Mix of width and columnWidth -- all columnWidth values must add up
-// to 1. The first column will take up exactly 120px, and the last two
-// columns will fill the remaining container width.
-var p = new Ext.Panel({
-    title: 'Column Layout - Mixed',
-    layout:'column',
-    items: [{
-        title: 'Column 1',
-        width: 120
-    },{
-        title: 'Column 2',
-        columnWidth: .8
-    },{
-        title: 'Column 3',
-        columnWidth: .2
-    }]
-});
-
- */
-Ext.layout.ColumnLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    // private
-    monitorResize:true,
-
-    type: 'column',
-
-    extraCls: 'x-column',
-
-    scrollOffset : 0,
-
-    // private
-
-    targetCls: 'x-column-layout-ct',
-
-    isValidParent : function(c, target){
-        return this.innerCt && c.getPositionEl().dom.parentNode == this.innerCt.dom;
-    },
-
-    getLayoutTargetSize : function() {
-        var target = this.container.getLayoutTarget(), ret;
-        if (target) {
-            ret = target.getViewSize();
-            ret.width -= target.getPadding('lr');
-            ret.height -= target.getPadding('tb');
-        }
-        return ret;
-    },
-
-    renderAll : function(ct, target) {
-        if(!this.innerCt){
-            // the innerCt prevents wrapping and shuffling while
-            // the container is resizing
-            this.innerCt = target.createChild({cls:'x-column-inner'});
-            this.innerCt.createChild({cls:'x-clear'});
-        }
-        Ext.layout.ColumnLayout.superclass.renderAll.call(this, ct, this.innerCt);
-    },
-
-    // private
-    onLayout : function(ct, target){
-        var cs = ct.items.items, len = cs.length, c, i;
-
-        this.renderAll(ct, target);
-
-        var size = this.getLayoutTargetSize();
-
-        if(size.width < 1 && size.height < 1){ // display none?
-            return;
-        }
-
-        var w = size.width - this.scrollOffset,
-            h = size.height,
-            pw = w;
-
-        this.innerCt.setWidth(w);
-
-        // some columns can be percentages while others are fixed
-        // so we need to make 2 passes
-
-        for(i = 0; i < len; i++){
-            c = cs[i];
-            if(!c.columnWidth){
-                pw -= (c.getWidth() + c.getPositionEl().getMargins('lr'));
-            }
-        }
-
-        pw = pw < 0 ? 0 : pw;
-
-        for(i = 0; i < len; i++){
-            c = cs[i];
-            if(c.columnWidth){
-                c.setSize(Math.floor(c.columnWidth * pw) - c.getPositionEl().getMargins('lr'));
-            }
-        }
-
-        // Browsers differ as to when they account for scrollbars.  We need to re-measure to see if the scrollbar
-        // spaces were accounted for properly.  If not, re-layout.
-        if (Ext.isIE) {
-            if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
-                var ts = this.getLayoutTargetSize();
-                if (ts.width != size.width){
-                    this.adjustmentPass = true;
-                    this.onLayout(ct, target);
-                }
-            }
-        }
-        delete this.adjustmentPass;
-    }
-
-    /**
-     * @property activeItem
-     * @hide
-     */
-});
-
-Ext.Container.LAYOUTS['column'] = Ext.layout.ColumnLayout;/**
- * @class Ext.layout.BorderLayout
- * @extends Ext.layout.ContainerLayout
- * This is a multi-pane, application-oriented UI layout style that supports multiple
- * nested panels, automatic {@link Ext.layout.BorderLayout.Region#split split} bars between
- * {@link Ext.layout.BorderLayout.Region#BorderLayout.Region regions} and built-in
- * {@link Ext.layout.BorderLayout.Region#collapsible expanding and collapsing} of regions.
- * This class is intended to be extended or created via the layout:'border'
- * {@link Ext.Container#layout} config, and should generally not need to be created directly
- * via the new keyword.
- * BorderLayout does not have any direct config options (other than inherited ones).
- * All configuration options available for customizing the BorderLayout are at the
- * {@link Ext.layout.BorderLayout.Region} and {@link Ext.layout.BorderLayout.SplitRegion}
- * levels.
- * Example usage:
- * 
-var myBorderPanel = new Ext.Panel({
-    {@link Ext.Component#renderTo renderTo}: document.body,
-    {@link Ext.BoxComponent#width width}: 700,
-    {@link Ext.BoxComponent#height height}: 500,
-    {@link Ext.Panel#title title}: 'Border Layout',
-    {@link Ext.Container#layout layout}: 'border',
-    {@link Ext.Container#items items}: [{
-        {@link Ext.Panel#title title}: 'South Region is resizable',
-        {@link Ext.layout.BorderLayout.Region#BorderLayout.Region region}: 'south',     // position for region
-        {@link Ext.BoxComponent#height height}: 100,
-        {@link Ext.layout.BorderLayout.Region#split split}: true,         // enable resizing
-        {@link Ext.SplitBar#minSize minSize}: 75,         // defaults to {@link Ext.layout.BorderLayout.Region#minHeight 50}
-        {@link Ext.SplitBar#maxSize maxSize}: 150,
-        {@link Ext.layout.BorderLayout.Region#margins margins}: '0 5 5 5'
-    },{
-        // xtype: 'panel' implied by default
-        {@link Ext.Panel#title title}: 'West Region is collapsible',
-        {@link Ext.layout.BorderLayout.Region#BorderLayout.Region region}:'west',
-        {@link Ext.layout.BorderLayout.Region#margins margins}: '5 0 0 5',
-        {@link Ext.BoxComponent#width width}: 200,
-        {@link Ext.layout.BorderLayout.Region#collapsible collapsible}: true,   // make collapsible
-        {@link Ext.layout.BorderLayout.Region#cmargins cmargins}: '5 5 0 5', // adjust top margin when collapsed
-        {@link Ext.Component#id id}: 'west-region-container',
-        {@link Ext.Container#layout layout}: 'fit',
-        {@link Ext.Panel#unstyled unstyled}: true
-    },{
-        {@link Ext.Panel#title title}: 'Center Region',
-        {@link Ext.layout.BorderLayout.Region#BorderLayout.Region region}: 'center',     // center region is required, no width/height specified
-        {@link Ext.Component#xtype xtype}: 'container',
-        {@link Ext.Container#layout layout}: 'fit',
-        {@link Ext.layout.BorderLayout.Region#margins margins}: '5 5 0 0'
-    }]
-});
-
- * Notes:

- * Any container using the BorderLayout must have a child item with region:'center'.
- * The child item in the center region will always be resized to fill the remaining space not used by
- * the other regions in the layout.
- * Any child items with a region of west or east must have width defined
- * (an integer representing the number of pixels that the region should take up).
- * Any child items with a region of north or south must have height defined.
- * The regions of a BorderLayout are fixed at render time and thereafter, its child Components may not be removed or added.  To add/remove
- * Components within a BorderLayout, have them wrapped by an additional Container which is directly
- * managed by the BorderLayout.  If the region is to be collapsible, the Container used directly
- * by the BorderLayout manager should be a Panel.  In the following example a Container (an Ext.Panel)
- * is added to the west region:
- * 
-wrc = {@link Ext#getCmp Ext.getCmp}('west-region-container');
-wrc.{@link Ext.Panel#removeAll removeAll}();
-wrc.{@link Ext.Container#add add}({
-    title: 'Added Panel',
-    html: 'Some content'
-});
-wrc.{@link Ext.Container#doLayout doLayout}();
- * 
- * 
- *  To reference a {@link Ext.layout.BorderLayout.Region Region}:
- * 
-wr = myBorderPanel.layout.west;
- * 
- * 
- * 
- */
-Ext.layout.BorderLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    // private
-    monitorResize:true,
+    hasMultiSort: false,
+
     // private
-    rendered : false,
+    batchKey : '_ext_batch_',
 
-    type: 'border',
+    constructor : function(config){
+        this.data = new Ext.util.MixedCollection(false);
+        this.data.getKey = function(o){
+            return o.id;
+        };
 
-    targetCls: 'x-border-layout-ct',
 
-    getLayoutTargetSize : function() {
-        var target = this.container.getLayoutTarget();
-        return target ? target.getViewSize() : {};
-    },
+        // temporary removed-records cache
+        this.removed = [];
 
-    // private
-    onLayout : function(ct, target){
-        var collapsed, i, c, pos, items = ct.items.items, len = items.length;
-        if(!this.rendered){
-            collapsed = [];
-            for(i = 0; i < len; i++) {
-                c = items[i];
-                pos = c.region;
-                if(c.collapsed){
-                    collapsed.push(c);
-                }
-                c.collapsed = false;
-                if(!c.rendered){
-                    c.render(target, i);
-                    c.getPositionEl().addClass('x-border-panel');
-                }
-                this[pos] = pos != 'center' && c.split ?
-                    new Ext.layout.BorderLayout.SplitRegion(this, c.initialConfig, pos) :
-                    new Ext.layout.BorderLayout.Region(this, c.initialConfig, pos);
-                this[pos].render(target, c);
-            }
-            this.rendered = true;
+        if(config && config.data){
+            this.inlineData = config.data;
+            delete config.data;
         }
 
-        var size = this.getLayoutTargetSize();
-        if(size.width < 20 || size.height < 20){ // display none?
-            if(collapsed){
-                this.restoreCollapsed = collapsed;
-            }
-            return;
-        }else if(this.restoreCollapsed){
-            collapsed = this.restoreCollapsed;
-            delete this.restoreCollapsed;
-        }
+        Ext.apply(this, config);
 
-        var w = size.width, h = size.height,
-            centerW = w, centerH = h, centerY = 0, centerX = 0,
-            n = this.north, s = this.south, west = this.west, e = this.east, c = this.center,
-            b, m, totalWidth, totalHeight;
-        if(!c && Ext.layout.BorderLayout.WARN !== false){
-            throw 'No center region defined in BorderLayout ' + ct.id;
-        }
+        /**
+         * See the {@link #baseParams corresponding configuration option}
+         * for a description of this property.
+         * To modify this property see {@link #setBaseParam}.
+         * @property
+         */
+        this.baseParams = Ext.isObject(this.baseParams) ? this.baseParams : {};
 
-        if(n && n.isVisible()){
-            b = n.getSize();
-            m = n.getMargins();
-            b.width = w - (m.left+m.right);
-            b.x = m.left;
-            b.y = m.top;
-            centerY = b.height + b.y + m.bottom;
-            centerH -= centerY;
-            n.applyLayout(b);
-        }
-        if(s && s.isVisible()){
-            b = s.getSize();
-            m = s.getMargins();
-            b.width = w - (m.left+m.right);
-            b.x = m.left;
-            totalHeight = (b.height + m.top + m.bottom);
-            b.y = h - totalHeight + m.top;
-            centerH -= totalHeight;
-            s.applyLayout(b);
-        }
-        if(west && west.isVisible()){
-            b = west.getSize();
-            m = west.getMargins();
-            b.height = centerH - (m.top+m.bottom);
-            b.x = m.left;
-            b.y = centerY + m.top;
-            totalWidth = (b.width + m.left + m.right);
-            centerX += totalWidth;
-            centerW -= totalWidth;
-            west.applyLayout(b);
+        this.paramNames = Ext.applyIf(this.paramNames || {}, this.defaultParamNames);
+
+        if((this.url || this.api) && !this.proxy){
+            this.proxy = new Ext.data.HttpProxy({url: this.url, api: this.api});
         }
-        if(e && e.isVisible()){
-            b = e.getSize();
-            m = e.getMargins();
-            b.height = centerH - (m.top+m.bottom);
-            totalWidth = (b.width + m.left + m.right);
-            b.x = w - totalWidth + m.left;
-            b.y = centerY + m.top;
-            centerW -= totalWidth;
-            e.applyLayout(b);
+        // If Store is RESTful, so too is the DataProxy
+        if (this.restful === true && this.proxy) {
+            // When operating RESTfully, a unique transaction is generated for each record.
+            // TODO might want to allow implemention of faux REST where batch is possible using RESTful routes only.
+            this.batch = false;
+            Ext.data.Api.restify(this.proxy);
         }
-        if(c){
-            m = c.getMargins();
-            var centerBox = {
-                x: centerX + m.left,
-                y: centerY + m.top,
-                width: centerW - (m.left+m.right),
-                height: centerH - (m.top+m.bottom)
-            };
-            c.applyLayout(centerBox);
+
+        if(this.reader){ // reader passed
+            if(!this.recordType){
+                this.recordType = this.reader.recordType;
+            }
+            if(this.reader.onMetaChange){
+                this.reader.onMetaChange = this.reader.onMetaChange.createSequence(this.onMetaChange, this);
+            }
+            if (this.writer) { // writer passed
+                if (this.writer instanceof(Ext.data.DataWriter) === false) {    // <-- config-object instead of instance.
+                    this.writer = this.buildWriter(this.writer);
+                }
+                this.writer.meta = this.reader.meta;
+                this.pruneModifiedRecords = true;
+            }
         }
-        if(collapsed){
-            for(i = 0, len = collapsed.length; i < len; i++){
-                collapsed[i].collapse(false);
+
+        /**
+         * The {@link Ext.data.Record Record} constructor as supplied to (or created by) the
+         * {@link Ext.data.DataReader Reader}. Read-only.
+         * If the Reader was constructed by passing in an Array of {@link Ext.data.Field} definition objects,
+         * instead of a Record constructor, it will implicitly create a Record constructor from that Array (see
+         * {@link Ext.data.Record}.{@link Ext.data.Record#create create} for additional details).
+         * This property may be used to create new Records of the type held in this Store, for example:

+    // create the data store
+    var store = new Ext.data.ArrayStore({
+        autoDestroy: true,
+        fields: [
+           {name: 'company'},
+           {name: 'price', type: 'float'},
+           {name: 'change', type: 'float'},
+           {name: 'pctChange', type: 'float'},
+           {name: 'lastChange', type: 'date', dateFormat: 'n/j h:ia'}
+        ]
+    });
+    store.loadData(myData);
+
+    // create the Grid
+    var grid = new Ext.grid.EditorGridPanel({
+        store: store,
+        colModel: new Ext.grid.ColumnModel({
+            columns: [
+                {id:'company', header: 'Company', width: 160, dataIndex: 'company'},
+                {header: 'Price', renderer: 'usMoney', dataIndex: 'price'},
+                {header: 'Change', renderer: change, dataIndex: 'change'},
+                {header: '% Change', renderer: pctChange, dataIndex: 'pctChange'},
+                {header: 'Last Updated', width: 85,
+                    renderer: Ext.util.Format.dateRenderer('m/d/Y'),
+                    dataIndex: 'lastChange'}
+            ],
+            defaults: {
+                sortable: true,
+                width: 75
+            }
+        }),
+        autoExpandColumn: 'company', // match the id specified in the column model
+        height:350,
+        width:600,
+        title:'Array Grid',
+        tbar: [{
+            text: 'Add Record',
+            handler : function(){
+                var defaultData = {
+                    change: 0,
+                    company: 'New Company',
+                    lastChange: (new Date()).clearTime(),
+                    pctChange: 0,
+                    price: 10
+                };
+                var recId = 3; // provide unique id
+                var p = new store.recordType(defaultData, recId); // create new record
+                grid.stopEditing();
+                store.{@link #insert}(0, p); // insert a new record into the store (also see {@link #add})
+                grid.startEditing(0, 0);
             }
+        }]
+    });
+         * 
+         * @property recordType
+         * @type Function
+         */
+
+        if(this.recordType){
+            /**
+             * A {@link Ext.util.MixedCollection MixedCollection} containing the defined {@link Ext.data.Field Field}s
+             * for the {@link Ext.data.Record Records} stored in this Store. Read-only.
+             * @property fields
+             * @type Ext.util.MixedCollection
+             */
+            this.fields = this.recordType.prototype.fields;
         }
-        if(Ext.isIE && Ext.isStrict){ // workaround IE strict repainting issue
-            target.repaint();
+        this.modified = [];
+
+        this.addEvents(
+            /**
+             * @event datachanged
+             * Fires when the data cache has changed in a bulk manner (e.g., it has been sorted, filtered, etc.) and a
+             * widget that is using this Store as a Record cache should refresh its view.
+             * @param {Store} this
+             */
+            'datachanged',
+            /**
+             * @event metachange
+             * Fires when this store's reader provides new metadata (fields). This is currently only supported for JsonReaders.
+             * @param {Store} this
+             * @param {Object} meta The JSON metadata
+             */
+            'metachange',
+            /**
+             * @event add
+             * Fires when Records have been {@link #add}ed to the Store
+             * @param {Store} this
+             * @param {Ext.data.Record[]} records The array of Records added
+             * @param {Number} index The index at which the record(s) were added
+             */
+            'add',
+            /**
+             * @event remove
+             * Fires when a Record has been {@link #remove}d from the Store
+             * @param {Store} this
+             * @param {Ext.data.Record} record The Record that was removed
+             * @param {Number} index The index at which the record was removed
+             */
+            'remove',
+            /**
+             * @event update
+             * Fires when a Record has been updated
+             * @param {Store} this
+             * @param {Ext.data.Record} record The Record that was updated
+             * @param {String} operation The update operation being performed.  Value may be one of:
+             * 
+     Ext.data.Record.EDIT
+     Ext.data.Record.REJECT
+     Ext.data.Record.COMMIT
+             * 
+             */
+            'update',
+            /**
+             * @event clear
+             * Fires when the data cache has been cleared.
+             * @param {Store} this
+             * @param {Record[]} The records that were cleared.
+             */
+            'clear',
+            /**
+             * @event exception
+             * Fires if an exception occurs in the Proxy during a remote request.
+             * This event is relayed through the corresponding {@link Ext.data.DataProxy}.
+             * See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception}
+             * for additional details.
+             * @param {misc} misc See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception}
+             * for description.
+             */
+            'exception',
+            /**
+             * @event beforeload
+             * Fires before a request is made for a new data object.  If the beforeload handler returns
+             * false the {@link #load} action will be canceled.
+             * @param {Store} this
+             * @param {Object} options The loading options that were specified (see {@link #load} for details)
+             */
+            'beforeload',
+            /**
+             * @event load
+             * Fires after a new set of Records has been loaded.
+             * @param {Store} this
+             * @param {Ext.data.Record[]} records The Records that were loaded
+             * @param {Object} options The loading options that were specified (see {@link #load} for details)
+             */
+            'load',
+            /**
+             * @event loadexception
+             * 
This event is deprecated in favor of the catch-all {@link #exception}
+             * event instead.
+             * This event is relayed through the corresponding {@link Ext.data.DataProxy}.
+             * See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#loadexception loadexception}
+             * for additional details.
+             * @param {misc} misc See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#loadexception loadexception}
+             * for description.
+             */
+            'loadexception',
+            /**
+             * @event beforewrite
+             * @param {Ext.data.Store} store
+             * @param {String} action [Ext.data.Api.actions.create|update|destroy]
+             * @param {Record/Record[]} rs The Record(s) being written.
+             * @param {Object} options The loading options that were specified. Edit options.params to add Http parameters to the request.  (see {@link #save} for details)
+             * @param {Object} arg The callback's arg object passed to the {@link #request} function
+             */
+            'beforewrite',
+            /**
+             * @event write
+             * Fires if the server returns 200 after an Ext.data.Api.actions CRUD action.
+             * Success of the action is determined in the result['successProperty']property (NOTE for RESTful stores,
+             * a simple 20x response is sufficient for the actions "destroy" and "update".  The "create" action should should return 200 along with a database pk).
+             * @param {Ext.data.Store} store
+             * @param {String} action [Ext.data.Api.actions.create|update|destroy]
+             * @param {Object} result The 'data' picked-out out of the response for convenience.
+             * @param {Ext.Direct.Transaction} res
+             * @param {Record/Record[]} rs Store's records, the subject(s) of the write-action
+             */
+            'write',
+            /**
+             * @event beforesave
+             * Fires before a save action is called. A save encompasses destroying records, updating records and creating records.
+             * @param {Ext.data.Store} store
+             * @param {Object} data An object containing the data that is to be saved. The object will contain a key for each appropriate action,
+             * with an array of records for each action.
+             */
+            'beforesave',
+            /**
+             * @event save
+             * Fires after a save is completed. A save encompasses destroying records, updating records and creating records.
+             * @param {Ext.data.Store} store
+             * @param {Number} batch The identifier for the batch that was saved.
+             * @param {Object} data An object containing the data that is to be saved. The object will contain a key for each appropriate action,
+             * with an array of records for each action.
+             */
+            'save'
+
+        );
+
+        if(this.proxy){
+            // TODO remove deprecated loadexception with ext-3.0.1
+            this.relayEvents(this.proxy,  ['loadexception', 'exception']);
         }
-        // Putting a border layout into an overflowed container is NOT correct and will make a second layout pass necessary.
-        if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
-            var ts = this.getLayoutTargetSize();
-            if (ts.width != size.width || ts.height != size.height){
-                this.adjustmentPass = true;
-                this.onLayout(ct, target);
-            }
+        // With a writer set for the Store, we want to listen to add/remove events to remotely create/destroy records.
+        if (this.writer) {
+            this.on({
+                scope: this,
+                add: this.createRecords,
+                remove: this.destroyRecord,
+                update: this.updateRecord,
+                clear: this.onClear
+            });
         }
-        delete this.adjustmentPass;
-    },
 
-    destroy: function() {
-        var r = ['north', 'south', 'east', 'west'], i, region;
-        for (i = 0; i < r.length; i++) {
-            region = this[r[i]];
-            if(region){
-                if(region.destroy){
-                    region.destroy();
-                }else if (region.split){
-                    region.split.destroy(true);
-                }
-            }
+        this.sortToggle = {};
+        if(this.sortField){
+            this.setDefaultSort(this.sortField, this.sortDir);
+        }else if(this.sortInfo){
+            this.setDefaultSort(this.sortInfo.field, this.sortInfo.direction);
         }
-        Ext.layout.BorderLayout.superclass.destroy.call(this);
-    }
 
-    /**
-     * @property activeItem
-     * @hide
-     */
-});
+        Ext.data.Store.superclass.constructor.call(this);
 
-/**
- * @class Ext.layout.BorderLayout.Region
- * 
This is a region of a {@link Ext.layout.BorderLayout BorderLayout} that acts as a subcontainer
- * within the layout.  Each region has its own {@link Ext.layout.ContainerLayout layout} that is
- * independent of other regions and the containing BorderLayout, and can be any of the
- * {@link Ext.layout.ContainerLayout valid Ext layout types}.
- * Region size is managed automatically and cannot be changed by the user -- for
- * {@link #split resizable regions}, see {@link Ext.layout.BorderLayout.SplitRegion}.
- * @constructor
- * Create a new Region.
- * @param {Layout} layout The {@link Ext.layout.BorderLayout BorderLayout} instance that is managing this Region.
- * @param {Object} config The configuration options
- * @param {String} position The region position.  Valid values are: north, south,
- * east, west and center.  Every {@link Ext.layout.BorderLayout BorderLayout}
- * must have a center region for the primary content -- all other regions are optional.
- */
-Ext.layout.BorderLayout.Region = function(layout, config, pos){
-    Ext.apply(this, config);
-    this.layout = layout;
-    this.position = pos;
-    this.state = {};
-    if(typeof this.margins == 'string'){
-        this.margins = this.layout.parseMargins(this.margins);
-    }
-    this.margins = Ext.applyIf(this.margins || {}, this.defaultMargins);
-    if(this.collapsible){
-        if(typeof this.cmargins == 'string'){
-            this.cmargins = this.layout.parseMargins(this.cmargins);
+        if(this.id){
+            this.storeId = this.id;
+            delete this.id;
         }
-        if(this.collapseMode == 'mini' && !this.cmargins){
-            this.cmargins = {left:0,top:0,right:0,bottom:0};
-        }else{
-            this.cmargins = Ext.applyIf(this.cmargins || {},
-                pos == 'north' || pos == 'south' ? this.defaultNSCMargins : this.defaultEWCMargins);
+        if(this.storeId){
+            Ext.StoreMgr.register(this);
         }
-    }
-};
-
-Ext.layout.BorderLayout.Region.prototype = {
-    /**
-     * @cfg {Boolean} animFloat
-     * When a collapsed region's bar is clicked, the region's panel will be displayed as a floated
-     * panel that will close again once the user mouses out of that panel (or clicks out if
-     * {@link #autoHide} = false).  Setting {@link #animFloat} = false will
-     * prevent the open and close of these floated panels from being animated (defaults to true).
-     */
-    /**
-     * @cfg {Boolean} autoHide
-     * When a collapsed region's bar is clicked, the region's panel will be displayed as a floated
-     * panel.  If autoHide = true, the panel will automatically hide after the user mouses
-     * out of the panel.  If autoHide = false, the panel will continue to display until the
-     * user clicks outside of the panel (defaults to true).
-     */
-    /**
-     * @cfg {String} collapseMode
-     * collapseMode supports two configuration values:
-     * undefined (default)By default, {@link #collapsible}
-     * regions are collapsed by clicking the expand/collapse tool button that renders into the region's
-     * title bar.
-     * 'mini'Optionally, when collapseMode is set to
-     * 'mini' the region's split bar will also display a small collapse button in the center of
-     * the bar. In 'mini' mode the region will collapse to a thinner bar than in normal mode.
-     * 
-     * 

-     * Note: if a collapsible region does not have a title bar, then set collapseMode =
-     * 'mini' and {@link #split} = true in order for the region to be {@link #collapsible}
-     * by the user as the expand/collapse tool button (that would go in the title bar) will not be rendered.
-     * See also {@link #cmargins}.
-     */
-    /**
-     * @cfg {Object} margins
-     * An object containing margins to apply to the region when in the expanded state in the
-     * format:
-{
-    top: (top margin),
-    right: (right margin),
-    bottom: (bottom margin),
-    left: (left margin)
-}
-     * May also be a string containing space-separated, numeric margin values. The order of the
-     * sides associated with each value matches the way CSS processes margin values:
-     * 

-     * If there is only one value, it applies to all sides.
-     * If there are two values, the top and bottom borders are set to the first value and the
-     * right and left are set to the second.
-     * If there are three values, the top is set to the first value, the left and right are set
-     * to the second, and the bottom is set to the third.
-     * If there are four values, they apply to the top, right, bottom, and left, respectively.
-     * 

-     * Defaults to:

-     * {top:0, right:0, bottom:0, left:0}
-     * 
-     */
-    /**
-     * @cfg {Object} cmargins
-     * An object containing margins to apply to the region when in the collapsed state in the
-     * format:
-{
-    top: (top margin),
-    right: (right margin),
-    bottom: (bottom margin),
-    left: (left margin)
-}
-     * May also be a string containing space-separated, numeric margin values. The order of the
-     * sides associated with each value matches the way CSS processes margin values.
-     * 

-     * If there is only one value, it applies to all sides.
-     * If there are two values, the top and bottom borders are set to the first value and the
-     * right and left are set to the second.
-     * If there are three values, the top is set to the first value, the left and right are set
-     * to the second, and the bottom is set to the third.
-     * If there are four values, they apply to the top, right, bottom, and left, respectively.
-     * 

-     */
-    /**
-     * @cfg {Boolean} collapsible
-     * true to allow the user to collapse this region (defaults to false).  If
-     * true, an expand/collapse tool button will automatically be rendered into the title
-     * bar of the region, otherwise the button will not be shown.
-     * Note: that a title bar is required to display the collapse/expand toggle button -- if
-     * no title is specified for the region's panel, the region will only be collapsible if
-     * {@link #collapseMode} = 'mini' and {@link #split} = true.
-     */
-    collapsible : false,
-    /**
-     * @cfg {Boolean} split
-     * 
true to create a {@link Ext.layout.BorderLayout.SplitRegion SplitRegion} and
-     * display a 5px wide {@link Ext.SplitBar} between this region and its neighbor, allowing the user to
-     * resize the regions dynamically.  Defaults to false creating a
-     * {@link Ext.layout.BorderLayout.Region Region}.


-     * Notes:

-     * this configuration option is ignored if region='center'
-     * when split == true, it is common to specify a
-     * {@link Ext.SplitBar#minSize minSize} and {@link Ext.SplitBar#maxSize maxSize}
-     * for the {@link Ext.BoxComponent BoxComponent} representing the region. These are not native
-     * configs of {@link Ext.BoxComponent BoxComponent}, and are used only by this class.
-     * if {@link #collapseMode} = 'mini' requires split = true to reserve space
-     * for the collapse tool
-     * 
-     */
-    split:false,
-    /**
-     * @cfg {Boolean} floatable
-     * true to allow clicking a collapsed region's bar to display the region's panel floated
-     * above the layout, false to force the user to fully expand a collapsed region by
-     * clicking the expand button to see it again (defaults to true).
-     */
-    floatable: true,
-    /**
-     * @cfg {Number} minWidth
-     * The minimum allowable width in pixels for this region (defaults to 50).
-     * maxWidth may also be specified.


-     * Note: setting the {@link Ext.SplitBar#minSize minSize} /
-     * {@link Ext.SplitBar#maxSize maxSize} supersedes any specified
-     * minWidth / maxWidth.
-     */
-    minWidth:50,
-    /**
-     * @cfg {Number} minHeight
-     * The minimum allowable height in pixels for this region (defaults to 50)
-     * maxHeight may also be specified.


-     * Note: setting the {@link Ext.SplitBar#minSize minSize} /
-     * {@link Ext.SplitBar#maxSize maxSize} supersedes any specified
-     * minHeight / maxHeight.
-     */
-    minHeight:50,
-
-    // private
-    defaultMargins : {left:0,top:0,right:0,bottom:0},
-    // private
-    defaultNSCMargins : {left:5,top:5,right:5,bottom:5},
-    // private
-    defaultEWCMargins : {left:5,top:0,right:5,bottom:0},
-    floatingZIndex: 100,
+        if(this.inlineData){
+            this.loadData(this.inlineData);
+            delete this.inlineData;
+        }else if(this.autoLoad){
+            this.load.defer(10, this, [
+                typeof this.autoLoad == 'object' ?
+                    this.autoLoad : undefined]);
+        }
+        // used internally to uniquely identify a batch
+        this.batchCounter = 0;
+        this.batches = {};
+    },
 
     /**
-     * True if this region is collapsed. Read-only.
-     * @type Boolean
-     * @property
+     * builds a DataWriter instance when Store constructor is provided with a writer config-object instead of an instace.
+     * @param {Object} config Writer configuration
+     * @return {Ext.data.DataWriter}
+     * @private
      */
-    isCollapsed : false,
+    buildWriter : function(config) {
+        var klass = undefined,
+            type = (config.format || 'json').toLowerCase();
+        switch (type) {
+            case 'json':
+                klass = Ext.data.JsonWriter;
+                break;
+            case 'xml':
+                klass = Ext.data.XmlWriter;
+                break;
+            default:
+                klass = Ext.data.JsonWriter;
+        }
+        return new klass(config);
+    },
 
     /**
-     * This region's panel.  Read-only.
-     * @type Ext.Panel
-     * @property panel
-     */
-    /**
-     * This region's layout.  Read-only.
-     * @type Layout
-     * @property layout
-     */
-    /**
-     * This region's layout position (north, south, east, west or center).  Read-only.
-     * @type String
-     * @property position
+     * Destroys the store.
      */
-
-    // private
-    render : function(ct, p){
-        this.panel = p;
-        p.el.enableDisplayMode();
-        this.targetEl = ct;
-        this.el = p.el;
-
-        var gs = p.getState, ps = this.position;
-        p.getState = function(){
-            return Ext.apply(gs.call(p) || {}, this.state);
-        }.createDelegate(this);
-
-        if(ps != 'center'){
-            p.allowQueuedExpand = false;
-            p.on({
-                beforecollapse: this.beforeCollapse,
-                collapse: this.onCollapse,
-                beforeexpand: this.beforeExpand,
-                expand: this.onExpand,
-                hide: this.onHide,
-                show: this.onShow,
-                scope: this
-            });
-            if(this.collapsible || this.floatable){
-                p.collapseEl = 'el';
-                p.slideAnchor = this.getSlideAnchor();
-            }
-            if(p.tools && p.tools.toggle){
-                p.tools.toggle.addClass('x-tool-collapse-'+ps);
-                p.tools.toggle.addClassOnOver('x-tool-collapse-'+ps+'-over');
+    destroy : function(){
+        if(!this.isDestroyed){
+            if(this.storeId){
+                Ext.StoreMgr.unregister(this);
             }
+            this.clearData();
+            this.data = null;
+            Ext.destroy(this.proxy);
+            this.reader = this.writer = null;
+            this.purgeListeners();
+            this.isDestroyed = true;
         }
     },
 
-    // private
-    getCollapsedEl : function(){
-        if(!this.collapsedEl){
-            if(!this.toolTemplate){
-                var tt = new Ext.Template(
-                     ' '
-                );
-                tt.disableFormats = true;
-                tt.compile();
-                Ext.layout.BorderLayout.Region.prototype.toolTemplate = tt;
-            }
-            this.collapsedEl = this.targetEl.createChild({
-                cls: "x-layout-collapsed x-layout-collapsed-"+this.position,
-                id: this.panel.id + '-xcollapsed'
-            });
-            this.collapsedEl.enableDisplayMode('block');
-
-            if(this.collapseMode == 'mini'){
-                this.collapsedEl.addClass('x-layout-cmini-'+this.position);
-                this.miniCollapsedEl = this.collapsedEl.createChild({
-                    cls: "x-layout-mini x-layout-mini-"+this.position, html: " "
-                });
-                this.miniCollapsedEl.addClassOnOver('x-layout-mini-over');
-                this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
-                this.collapsedEl.on('click', this.onExpandClick, this, {stopEvent:true});
-            }else {
-                if(this.collapsible !== false && !this.hideCollapseTool) {
-                    var t = this.toolTemplate.append(
-                            this.collapsedEl.dom,
-                            {id:'expand-'+this.position}, true);
-                    t.addClassOnOver('x-tool-expand-'+this.position+'-over');
-                    t.on('click', this.onExpandClick, this, {stopEvent:true});
-                }
-                if(this.floatable !== false || this.titleCollapse){
-                   this.collapsedEl.addClassOnOver("x-layout-collapsed-over");
-                   this.collapsedEl.on("click", this[this.floatable ? 'collapseClick' : 'onExpandClick'], this);
-                }
-            }
+    /**
+     * Add Records to the Store and fires the {@link #add} event.  To add Records
+     * to the store from a remote source use {@link #load}({add:true}).
+     * See also {@link #recordType} and {@link #insert}.
+     * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects
+     * to add to the cache. See {@link #recordType}.
+     */
+    add : function(records){
+        records = [].concat(records);
+        if(records.length < 1){
+            return;
         }
-        return this.collapsedEl;
-    },
-
-    // private
-    onExpandClick : function(e){
-        if(this.isSlid){
-            this.panel.expand(false);
-        }else{
-            this.panel.expand();
+        for(var i = 0, len = records.length; i < len; i++){
+            records[i].join(this);
+        }
+        var index = this.data.length;
+        this.data.addAll(records);
+        if(this.snapshot){
+            this.snapshot.addAll(records);
         }
+        this.fireEvent('add', this, records, index);
     },
 
-    // private
-    onCollapseClick : function(e){
-        this.panel.collapse();
+    /**
+     * (Local sort only) Inserts the passed Record into the Store at the index where it
+     * should go based on the current sort information.
+     * @param {Ext.data.Record} record
+     */
+    addSorted : function(record){
+        var index = this.findInsertIndex(record);
+        this.insert(index, record);
     },
 
-    // private
-    beforeCollapse : function(p, animate){
-        this.lastAnim = animate;
-        if(this.splitEl){
-            this.splitEl.hide();
+    /**
+     * Remove Records from the Store and fires the {@link #remove} event.
+     * @param {Ext.data.Record/Ext.data.Record[]} record The record object or array of records to remove from the cache.
+     */
+    remove : function(record){
+        if(Ext.isArray(record)){
+            Ext.each(record, function(r){
+                this.remove(r);
+            }, this);
         }
-        this.getCollapsedEl().show();
-        var el = this.panel.getEl();
-        this.originalZIndex = el.getStyle('z-index');
-        el.setStyle('z-index', 100);
-        this.isCollapsed = true;
-        this.layout.layout();
-    },
-
-    // private
-    onCollapse : function(animate){
-        this.panel.el.setStyle('z-index', 1);
-        if(this.lastAnim === false || this.panel.animCollapse === false){
-            this.getCollapsedEl().dom.style.visibility = 'visible';
-        }else{
-            this.getCollapsedEl().slideIn(this.panel.slideAnchor, {duration:.2});
+        var index = this.data.indexOf(record);
+        if(index > -1){
+            record.join(null);
+            this.data.removeAt(index);
         }
-        this.state.collapsed = true;
-        this.panel.saveState();
-    },
-
-    // private
-    beforeExpand : function(animate){
-        if(this.isSlid){
-            this.afterSlideIn();
+        if(this.pruneModifiedRecords){
+            this.modified.remove(record);
         }
-        var c = this.getCollapsedEl();
-        this.el.show();
-        if(this.position == 'east' || this.position == 'west'){
-            this.panel.setSize(undefined, c.getHeight());
-        }else{
-            this.panel.setSize(c.getWidth(), undefined);
+        if(this.snapshot){
+            this.snapshot.remove(record);
         }
-        c.hide();
-        c.dom.style.visibility = 'hidden';
-        this.panel.el.setStyle('z-index', this.floatingZIndex);
-    },
-
-    // private
-    onExpand : function(){
-        this.isCollapsed = false;
-        if(this.splitEl){
-            this.splitEl.show();
+        if(index > -1){
+            this.fireEvent('remove', this, record, index);
         }
-        this.layout.layout();
-        this.panel.el.setStyle('z-index', this.originalZIndex);
-        this.state.collapsed = false;
-        this.panel.saveState();
     },
 
-    // private
-    collapseClick : function(e){
-        if(this.isSlid){
-           e.stopPropagation();
-           this.slideIn();
-        }else{
-           e.stopPropagation();
-           this.slideOut();
-        }
+    /**
+     * Remove a Record from the Store at the specified index. Fires the {@link #remove} event.
+     * @param {Number} index The index of the record to remove.
+     */
+    removeAt : function(index){
+        this.remove(this.getAt(index));
     },
 
-    // private
-    onHide : function(){
-        if(this.isCollapsed){
-            this.getCollapsedEl().hide();
-        }else if(this.splitEl){
-            this.splitEl.hide();
+    /**
+     * Remove all Records from the Store and fires the {@link #clear} event.
+     * @param {Boolean} silent [false] Defaults to false.  Set true to not fire clear event.
+     */
+    removeAll : function(silent){
+        var items = [];
+        this.each(function(rec){
+            items.push(rec);
+        });
+        this.clearData();
+        if(this.snapshot){
+            this.snapshot.clear();
         }
-    },
-
-    // private
-    onShow : function(){
-        if(this.isCollapsed){
-            this.getCollapsedEl().show();
-        }else if(this.splitEl){
-            this.splitEl.show();
+        if(this.pruneModifiedRecords){
+            this.modified = [];
+        }
+        if (silent !== true) {  // <-- prevents write-actions when we just want to clear a store.
+            this.fireEvent('clear', this, items);
         }
     },
 
-    /**
-     * True if this region is currently visible, else false.
-     * @return {Boolean}
-     */
-    isVisible : function(){
-        return !this.panel.hidden;
+    // private
+    onClear: function(store, records){
+        Ext.each(records, function(rec, index){
+            this.destroyRecord(this, rec, index);
+        }, this);
     },
 
     /**
-     * Returns the current margins for this region.  If the region is collapsed, the
-     * {@link #cmargins} (collapsed margins) value will be returned, otherwise the
-     * {@link #margins} value will be returned.
-     * @return {Object} An object containing the element's margins: {left: (left
-     * margin), top: (top margin), right: (right margin), bottom: (bottom margin)}
+     * Inserts Records into the Store at the given index and fires the {@link #add} event.
+     * See also {@link #add} and {@link #addSorted}.
+     * @param {Number} index The start index at which to insert the passed Records.
+     * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects to add to the cache.
      */
-    getMargins : function(){
-        return this.isCollapsed && this.cmargins ? this.cmargins : this.margins;
+    insert : function(index, records){
+        records = [].concat(records);
+        for(var i = 0, len = records.length; i < len; i++){
+            this.data.insert(index, records[i]);
+            records[i].join(this);
+        }
+        if(this.snapshot){
+            this.snapshot.addAll(records);
+        }
+        this.fireEvent('add', this, records, index);
     },
 
     /**
-     * Returns the current size of this region.  If the region is collapsed, the size of the
-     * collapsedEl will be returned, otherwise the size of the region's panel will be returned.
-     * @return {Object} An object containing the element's size: {width: (element width),
-     * height: (element height)}
+     * Get the index within the cache of the passed Record.
+     * @param {Ext.data.Record} record The Ext.data.Record object to find.
+     * @return {Number} The index of the passed Record. Returns -1 if not found.
      */
-    getSize : function(){
-        return this.isCollapsed ? this.getCollapsedEl().getSize() : this.panel.getSize();
+    indexOf : function(record){
+        return this.data.indexOf(record);
     },
 
     /**
-     * Sets the specified panel as the container element for this region.
-     * @param {Ext.Panel} panel The new panel
+     * Get the index within the cache of the Record with the passed id.
+     * @param {String} id The id of the Record to find.
+     * @return {Number} The index of the Record. Returns -1 if not found.
      */
-    setPanel : function(panel){
-        this.panel = panel;
+    indexOfId : function(id){
+        return this.data.indexOfKey(id);
     },
 
     /**
-     * Returns the minimum allowable width for this region.
-     * @return {Number} The minimum width
+     * Get the Record with the specified id.
+     * @param {String} id The id of the Record to find.
+     * @return {Ext.data.Record} The Record with the passed id. Returns undefined if not found.
      */
-    getMinWidth: function(){
-        return this.minWidth;
+    getById : function(id){
+        return (this.snapshot || this.data).key(id);
     },
 
     /**
-     * Returns the minimum allowable height for this region.
-     * @return {Number} The minimum height
+     * Get the Record at the specified index.
+     * @param {Number} index The index of the Record to find.
+     * @return {Ext.data.Record} The Record at the passed index. Returns undefined if not found.
      */
-    getMinHeight: function(){
-        return this.minHeight;
-    },
-
-    // private
-    applyLayoutCollapsed : function(box){
-        var ce = this.getCollapsedEl();
-        ce.setLeftTop(box.x, box.y);
-        ce.setSize(box.width, box.height);
+    getAt : function(index){
+        return this.data.itemAt(index);
     },
 
-    // private
-    applyLayout : function(box){
-        if(this.isCollapsed){
-            this.applyLayoutCollapsed(box);
-        }else{
-            this.panel.setPosition(box.x, box.y);
-            this.panel.setSize(box.width, box.height);
-        }
+    /**
+     * Returns a range of Records between specified indices.
+     * @param {Number} startIndex (optional) The starting index (defaults to 0)
+     * @param {Number} endIndex (optional) The ending index (defaults to the last Record in the Store)
+     * @return {Ext.data.Record[]} An array of Records
+     */
+    getRange : function(start, end){
+        return this.data.getRange(start, end);
     },
 
     // private
-    beforeSlide: function(){
-        this.panel.beforeEffect();
+    storeOptions : function(o){
+        o = Ext.apply({}, o);
+        delete o.callback;
+        delete o.scope;
+        this.lastOptions = o;
     },
 
     // private
-    afterSlide : function(){
-        this.panel.afterEffect();
+    clearData: function(){
+        this.data.each(function(rec) {
+            rec.join(null);
+        });
+        this.data.clear();
     },
 
-    // private
-    initAutoHide : function(){
-        if(this.autoHide !== false){
-            if(!this.autoHideHd){
-                var st = new Ext.util.DelayedTask(this.slideIn, this);
-                this.autoHideHd = {
-                    "mouseout": function(e){
-                        if(!e.within(this.el, true)){
-                            st.delay(500);
-                        }
-                    },
-                    "mouseover" : function(e){
-                        st.cancel();
-                    },
-                    scope : this
-                };
-            }
-            this.el.on(this.autoHideHd);
-            this.collapsedEl.on(this.autoHideHd);
+    /**
+     * Loads the Record cache from the configured {@link #proxy} using the configured {@link #reader}.
+     * 
Notes:

+     * Important: loading is asynchronous! This call will return before the new data has been
+     * loaded. To perform any post-processing where information from the load call is required, specify
+     * the callback function to be called, or use a {@link Ext.util.Observable#listeners a 'load' event handler}.
+     * If using {@link Ext.PagingToolbar remote paging}, the first load call must specify the start and limit
+     * properties in the options.params property to establish the initial position within the
+     * dataset, and the number of Records to cache on each read from the Proxy.
+     * If using {@link #remoteSort remote sorting}, the configured {@link #sortInfo}
+     * will be automatically included with the posted parameters according to the specified
+     * {@link #paramNames}.
+     * 
+     * @param {Object} options An object containing properties which control loading options:
+     * params :ObjectAn object containing properties to pass as HTTP
+     * parameters to a remote data source. Note: params will override any
+     * {@link #baseParams} of the same name.
+     * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}.
+     * callback : FunctionA function to be called after the Records
+     * have been loaded. The callback is called after the load event is fired, and is passed the following arguments:

+     * r : Ext.data.Record[] An Array of Records loaded.
+     * options : Options object from the load call.
+     * success : Boolean success indicator.

+     * scope : ObjectScope with which to call the callback (defaults
+     * to the Store object)
+     * add : BooleanIndicator to append loaded records rather than
+     * replace the current cache.  Note: see note for {@link #loadData}
+     * 
+     * @return {Boolean} If the developer provided {@link #beforeload} event handler returns
+     * false, the load call will abort and will return false; otherwise will return true.
+     */
+    load : function(options) {
+        options = Ext.apply({}, options);
+        this.storeOptions(options);
+        if(this.sortInfo && this.remoteSort){
+            var pn = this.paramNames;
+            options.params = Ext.apply({}, options.params);
+            options.params[pn.sort] = this.sortInfo.field;
+            options.params[pn.dir] = this.sortInfo.direction;
         }
-    },
-
-    // private
-    clearAutoHide : function(){
-        if(this.autoHide !== false){
-            this.el.un("mouseout", this.autoHideHd.mouseout);
-            this.el.un("mouseover", this.autoHideHd.mouseover);
-            this.collapsedEl.un("mouseout", this.autoHideHd.mouseout);
-            this.collapsedEl.un("mouseover", this.autoHideHd.mouseover);
+        try {
+            return this.execute('read', null, options); // <-- null represents rs.  No rs for load actions.
+        } catch(e) {
+            this.handleException(e);
+            return false;
         }
     },
 
-    // private
-    clearMonitor : function(){
-        Ext.getDoc().un("click", this.slideInIf, this);
+    /**
+     * updateRecord  Should not be used directly.  This method will be called automatically if a Writer is set.
+     * Listens to 'update' event.
+     * @param {Object} store
+     * @param {Object} record
+     * @param {Object} action
+     * @private
+     */
+    updateRecord : function(store, record, action) {
+        if (action == Ext.data.Record.EDIT && this.autoSave === true && (!record.phantom || (record.phantom && record.isValid()))) {
+            this.save();
+        }
     },
 
     /**
-     * If this Region is {@link #floatable}, this method slides this Region into full visibility over the top
-     * of the center Region where it floats until either {@link #slideIn} is called, or other regions of the layout
-     * are clicked, or the mouse exits the Region.
+     * Should not be used directly.  Store#add will call this automatically if a Writer is set
+     * @param {Object} store
+     * @param {Object} rs
+     * @param {Object} index
+     * @private
      */
-    slideOut : function(){
-        if(this.isSlid || this.el.hasActiveFx()){
-            return;
-        }
-        this.isSlid = true;
-        var ts = this.panel.tools, dh, pc;
-        if(ts && ts.toggle){
-            ts.toggle.hide();
+    createRecords : function(store, rs, index) {
+        for (var i = 0, len = rs.length; i < len; i++) {
+            if (rs[i].phantom && rs[i].isValid()) {
+                rs[i].markDirty();  // <-- Mark new records dirty
+                this.modified.push(rs[i]);  // <-- add to modified
+            }
         }
-        this.el.show();
-
-        // Temporarily clear the collapsed flag so we can onResize the panel on the slide
-        pc = this.panel.collapsed;
-        this.panel.collapsed = false;
-
-        if(this.position == 'east' || this.position == 'west'){
-            // Temporarily clear the deferHeight flag so we can size the height on the slide
-            dh = this.panel.deferHeight;
-            this.panel.deferHeight = false;
-
-            this.panel.setSize(undefined, this.collapsedEl.getHeight());
-
-            // Put the deferHeight flag back after setSize
-            this.panel.deferHeight = dh;
-        }else{
-            this.panel.setSize(this.collapsedEl.getWidth(), undefined);
+        if (this.autoSave === true) {
+            this.save();
         }
+    },
 
-        // Put the collapsed flag back after onResize
-        this.panel.collapsed = pc;
-
-        this.restoreLT = [this.el.dom.style.left, this.el.dom.style.top];
-        this.el.alignTo(this.collapsedEl, this.getCollapseAnchor());
-        this.el.setStyle("z-index", this.floatingZIndex+2);
-        this.panel.el.replaceClass('x-panel-collapsed', 'x-panel-floating');
-        if(this.animFloat !== false){
-            this.beforeSlide();
-            this.el.slideIn(this.getSlideAnchor(), {
-                callback: function(){
-                    this.afterSlide();
-                    this.initAutoHide();
-                    Ext.getDoc().on("click", this.slideInIf, this);
-                },
-                scope: this,
-                block: true
-            });
-        }else{
-            this.initAutoHide();
-             Ext.getDoc().on("click", this.slideInIf, this);
+    /**
+     * Destroys a Record.  Should not be used directly.  It's called by Store#remove if a Writer is set.
+     * @param {Store} store this
+     * @param {Ext.data.Record} record
+     * @param {Number} index
+     * @private
+     */
+    destroyRecord : function(store, record, index) {
+        if (this.modified.indexOf(record) != -1) {  // <-- handled already if @cfg pruneModifiedRecords == true
+            this.modified.remove(record);
         }
-    },
+        if (!record.phantom) {
+            this.removed.push(record);
 
-    // private
-    afterSlideIn : function(){
-        this.clearAutoHide();
-        this.isSlid = false;
-        this.clearMonitor();
-        this.el.setStyle("z-index", "");
-        this.panel.el.replaceClass('x-panel-floating', 'x-panel-collapsed');
-        this.el.dom.style.left = this.restoreLT[0];
-        this.el.dom.style.top = this.restoreLT[1];
+            // since the record has already been removed from the store but the server request has not yet been executed,
+            // must keep track of the last known index this record existed.  If a server error occurs, the record can be
+            // put back into the store.  @see Store#createCallback where the record is returned when response status === false
+            record.lastIndex = index;
 
-        var ts = this.panel.tools;
-        if(ts && ts.toggle){
-            ts.toggle.show();
+            if (this.autoSave === true) {
+                this.save();
+            }
         }
     },
 
     /**
-     * If this Region is {@link #floatable}, and this Region has been slid into floating visibility, then this method slides
-     * this region back into its collapsed state.
+     * This method should generally not be used directly.  This method is called internally
+     * by {@link #load}, or if a Writer is set will be called automatically when {@link #add},
+     * {@link #remove}, or {@link #update} events fire.
+     * @param {String} action Action name ('read', 'create', 'update', or 'destroy')
+     * @param {Record/Record[]} rs
+     * @param {Object} options
+     * @throws Error
+     * @private
      */
-    slideIn : function(cb){
-        if(!this.isSlid || this.el.hasActiveFx()){
-            Ext.callback(cb);
-            return;
+    execute : function(action, rs, options, /* private */ batch) {
+        // blow up if action not Ext.data.CREATE, READ, UPDATE, DESTROY
+        if (!Ext.data.Api.isAction(action)) {
+            throw new Ext.data.Api.Error('execute', action);
         }
-        this.isSlid = false;
-        if(this.animFloat !== false){
-            this.beforeSlide();
-            this.el.slideOut(this.getSlideAnchor(), {
-                callback: function(){
-                    this.el.hide();
-                    this.afterSlide();
-                    this.afterSlideIn();
-                    Ext.callback(cb);
-                },
-                scope: this,
-                block: true
-            });
-        }else{
-            this.el.hide();
-            this.afterSlideIn();
+        // make sure options has a fresh, new params hash
+        options = Ext.applyIf(options||{}, {
+            params: {}
+        });
+        if(batch !== undefined){
+            this.addToBatch(batch);
         }
-    },
+        // have to separate before-events since load has a different signature than create,destroy and save events since load does not
+        // include the rs (record resultset) parameter.  Capture return values from the beforeaction into doRequest flag.
+        var doRequest = true;
 
-    // private
-    slideInIf : function(e){
-        if(!e.within(this.el)){
-            this.slideIn();
+        if (action === 'read') {
+            doRequest = this.fireEvent('beforeload', this, options);
+            Ext.applyIf(options.params, this.baseParams);
         }
-    },
-
-    // private
-    anchors : {
-        "west" : "left",
-        "east" : "right",
-        "north" : "top",
-        "south" : "bottom"
-    },
-
-    // private
-    sanchors : {
-        "west" : "l",
-        "east" : "r",
-        "north" : "t",
-        "south" : "b"
-    },
-
-    // private
-    canchors : {
-        "west" : "tl-tr",
-        "east" : "tr-tl",
-        "north" : "tl-bl",
-        "south" : "bl-tl"
-    },
-
-    // private
-    getAnchor : function(){
-        return this.anchors[this.position];
-    },
-
-    // private
-    getCollapseAnchor : function(){
-        return this.canchors[this.position];
-    },
-
-    // private
-    getSlideAnchor : function(){
-        return this.sanchors[this.position];
-    },
-
-    // private
-    getAlignAdj : function(){
-        var cm = this.cmargins;
-        switch(this.position){
-            case "west":
-                return [0, 0];
-            break;
-            case "east":
-                return [0, 0];
-            break;
-            case "north":
-                return [0, 0];
-            break;
-            case "south":
-                return [0, 0];
-            break;
+        else {
+            // if Writer is configured as listful, force single-record rs to be [{}] instead of {}
+            // TODO Move listful rendering into DataWriter where the @cfg is defined.  Should be easy now.
+            if (this.writer.listful === true && this.restful !== true) {
+                rs = (Ext.isArray(rs)) ? rs : [rs];
+            }
+            // if rs has just a single record, shift it off so that Writer writes data as '{}' rather than '[{}]'
+            else if (Ext.isArray(rs) && rs.length == 1) {
+                rs = rs.shift();
+            }
+            // Write the action to options.params
+            if ((doRequest = this.fireEvent('beforewrite', this, action, rs, options)) !== false) {
+                this.writer.apply(options.params, this.baseParams, action, rs);
+            }
         }
-    },
-
-    // private
-    getExpandAdj : function(){
-        var c = this.collapsedEl, cm = this.cmargins;
-        switch(this.position){
-            case "west":
-                return [-(cm.right+c.getWidth()+cm.left), 0];
-            break;
-            case "east":
-                return [cm.right+c.getWidth()+cm.left, 0];
-            break;
-            case "north":
-                return [0, -(cm.top+cm.bottom+c.getHeight())];
-            break;
-            case "south":
-                return [0, cm.top+cm.bottom+c.getHeight()];
-            break;
+        if (doRequest !== false) {
+            // Send request to proxy.
+            if (this.writer && this.proxy.url && !this.proxy.restful && !Ext.data.Api.hasUniqueUrl(this.proxy, action)) {
+                options.params.xaction = action;    // <-- really old, probaby unecessary.
+            }
+            // Note:  Up until this point we've been dealing with 'action' as a key from Ext.data.Api.actions.
+            // We'll flip it now and send the value into DataProxy#request, since it's the value which maps to
+            // the user's configured DataProxy#api
+            // TODO Refactor all Proxies to accept an instance of Ext.data.Request (not yet defined) instead of this looooooong list
+            // of params.  This method is an artifact from Ext2.
+            this.proxy.request(Ext.data.Api.actions[action], rs, options.params, this.reader, this.createCallback(action, rs, batch), this, options);
         }
+        return doRequest;
     },
 
-    destroy : function(){
-        Ext.destroy(this.miniCollapsedEl, this.collapsedEl);
-    }
-};
-
-/**
- * @class Ext.layout.BorderLayout.SplitRegion
- * @extends Ext.layout.BorderLayout.Region
- * This is a specialized type of {@link Ext.layout.BorderLayout.Region BorderLayout region} that
- * has a built-in {@link Ext.SplitBar} for user resizing of regions.  The movement of the split bar
- * is configurable to move either {@link #tickSize smooth or incrementally}.
- * @constructor
- * Create a new SplitRegion.
- * @param {Layout} layout The {@link Ext.layout.BorderLayout BorderLayout} instance that is managing this Region.
- * @param {Object} config The configuration options
- * @param {String} position The region position.  Valid values are: north, south, east, west and center.  Every
- * BorderLayout must have a center region for the primary content -- all other regions are optional.
- */
-Ext.layout.BorderLayout.SplitRegion = function(layout, config, pos){
-    Ext.layout.BorderLayout.SplitRegion.superclass.constructor.call(this, layout, config, pos);
-    // prevent switch
-    this.applyLayout = this.applyFns[pos];
-};
-
-Ext.extend(Ext.layout.BorderLayout.SplitRegion, Ext.layout.BorderLayout.Region, {
-    /**
-     * @cfg {Number} tickSize
-     * The increment, in pixels by which to move this Region's {@link Ext.SplitBar SplitBar}.
-     * By default, the {@link Ext.SplitBar SplitBar} moves smoothly.
-     */
-    /**
-     * @cfg {String} splitTip
-     * The tooltip to display when the user hovers over a
-     * {@link Ext.layout.BorderLayout.Region#collapsible non-collapsible} region's split bar
-     * (defaults to "Drag to resize.").  Only applies if
-     * {@link #useSplitTips} = true.
-     */
-    splitTip : "Drag to resize.",
-    /**
-     * @cfg {String} collapsibleSplitTip
-     * The tooltip to display when the user hovers over a
-     * {@link Ext.layout.BorderLayout.Region#collapsible collapsible} region's split bar
-     * (defaults to "Drag to resize. Double click to hide."). Only applies if
-     * {@link #useSplitTips} = true.
-     */
-    collapsibleSplitTip : "Drag to resize. Double click to hide.",
     /**
-     * @cfg {Boolean} useSplitTips
-     * true to display a tooltip when the user hovers over a region's split bar
-     * (defaults to false).  The tooltip text will be the value of either
-     * {@link #splitTip} or {@link #collapsibleSplitTip} as appropriate.
+     * Saves all pending changes to the store.  If the commensurate Ext.data.Api.actions action is not configured, then
+     * the configured {@link #url} will be used.
+     * +     * change            url
+     * ---------------   --------------------
+     * removed records   Ext.data.Api.actions.destroy
+     * phantom records   Ext.data.Api.actions.create
+     * {@link #getModifiedRecords modified records}  Ext.data.Api.actions.update
+     * 
+     * @TODO:  Create extensions of Error class and send associated Record with thrown exceptions.
+     * e.g.:  Ext.data.DataReader.Error or Ext.data.Error or Ext.data.DataProxy.Error, etc.
+     * @return {Number} batch Returns a number to uniquely identify the "batch" of saves occurring. -1 will be returned
+     * if there are no items to save or the save was cancelled.
      */
-    useSplitTips : false,
+    save : function() {
+        if (!this.writer) {
+            throw new Ext.data.Store.Error('writer-undefined');
+        }
 
-    // private
-    splitSettings : {
-        north : {
-            orientation: Ext.SplitBar.VERTICAL,
-            placement: Ext.SplitBar.TOP,
-            maxFn : 'getVMaxSize',
-            minProp: 'minHeight',
-            maxProp: 'maxHeight'
-        },
-        south : {
-            orientation: Ext.SplitBar.VERTICAL,
-            placement: Ext.SplitBar.BOTTOM,
-            maxFn : 'getVMaxSize',
-            minProp: 'minHeight',
-            maxProp: 'maxHeight'
-        },
-        east : {
-            orientation: Ext.SplitBar.HORIZONTAL,
-            placement: Ext.SplitBar.RIGHT,
-            maxFn : 'getHMaxSize',
-            minProp: 'minWidth',
-            maxProp: 'maxWidth'
-        },
-        west : {
-            orientation: Ext.SplitBar.HORIZONTAL,
-            placement: Ext.SplitBar.LEFT,
-            maxFn : 'getHMaxSize',
-            minProp: 'minWidth',
-            maxProp: 'maxWidth'
+        var queue = [],
+            len,
+            trans,
+            batch,
+            data = {};
+        // DESTROY:  First check for removed records.  Records in this.removed are guaranteed non-phantoms.  @see Store#remove
+        if(this.removed.length){
+            queue.push(['destroy', this.removed]);
         }
-    },
 
-    // private
-    applyFns : {
-        west : function(box){
-            if(this.isCollapsed){
-                return this.applyLayoutCollapsed(box);
+        // Check for modified records. Use a copy so Store#rejectChanges will work if server returns error.
+        var rs = [].concat(this.getModifiedRecords());
+        if(rs.length){
+            // CREATE:  Next check for phantoms within rs.  splice-off and execute create.
+            var phantoms = [];
+            for(var i = rs.length-1; i >= 0; i--){
+                if(rs[i].phantom === true){
+                    var rec = rs.splice(i, 1).shift();
+                    if(rec.isValid()){
+                        phantoms.push(rec);
+                    }
+                }else if(!rs[i].isValid()){ // <-- while we're here, splice-off any !isValid real records
+                    rs.splice(i,1);
+                }
+            }
+            // If we have valid phantoms, create them...
+            if(phantoms.length){
+                queue.push(['create', phantoms]);
+            }
+
+            // UPDATE:  And finally, if we're still here after splicing-off phantoms and !isValid real records, update the rest...
+            if(rs.length){
+                queue.push(['update', rs]);
             }
-            var sd = this.splitEl.dom, s = sd.style;
-            this.panel.setPosition(box.x, box.y);
-            var sw = sd.offsetWidth;
-            s.left = (box.x+box.width-sw)+'px';
-            s.top = (box.y)+'px';
-            s.height = Math.max(0, box.height)+'px';
-            this.panel.setSize(box.width-sw, box.height);
-        },
-        east : function(box){
-            if(this.isCollapsed){
-                return this.applyLayoutCollapsed(box);
+        }
+        len = queue.length;
+        if(len){
+            batch = ++this.batchCounter;
+            for(var i = 0; i < len; ++i){
+                trans = queue[i];
+                data[trans[0]] = trans[1];
             }
-            var sd = this.splitEl.dom, s = sd.style;
-            var sw = sd.offsetWidth;
-            this.panel.setPosition(box.x+sw, box.y);
-            s.left = (box.x)+'px';
-            s.top = (box.y)+'px';
-            s.height = Math.max(0, box.height)+'px';
-            this.panel.setSize(box.width-sw, box.height);
-        },
-        north : function(box){
-            if(this.isCollapsed){
-                return this.applyLayoutCollapsed(box);
+            if(this.fireEvent('beforesave', this, data) !== false){
+                for(var i = 0; i < len; ++i){
+                    trans = queue[i];
+                    this.doTransaction(trans[0], trans[1], batch);
+                }
+                return batch;
             }
-            var sd = this.splitEl.dom, s = sd.style;
-            var sh = sd.offsetHeight;
-            this.panel.setPosition(box.x, box.y);
-            s.left = (box.x)+'px';
-            s.top = (box.y+box.height-sh)+'px';
-            s.width = Math.max(0, box.width)+'px';
-            this.panel.setSize(box.width, box.height-sh);
-        },
-        south : function(box){
-            if(this.isCollapsed){
-                return this.applyLayoutCollapsed(box);
+        }
+        return -1;
+    },
+
+    // private.  Simply wraps call to Store#execute in try/catch.  Defers to Store#handleException on error.  Loops if batch: false
+    doTransaction : function(action, rs, batch) {
+        function transaction(records) {
+            try{
+                this.execute(action, records, undefined, batch);
+            }catch (e){
+                this.handleException(e);
             }
-            var sd = this.splitEl.dom, s = sd.style;
-            var sh = sd.offsetHeight;
-            this.panel.setPosition(box.x, box.y+sh);
-            s.left = (box.x)+'px';
-            s.top = (box.y)+'px';
-            s.width = Math.max(0, box.width)+'px';
-            this.panel.setSize(box.width, box.height-sh);
+        }
+        if(this.batch === false){
+            for(var i = 0, len = rs.length; i < len; i++){
+                transaction.call(this, rs[i]);
+            }
+        }else{
+            transaction.call(this, rs);
         }
     },
 
     // private
-    render : function(ct, p){
-        Ext.layout.BorderLayout.SplitRegion.superclass.render.call(this, ct, p);
+    addToBatch : function(batch){
+        var b = this.batches,
+            key = this.batchKey + batch,
+            o = b[key];
 
-        var ps = this.position;
+        if(!o){
+            b[key] = o = {
+                id: batch,
+                count: 0,
+                data: {}
+            };
+        }
+        ++o.count;
+    },
 
-        this.splitEl = ct.createChild({
-            cls: "x-layout-split x-layout-split-"+ps, html: " ",
-            id: this.panel.id + '-xsplit'
-        });
+    removeFromBatch : function(batch, action, data){
+        var b = this.batches,
+            key = this.batchKey + batch,
+            o = b[key],
+            data,
+            arr;
 
-        if(this.collapseMode == 'mini'){
-            this.miniSplitEl = this.splitEl.createChild({
-                cls: "x-layout-mini x-layout-mini-"+ps, html: " "
-            });
-            this.miniSplitEl.addClassOnOver('x-layout-mini-over');
-            this.miniSplitEl.on('click', this.onCollapseClick, this, {stopEvent:true});
+
+        if(o){
+            arr = o.data[action] || [];
+            o.data[action] = arr.concat(data);
+            if(o.count === 1){
+                data = o.data;
+                delete b[key];
+                this.fireEvent('save', this, batch, data);
+            }else{
+                --o.count;
+            }
         }
+    },
 
-        var s = this.splitSettings[ps];
+    // @private callback-handler for remote CRUD actions
+    // Do not override -- override loadRecords, onCreateRecords, onDestroyRecords and onUpdateRecords instead.
+    createCallback : function(action, rs, batch) {
+        var actions = Ext.data.Api.actions;
+        return (action == 'read') ? this.loadRecords : function(data, response, success) {
+            // calls: onCreateRecords | onUpdateRecords | onDestroyRecords
+            this['on' + Ext.util.Format.capitalize(action) + 'Records'](success, rs, [].concat(data));
+            // If success === false here, exception will have been called in DataProxy
+            if (success === true) {
+                this.fireEvent('write', this, action, data, response, rs);
+            }
+            this.removeFromBatch(batch, action, data);
+        };
+    },
 
-        this.split = new Ext.SplitBar(this.splitEl.dom, p.el, s.orientation);
-        this.split.tickSize = this.tickSize;
-        this.split.placement = s.placement;
-        this.split.getMaximumSize = this[s.maxFn].createDelegate(this);
-        this.split.minSize = this.minSize || this[s.minProp];
-        this.split.on("beforeapply", this.onSplitMove, this);
-        this.split.useShim = this.useShim === true;
-        this.maxSize = this.maxSize || this[s.maxProp];
+    // Clears records from modified array after an exception event.
+    // NOTE:  records are left marked dirty.  Do we want to commit them even though they were not updated/realized?
+    // TODO remove this method?
+    clearModified : function(rs) {
+        if (Ext.isArray(rs)) {
+            for (var n=rs.length-1;n>=0;n--) {
+                this.modified.splice(this.modified.indexOf(rs[n]), 1);
+            }
+        } else {
+            this.modified.splice(this.modified.indexOf(rs), 1);
+        }
+    },
 
-        if(p.hidden){
-            this.splitEl.hide();
+    // remap record ids in MixedCollection after records have been realized.  @see Store#onCreateRecords, @see DataReader#realize
+    reMap : function(record) {
+        if (Ext.isArray(record)) {
+            for (var i = 0, len = record.length; i < len; i++) {
+                this.reMap(record[i]);
+            }
+        } else {
+            delete this.data.map[record._phid];
+            this.data.map[record.id] = record;
+            var index = this.data.keys.indexOf(record._phid);
+            this.data.keys.splice(index, 1, record.id);
+            delete record._phid;
         }
+    },
 
-        if(this.useSplitTips){
-            this.splitEl.dom.title = this.collapsible ? this.collapsibleSplitTip : this.splitTip;
+    // @protected onCreateRecord proxy callback for create action
+    onCreateRecords : function(success, rs, data) {
+        if (success === true) {
+            try {
+                this.reader.realize(rs, data);
+                this.reMap(rs);
+            }
+            catch (e) {
+                this.handleException(e);
+                if (Ext.isArray(rs)) {
+                    // Recurse to run back into the try {}.  DataReader#realize splices-off the rs until empty.
+                    this.onCreateRecords(success, rs, data);
+                }
+            }
         }
-        if(this.collapsible){
-            this.splitEl.on("dblclick", this.onCollapseClick,  this);
+    },
+
+    // @protected, onUpdateRecords proxy callback for update action
+    onUpdateRecords : function(success, rs, data) {
+        if (success === true) {
+            try {
+                this.reader.update(rs, data);
+            } catch (e) {
+                this.handleException(e);
+                if (Ext.isArray(rs)) {
+                    // Recurse to run back into the try {}.  DataReader#update splices-off the rs until empty.
+                    this.onUpdateRecords(success, rs, data);
+                }
+            }
         }
     },
 
-    //docs inherit from superclass
-    getSize : function(){
-        if(this.isCollapsed){
-            return this.collapsedEl.getSize();
+    // @protected onDestroyRecords proxy callback for destroy action
+    onDestroyRecords : function(success, rs, data) {
+        // splice each rec out of this.removed
+        rs = (rs instanceof Ext.data.Record) ? [rs] : [].concat(rs);
+        for (var i=0,len=rs.length;i=0;i--) {
+                this.insert(rs[i].lastIndex, rs[i]);    // <-- lastIndex set in Store#destroyRecord
+            }
         }
-        return s;
     },
 
-    // private
-    getHMaxSize : function(){
-         var cmax = this.maxSize || 10000;
-         var center = this.layout.center;
-         return Math.min(cmax, (this.el.getWidth()+center.el.getWidth())-center.getMinWidth());
+    // protected handleException.  Possibly temporary until Ext framework has an exception-handler.
+    handleException : function(e) {
+        // @see core/Error.js
+        Ext.handleError(e);
     },
 
-    // private
-    getVMaxSize : function(){
-        var cmax = this.maxSize || 10000;
-        var center = this.layout.center;
-        return Math.min(cmax, (this.el.getHeight()+center.el.getHeight())-center.getMinHeight());
+    /**
+     * Reloads the Record cache from the configured Proxy using the configured
+     * {@link Ext.data.Reader Reader} and the options from the last load operation
+     * performed.
+     * Note: see the Important note in {@link #load}.
+     * @param {Object} options (optional) An Object containing
+     * {@link #load loading options} which may override the {@link #lastOptions options}
+     * used in the last {@link #load} operation. See {@link #load} for details
+     * (defaults to null, in which case the {@link #lastOptions} are
+     * used).
+     * 
To add new params to the existing params:

+lastOptions = myStore.lastOptions;
+Ext.apply(lastOptions.params, {
+    myNewParam: true
+});
+myStore.reload(lastOptions);
+     * 
+     */
+    reload : function(options){
+        this.load(Ext.applyIf(options||{}, this.lastOptions));
     },
 
     // private
-    onSplitMove : function(split, newSize){
-        var s = this.panel.getSize();
-        this.lastSplitSize = newSize;
-        if(this.position == 'north' || this.position == 'south'){
-            this.panel.setSize(s.width, newSize);
-            this.state.height = newSize;
+    // Called as a callback by the Reader during a load operation.
+    loadRecords : function(o, options, success){
+        if (this.isDestroyed === true) {
+            return;
+        }
+        if(!o || success === false){
+            if(success !== false){
+                this.fireEvent('load', this, [], options);
+            }
+            if(options.callback){
+                options.callback.call(options.scope || this, [], options, false, o);
+            }
+            return;
+        }
+        var r = o.records, t = o.totalRecords || r.length;
+        if(!options || options.add !== true){
+            if(this.pruneModifiedRecords){
+                this.modified = [];
+            }
+            for(var i = 0, len = r.length; i < len; i++){
+                r[i].join(this);
+            }
+            if(this.snapshot){
+                this.data = this.snapshot;
+                delete this.snapshot;
+            }
+            this.clearData();
+            this.data.addAll(r);
+            this.totalLength = t;
+            this.applySort();
+            this.fireEvent('datachanged', this);
         }else{
-            this.panel.setSize(newSize, s.height);
-            this.state.width = newSize;
+            this.totalLength = Math.max(t, this.data.length+r.length);
+            this.add(r);
+        }
+        this.fireEvent('load', this, r, options);
+        if(options.callback){
+            options.callback.call(options.scope || this, r, options, true);
         }
-        this.layout.layout();
-        this.panel.saveState();
-        return false;
     },
 
     /**
-     * Returns a reference to the split bar in use by this region.
-     * @return {Ext.SplitBar} The split bar
+     * Loads data from a passed data block and fires the {@link #load} event. A {@link Ext.data.Reader Reader}
+     * which understands the format of the data must have been configured in the constructor.
+     * @param {Object} data The data block from which to read the Records.  The format of the data expected
+     * is dependent on the type of {@link Ext.data.Reader Reader} that is configured and should correspond to
+     * that {@link Ext.data.Reader Reader}'s {@link Ext.data.Reader#readRecords} parameter.
+     * @param {Boolean} append (Optional) true to append the new Records rather the default to replace
+     * the existing cache.
+     * Note: that Records in a Store are keyed by their {@link Ext.data.Record#id id}, so added Records
+     * with ids which are already present in the Store will replace existing Records. Only Records with
+     * new, unique ids will be added.
      */
-    getSplitBar : function(){
-        return this.split;
+    loadData : function(o, append){
+        var r = this.reader.readRecords(o);
+        this.loadRecords(r, {add: append}, true);
     },
 
-    // inherit docs
-    destroy : function() {
-        Ext.destroy(this.miniSplitEl, this.split, this.splitEl);
-        Ext.layout.BorderLayout.SplitRegion.superclass.destroy.call(this);
-    }
-});
+    /**
+     * Gets the number of cached records.
+     * If using paging, this may not be the total size of the dataset. If the data object
+     * used by the Reader contains the dataset size, then the {@link #getTotalCount} function returns
+     * the dataset size.  Note: see the Important note in {@link #load}.
+     * @return {Number} The number of Records in the Store's cache.
+     */
+    getCount : function(){
+        return this.data.length || 0;
+    },
 
-Ext.Container.LAYOUTS['border'] = Ext.layout.BorderLayout;/**
- * @class Ext.layout.FormLayout
- * @extends Ext.layout.AnchorLayout
- * This layout manager is specifically designed for rendering and managing child Components of
- * {@link Ext.form.FormPanel forms}. It is responsible for rendering the labels of
- * {@link Ext.form.Field Field}s.
- *
- * This layout manager is used when a Container is configured with the layout:'form'
- * {@link Ext.Container#layout layout} config option, and should generally not need to be created directly
- * via the new keyword. See {@link Ext.Container#layout} for additional details.
- *
- * In an application, it will usually be preferrable to use a {@link Ext.form.FormPanel FormPanel}
- * (which is configured with FormLayout as its layout class by default) since it also provides built-in
- * functionality for {@link Ext.form.BasicForm#doAction loading, validating and submitting} the form.
- *
- * A {@link Ext.Container Container} using the FormLayout layout manager (e.g.
- * {@link Ext.form.FormPanel} or specifying layout:'form') can also accept the following
- * layout-specific config properties:

- * {@link Ext.form.FormPanel#hideLabels hideLabels}
- * {@link Ext.form.FormPanel#labelAlign labelAlign}
- * {@link Ext.form.FormPanel#labelPad labelPad}
- * {@link Ext.form.FormPanel#labelSeparator labelSeparator}
- * {@link Ext.form.FormPanel#labelWidth labelWidth}
- * 

- *
- * Any Component (including Fields) managed by FormLayout accepts the following as a config option:
- * 

- * {@link Ext.Component#anchor anchor}
- * 

- *
- * Any Component managed by FormLayout may be rendered as a form field (with an associated label) by
- * configuring it with a non-null {@link Ext.Component#fieldLabel fieldLabel}. Components configured
- * in this way may be configured with the following options which affect the way the FormLayout renders them:
- * 

- * {@link Ext.Component#clearCls clearCls}
- * {@link Ext.Component#fieldLabel fieldLabel}
- * {@link Ext.Component#hideLabel hideLabel}
- * {@link Ext.Component#itemCls itemCls}
- * {@link Ext.Component#labelSeparator labelSeparator}
- * {@link Ext.Component#labelStyle labelStyle}
- * 

- *
- * Example usage:
- * 
-// Required if showing validation messages
-Ext.QuickTips.init();
+    /**
+     * Gets the total number of records in the dataset as returned by the server.
+     * If using paging, for this to be accurate, the data object used by the {@link #reader Reader}
+     * must contain the dataset size. For remote data sources, the value for this property
+     * (totalProperty for {@link Ext.data.JsonReader JsonReader},
+     * totalRecords for {@link Ext.data.XmlReader XmlReader}) shall be returned by a query on the server.
+     * Note: see the Important note in {@link #load}.
+     * @return {Number} The number of Records as specified in the data object passed to the Reader
+     * by the Proxy.
+     * Note: this value is not updated when changing the contents of the Store locally.
+     */
+    getTotalCount : function(){
+        return this.totalLength || 0;
+    },
 
-// While you can create a basic Panel with layout:'form', practically
-// you should usually use a FormPanel to also get its form functionality
-// since it already creates a FormLayout internally.
-var form = new Ext.form.FormPanel({
-    title: 'Form Layout',
-    bodyStyle: 'padding:15px',
-    width: 350,
-    defaultType: 'textfield',
-    defaults: {
-        // applied to each contained item
-        width: 230,
-        msgTarget: 'side'
+    /**
+     * Returns an object describing the current sort state of this Store.
+     * @return {Object} The sort state of the Store. An object with two properties:
+     * field : StringThe name of the field by which the Records are sorted.

+     * direction : StringThe sort order, 'ASC' or 'DESC' (case-sensitive).

+     * 

+     * See {@link #sortInfo} for additional details.
+     */
+    getSortState : function(){
+        return this.sortInfo;
     },
-    items: [{
-            fieldLabel: 'First Name',
-            name: 'first',
-            allowBlank: false,
-            {@link Ext.Component#labelSeparator labelSeparator}: ':' // override labelSeparator layout config
-        },{
-            fieldLabel: 'Last Name',
-            name: 'last'
-        },{
-            fieldLabel: 'Email',
-            name: 'email',
-            vtype:'email'
-        }, {
-            xtype: 'textarea',
-            hideLabel: true,     // override hideLabels layout config
-            name: 'msg',
-            anchor: '100% -53'
+
+    /**
+     * @private
+     * Invokes sortData if we have sortInfo to sort on and are not sorting remotely
+     */
+    applySort : function(){
+        if ((this.sortInfo || this.multiSortInfo) && !this.remoteSort) {
+            this.sortData();
         }
-    ],
-    buttons: [
-        {text: 'Save'},
-        {text: 'Cancel'}
-    ],
-    layoutConfig: {
-        {@link #labelSeparator}: '~' // superseded by assignment below
     },
-    // config options applicable to container when layout='form':
-    hideLabels: false,
-    labelAlign: 'left',   // or 'right' or 'top'
-    {@link Ext.form.FormPanel#labelSeparator labelSeparator}: '>>', // takes precedence over layoutConfig value
-    labelWidth: 65,       // defaults to 100
-    labelPad: 8           // defaults to 5, must specify labelWidth to be honored
-});
-

- */
-Ext.layout.FormLayout = Ext.extend(Ext.layout.AnchorLayout, {
 
     /**
-     * @cfg {String} labelSeparator
-     * See {@link Ext.form.FormPanel}.{@link Ext.form.FormPanel#labelSeparator labelSeparator}.  Configuration
-     * of this property at the container level takes precedence.
+     * @private
+     * Performs the actual sorting of data. This checks to see if we currently have a multi sort or not. It applies
+     * each sorter field/direction pair in turn by building an OR'ed master sorting function and running it against
+     * the full dataset
      */
-    labelSeparator : ':',
+    sortData : function() {
+        var sortInfo  = this.hasMultiSort ? this.multiSortInfo : this.sortInfo,
+            direction = sortInfo.direction || "ASC",
+            sorters   = sortInfo.sorters,
+            sortFns   = [];
+
+        //if we just have a single sorter, pretend it's the first in an array
+        if (!this.hasMultiSort) {
+            sorters = [{direction: direction, field: sortInfo.field}];
+        }
+
+        //create a sorter function for each sorter field/direction combo
+        for (var i=0, j = sorters.length; i < j; i++) {
+            sortFns.push(this.createSortFunction(sorters[i].field, sorters[i].direction));
+        }
+        
+        if (sortFns.length == 0) {
+            return;
+        }
+
+        //the direction modifier is multiplied with the result of the sorting functions to provide overall sort direction
+        //(as opposed to direction per field)
+        var directionModifier = direction.toUpperCase() == "DESC" ? -1 : 1;
+
+        //create a function which ORs each sorter together to enable multi-sort
+        var fn = function(r1, r2) {
+          var result = sortFns[0].call(this, r1, r2);
+
+          //if we have more than one sorter, OR any additional sorter functions together
+          if (sortFns.length > 1) {
+              for (var i=1, j = sortFns.length; i < j; i++) {
+                  result = result || sortFns[i].call(this, r1, r2);
+              }
+          }
+
+          return directionModifier * result;
+        };
+
+        //sort the data
+        this.data.sort(direction, fn);
+        if (this.snapshot && this.snapshot != this.data) {
+            this.snapshot.sort(direction, fn);
+        }
+    },
+
+    /**
+     * Creates and returns a function which sorts an array by the given field and direction
+     * @param {String} field The field to create the sorter for
+     * @param {String} direction The direction to sort by (defaults to "ASC")
+     * @return {Function} A function which sorts by the field/direction combination provided
+     */
+    createSortFunction: function(field, direction) {
+        direction = direction || "ASC";
+        var directionModifier = direction.toUpperCase() == "DESC" ? -1 : 1;
+
+        var sortType = this.fields.get(field).sortType;
+
+        //create a comparison function. Takes 2 records, returns 1 if record 1 is greater,
+        //-1 if record 2 is greater or 0 if they are equal
+        return function(r1, r2) {
+            var v1 = sortType(r1.data[field]),
+                v2 = sortType(r2.data[field]);
+
+            return directionModifier * (v1 > v2 ? 1 : (v1 < v2 ? -1 : 0));
+        };
+    },
 
     /**
-     * Read only. The CSS style specification string added to field labels in this layout if not
-     * otherwise {@link Ext.Component#labelStyle specified by each contained field}.
-     * @type String
-     * @property labelStyle
+     * Sets the default sort column and order to be used by the next {@link #load} operation.
+     * @param {String} fieldName The name of the field to sort by.
+     * @param {String} dir (optional) The sort order, 'ASC' or 'DESC' (case-sensitive, defaults to 'ASC')
      */
+    setDefaultSort : function(field, dir) {
+        dir = dir ? dir.toUpperCase() : 'ASC';
+        this.sortInfo = {field: field, direction: dir};
+        this.sortToggle[field] = dir;
+    },
 
     /**
-     * @cfg {Boolean} trackLabels
-     * True to show/hide the field label when the field is hidden. Defaults to false.
+     * Sort the Records.
+     * If remote sorting is used, the sort is performed on the server, and the cache is reloaded. If local
+     * sorting is used, the cache is sorted internally. See also {@link #remoteSort} and {@link #paramNames}.
+     * This function accepts two call signatures - pass in a field name as the first argument to sort on a single
+     * field, or pass in an array of sort configuration objects to sort by multiple fields.
+     * Single sort example:
+     * store.sort('name', 'ASC');
+     * Multi sort example:
+     * store.sort([
+     *   {
+     *     field    : 'name',
+     *     direction: 'ASC'
+     *   },
+     *   {
+     *     field    : 'salary',
+     *     direction: 'DESC'
+     *   }
+     * ], 'ASC');
+     * In this second form, the sort configs are applied in order, with later sorters sorting within earlier sorters' results.
+     * For example, if two records with the same name are present they will also be sorted by salary if given the sort configs
+     * above. Any number of sort configs can be added.
+     * @param {String/Array} fieldName The name of the field to sort by, or an array of ordered sort configs
+     * @param {String} dir (optional) The sort order, 'ASC' or 'DESC' (case-sensitive, defaults to 'ASC')
      */
-    trackLabels: false,
+    sort : function(fieldName, dir) {
+        if (Ext.isArray(arguments[0])) {
+            return this.multiSort.call(this, fieldName, dir);
+        } else {
+            return this.singleSort(fieldName, dir);
+        }
+    },
 
-    type: 'form',
+    /**
+     * Sorts the store contents by a single field and direction. This is called internally by {@link sort} and would
+     * not usually be called manually
+     * @param {String} fieldName The name of the field to sort by.
+     * @param {String} dir (optional) The sort order, 'ASC' or 'DESC' (case-sensitive, defaults to 'ASC')
+     */
+    singleSort: function(fieldName, dir) {
+        var field = this.fields.get(fieldName);
+        if (!field) return false;
 
+        var name       = field.name,
+            sortInfo   = this.sortInfo || null,
+            sortToggle = this.sortToggle ? this.sortToggle[name] : null;
 
-    onRemove: function(c){
-        Ext.layout.FormLayout.superclass.onRemove.call(this, c);
-        if(this.trackLabels){
-            c.un('show', this.onFieldShow, this);
-            c.un('hide', this.onFieldHide, this);
-        }
-        // check for itemCt, since we may be removing a fieldset or something similar
-        var el = c.getPositionEl(),
-                ct = c.getItemCt && c.getItemCt();
-        if(c.rendered && ct){
-            if (el && el.dom) {
-                el.insertAfter(ct);
+        if (!dir) {
+            if (sortInfo && sortInfo.field == name) { // toggle sort dir
+                dir = (this.sortToggle[name] || 'ASC').toggle('ASC', 'DESC');
+            } else {
+                dir = field.sortDir;
             }
-            Ext.destroy(ct);
-            Ext.destroyMembers(c, 'label', 'itemCt');
-            if(c.customItemCt){
-                Ext.destroyMembers(c, 'getItemCt', 'customItemCt');
+        }
+
+        this.sortToggle[name] = dir;
+        this.sortInfo = {field: name, direction: dir};
+        this.hasMultiSort = false;
+
+        if (this.remoteSort) {
+            if (!this.load(this.lastOptions)) {
+                if (sortToggle) {
+                    this.sortToggle[name] = sortToggle;
+                }
+                if (sortInfo) {
+                    this.sortInfo = sortInfo;
+                }
             }
+        } else {
+            this.applySort();
+            this.fireEvent('datachanged', this);
         }
     },
 
-    // private
-    setContainer : function(ct){
-        Ext.layout.FormLayout.superclass.setContainer.call(this, ct);
-        if(ct.labelAlign){
-            ct.addClass('x-form-label-'+ct.labelAlign);
+    /**
+     * Sorts the contents of this store by multiple field/direction sorters. This is called internally by {@link sort}
+     * and would not usually be called manually.
+     * Multi sorting only currently applies to local datasets - multiple sort data is not currently sent to a proxy
+     * if remoteSort is used.
+     * @param {Array} sorters Array of sorter objects (field and direction)
+     * @param {String} direction Overall direction to sort the ordered results by (defaults to "ASC")
+     */
+    multiSort: function(sorters, direction) {
+        this.hasMultiSort = true;
+        direction = direction || "ASC";
+
+        //toggle sort direction
+        if (this.multiSortInfo && direction == this.multiSortInfo.direction) {
+            direction = direction.toggle("ASC", "DESC");
         }
 
-        if(ct.hideLabels){
-            Ext.apply(this, {
-                labelStyle: 'display:none',
-                elementStyle: 'padding-left:0;',
-                labelAdjust: 0
-            });
-        }else{
-            this.labelSeparator = ct.labelSeparator || this.labelSeparator;
-            ct.labelWidth = ct.labelWidth || 100;
-            if(Ext.isNumber(ct.labelWidth)){
-                var pad = Ext.isNumber(ct.labelPad) ? ct.labelPad : 5;
-                Ext.apply(this, {
-                    labelAdjust: ct.labelWidth + pad,
-                    labelStyle: 'width:' + ct.labelWidth + 'px;',
-                    elementStyle: 'padding-left:' + (ct.labelWidth + pad) + 'px'
-                });
-            }
-            if(ct.labelAlign == 'top'){
-                Ext.apply(this, {
-                    labelStyle: 'width:auto;',
-                    labelAdjust: 0,
-                    elementStyle: 'padding-left:0;'
-                });
-            }
+        /**
+         * @property multiSortInfo
+         * @type Object
+         * Object containing overall sort direction and an ordered array of sorter configs used when sorting on multiple fields
+         */
+        this.multiSortInfo = {
+            sorters  : sorters,
+            direction: direction
+        };
+        
+        if (this.remoteSort) {
+            this.singleSort(sorters[0].field, sorters[0].direction);
+
+        } else {
+            this.applySort();
+            this.fireEvent('datachanged', this);
         }
     },
 
-    // private
-    isHide: function(c){
-        return c.hideLabel || this.container.hideLabels;
+    /**
+     * Calls the specified function for each of the {@link Ext.data.Record Records} in the cache.
+     * @param {Function} fn The function to call. The {@link Ext.data.Record Record} is passed as the first parameter.
+     * Returning false aborts and exits the iteration.
+     * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
+     * Defaults to the current {@link Ext.data.Record Record} in the iteration.
+     */
+    each : function(fn, scope){
+        this.data.each(fn, scope);
     },
 
-    onFieldShow: function(c){
-        c.getItemCt().removeClass('x-hide-' + c.hideMode);
+    /**
+     * Gets all {@link Ext.data.Record records} modified since the last commit.  Modified records are
+     * persisted across load operations (e.g., during paging). Note: deleted records are not
+     * included.  See also {@link #pruneModifiedRecords} and
+     * {@link Ext.data.Record}{@link Ext.data.Record#markDirty markDirty}..
+     * @return {Ext.data.Record[]} An array of {@link Ext.data.Record Records} containing outstanding
+     * modifications.  To obtain modified fields within a modified record see
+     *{@link Ext.data.Record}{@link Ext.data.Record#modified modified}..
+     */
+    getModifiedRecords : function(){
+        return this.modified;
     },
 
-    onFieldHide: function(c){
-        c.getItemCt().addClass('x-hide-' + c.hideMode);
+    /**
+     * Sums the value of property for each {@link Ext.data.Record record} between start
+     * and end and returns the result.
+     * @param {String} property A field in each record
+     * @param {Number} start (optional) The record index to start at (defaults to 0)
+     * @param {Number} end (optional) The last record index to include (defaults to length - 1)
+     * @return {Number} The sum
+     */
+    sum : function(property, start, end){
+        var rs = this.data.items, v = 0;
+        start = start || 0;
+        end = (end || end === 0) ? end : rs.length-1;
+
+        for(var i = start; i <= end; i++){
+            v += (rs[i].data[property] || 0);
+        }
+        return v;
     },
 
-    //private
-    getLabelStyle: function(s){
-        var ls = '', items = [this.labelStyle, s];
-        for (var i = 0, len = items.length; i < len; ++i){
-            if (items[i]){
-                ls += items[i];
-                if (ls.substr(-1, 1) != ';'){
-                    ls += ';'
-                }
-            }
+    /**
+     * @private
+     * Returns a filter function used to test a the given property's value. Defers most of the work to
+     * Ext.util.MixedCollection's createValueMatcher function
+     * @param {String} property The property to create the filter function for
+     * @param {String/RegExp} value The string/regex to compare the property value to
+     * @param {Boolean} anyMatch True if we don't care if the filter value is not the full value (defaults to false)
+     * @param {Boolean} caseSensitive True to create a case-sensitive regex (defaults to false)
+     * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. Ignored if anyMatch is true.
+     */
+    createFilterFn : function(property, value, anyMatch, caseSensitive, exactMatch){
+        if(Ext.isEmpty(value, false)){
+            return false;
         }
-        return ls;
+        value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
+        return function(r) {
+            return value.test(r.data[property]);
+        };
     },
 
     /**
-     * @cfg {Ext.Template} fieldTpl
-     * A {@link Ext.Template#compile compile}d {@link Ext.Template} for rendering
-     * the fully wrapped, labeled and styled form Field. Defaults to:

-new Ext.Template(
-    '<div class="x-form-item {itemCls}" tabIndex="-1">',
-        '<label for="{id}" style="{labelStyle}" class="x-form-item-label">{label}{labelSeparator}</label>',
-        '<div class="x-form-element" id="x-form-el-{id}" style="{elementStyle}">',
-        '</div><div class="{clearCls}"></div>',
-    '</div>'
-);
-
-     * This may be specified to produce a different DOM structure when rendering form Fields.
-     * A description of the properties within the template follows:

-     * itemCls : StringThe CSS class applied to the outermost div wrapper
-     * that contains this field label and field element (the default class is 'x-form-item' and itemCls
-     * will be added to that). If supplied, itemCls at the field level will override the default itemCls
-     * supplied at the container level.
-     * id : StringThe id of the Field
-     * {@link #labelStyle} : String
-     * A CSS style specification string to add to the field label for this field (defaults to '' or the
-     * {@link #labelStyle layout's value for labelStyle}).
-     * label : StringThe text to display as the label for this
-     * field (defaults to '')
-     * {@link #labelSeparator} : StringThe separator to display after
-     * the text of the label for this field (defaults to a colon ':' or the
-     * {@link #labelSeparator layout's value for labelSeparator}). To hide the separator use empty string ''.
-     * elementStyle : StringThe styles text for the input element's wrapper.
-     * clearCls : StringThe CSS class to apply to the special clearing div
-     * rendered directly after each form field wrapper (defaults to 'x-form-clear-left')
-     * 
-     * Also see {@link #getTemplateArgs}
+     * Given an array of filter functions (each with optional scope), constructs and returns a single function that returns
+     * the result of all of the filters ANDed together
+     * @param {Array} filters The array of filter objects (each object should contain an 'fn' and optional scope)
+     * @return {Function} The multiple filter function
      */
+    createMultipleFilterFn: function(filters) {
+        return function(record) {
+            var isMatch = true;
 
-    // private
-    renderItem : function(c, position, target){
-        if(c && (c.isFormField || c.fieldLabel) && c.inputType != 'hidden'){
-            var args = this.getTemplateArgs(c);
-            if(Ext.isNumber(position)){
-                position = target.dom.childNodes[position] || null;
-            }
-            if(position){
-                c.itemCt = this.fieldTpl.insertBefore(position, args, true);
-            }else{
-                c.itemCt = this.fieldTpl.append(target, args, true);
-            }
-            if(!c.getItemCt){
-                // Non form fields don't have getItemCt, apply it here
-                // This will get cleaned up in onRemove
-                Ext.apply(c, {
-                    getItemCt: function(){
-                        return c.itemCt;
-                    },
-                    customItemCt: true
-                });
-            }
-            c.label = c.getItemCt().child('label.x-form-item-label');
-            if(!c.rendered){
-                c.render('x-form-el-' + c.id);
-            }else if(!this.isValidParent(c, target)){
-                Ext.fly('x-form-el-' + c.id).appendChild(c.getPositionEl());
+            for (var i=0, j = filters.length; i < j; i++) {
+                var filter = filters[i],
+                    fn     = filter.fn,
+                    scope  = filter.scope;
+
+                isMatch = isMatch && fn.call(scope, record);
             }
-            if(this.trackLabels){
-                if(c.hidden){
-                    this.onFieldHide(c);
+
+            return isMatch;
+        };
+    },
+
+    /**
+     * Filter the {@link Ext.data.Record records} by a specified property. Alternatively, pass an array of filter
+     * options to filter by more than one property.
+     * Single filter example:
+     * store.filter('name', 'Ed', true, true); //finds all records containing the substring 'Ed'
+     * Multiple filter example:
+     * store.filter([
+     *   {
+     *     property     : 'name',
+     *     value        : 'Ed',
+     *     anyMatch     : true, //optional, defaults to true
+     *     caseSensitive: true  //optional, defaults to true
+     *   },
+     *
+     *   //filter functions can also be passed
+     *   {
+     *     fn   : function(record) {
+     *       return record.get('age') == 24
+     *     },
+     *     scope: this
+     *   }
+     * ]);
+     * @param {String|Array} field A field on your records, or an array containing multiple filter options
+     * @param {String/RegExp} value Either a string that the field should begin with, or a RegExp to test
+     * against the field.
+     * @param {Boolean} anyMatch (optional) true to match any part not just the beginning
+     * @param {Boolean} caseSensitive (optional) true for case sensitive comparison
+     * @param {Boolean} exactMatch True to force exact match (^ and $ characters added to the regex). Defaults to false. Ignored if anyMatch is true.
+     */
+    filter : function(property, value, anyMatch, caseSensitive, exactMatch){
+        //we can accept an array of filter objects, or a single filter object - normalize them here
+        if (Ext.isObject(property)) {
+            property = [property];
+        }
+
+        if (Ext.isArray(property)) {
+            var filters = [];
+
+            //normalize the filters passed into an array of filter functions
+            for (var i=0, j = property.length; i < j; i++) {
+                var filter = property[i],
+                    func   = filter.fn,
+                    scope  = filter.scope || this;
+
+                //if we weren't given a filter function, construct one now
+                if (!Ext.isFunction(func)) {
+                    func = this.createFilterFn(filter.property, filter.value, filter.anyMatch, filter.caseSensitive, filter.exactMatch);
                 }
-                c.on({
-                    scope: this,
-                    show: this.onFieldShow,
-                    hide: this.onFieldHide
-                });
+
+                filters.push({fn: func, scope: scope});
             }
-            this.configureItem(c);
-        }else {
-            Ext.layout.FormLayout.superclass.renderItem.apply(this, arguments);
+
+            var fn = this.createMultipleFilterFn(filters);
+        } else {
+            //classic single property filter
+            var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
         }
+
+        return fn ? this.filterBy(fn) : this.clearFilter();
     },
 
     /**
-     * Provides template arguments for rendering the fully wrapped, labeled and styled form Field.
-     * This method returns an object hash containing properties used by the layout's {@link #fieldTpl}
-     * to create a correctly wrapped, labeled and styled form Field. This may be overriden to
-     * create custom layouts. The properties which must be returned are:

-     * itemCls : StringThe CSS class applied to the outermost div wrapper
-     * that contains this field label and field element (the default class is 'x-form-item' and itemCls
-     * will be added to that). If supplied, itemCls at the field level will override the default itemCls
-     * supplied at the container level.
-     * id : StringThe id of the Field
-     * {@link #labelStyle} : String
-     * A CSS style specification string to add to the field label for this field (defaults to '' or the
-     * {@link #labelStyle layout's value for labelStyle}).
-     * label : StringThe text to display as the label for this
-     * field (defaults to '')
-     * {@link #labelSeparator} : StringThe separator to display after
-     * the text of the label for this field (defaults to a colon ':' or the
-     * {@link #labelSeparator layout's value for labelSeparator}). To hide the separator use empty string ''.
-     * elementStyle : StringThe styles text for the input element's wrapper.
-     * clearCls : StringThe CSS class to apply to the special clearing div
-     * rendered directly after each form field wrapper (defaults to 'x-form-clear-left')
-     * 
-     * @param (Ext.form.Field} field The {@link Ext.form.Field Field} being rendered.
-     * @return An object hash containing the properties required to render the Field.
+     * Filter by a function. The specified function will be called for each
+     * Record in this Store. If the function returns true the Record is included,
+     * otherwise it is filtered out.
+     * @param {Function} fn The function to be called. It will be passed the following parameters:
+     * record : Ext.data.RecordThe {@link Ext.data.Record record}
+     * to test for filtering. Access field values using {@link Ext.data.Record#get}.
+     * id : ObjectThe ID of the Record passed.
+     * 
+     * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store.
      */
-    getTemplateArgs: function(field) {
-        var noLabelSep = !field.fieldLabel || field.hideLabel;
-        return {
-            id: field.id,
-            label: field.fieldLabel,
-            labelStyle: this.getLabelStyle(field.labelStyle),
-            elementStyle: this.elementStyle||'',
-            labelSeparator: noLabelSep ? '' : (Ext.isDefined(field.labelSeparator) ? field.labelSeparator : this.labelSeparator),
-            itemCls: (field.itemCls||this.container.itemCls||'') + (field.hideLabel ? ' x-hide-label' : ''),
-            clearCls: field.clearCls || 'x-form-clear-left'
-        };
-    },
-
-    // private
-    adjustWidthAnchor: function(value, c){
-        if(c.label && !this.isHide(c) && (this.container.labelAlign != 'top')){
-            var adjust = Ext.isIE6 || (Ext.isIE && !Ext.isStrict);
-            return value - this.labelAdjust + (adjust ? -3 : 0);
-        }
-        return value;
+    filterBy : function(fn, scope){
+        this.snapshot = this.snapshot || this.data;
+        this.data = this.queryBy(fn, scope||this);
+        this.fireEvent('datachanged', this);
     },
 
-    adjustHeightAnchor : function(value, c){
-        if(c.label && !this.isHide(c) && (this.container.labelAlign == 'top')){
-            return value - c.label.getHeight();
+    /**
+     * Revert to a view of the Record cache with no filtering applied.
+     * @param {Boolean} suppressEvent If true the filter is cleared silently without firing the
+     * {@link #datachanged} event.
+     */
+    clearFilter : function(suppressEvent){
+        if(this.isFiltered()){
+            this.data = this.snapshot;
+            delete this.snapshot;
+            if(suppressEvent !== true){
+                this.fireEvent('datachanged', this);
+            }
         }
-        return value;
     },
 
-    // private
-    isValidParent : function(c, target){
-        return target && this.container.getEl().contains(c.getPositionEl());
-    }
-
     /**
-     * @property activeItem
-     * @hide
+     * Returns true if this store is currently filtered
+     * @return {Boolean}
      */
-});
-
-Ext.Container.LAYOUTS['form'] = Ext.layout.FormLayout;
-/**
- * @class Ext.layout.AccordionLayout
- * @extends Ext.layout.FitLayout
- * This is a layout that manages multiple Panels in an expandable accordion style such that only
- * one Panel can be expanded at any given time. Each Panel has built-in support for expanding and collapsing.
- * Note: Only Ext.Panels and all subclasses of Ext.Panel may be used in an accordion layout Container.
- * This class is intended to be extended or created via the {@link Ext.Container#layout layout}
- * configuration property.  See {@link Ext.Container#layout} for additional details.
- * Example usage:
- * 
-var accordion = new Ext.Panel({
-    title: 'Accordion Layout',
-    layout:'accordion',
-    defaults: {
-        // applied to each contained panel
-        bodyStyle: 'padding:15px'
-    },
-    layoutConfig: {
-        // layout-specific configs go here
-        titleCollapse: false,
-        animate: true,
-        activeOnTop: true
-    },
-    items: [{
-        title: 'Panel 1',
-        html: '<p>Panel content!</p>'
-    },{
-        title: 'Panel 2',
-        html: '<p>Panel content!</p>'
-    },{
-        title: 'Panel 3',
-        html: '<p>Panel content!</p>'
-    }]
-});
-
- */
-Ext.layout.AccordionLayout = Ext.extend(Ext.layout.FitLayout, {
-    /**
-     * @cfg {Boolean} fill
-     * True to adjust the active item's height to fill the available space in the container, false to use the
-     * item's current height, or auto height if not explicitly set (defaults to true).
-     */
-    fill : true,
-    /**
-     * @cfg {Boolean} autoWidth
-     * True to set each contained item's width to 'auto', false to use the item's current width (defaults to true).
-     * Note that some components, in particular the {@link Ext.grid.GridPanel grid}, will not function properly within
-     * layouts if they have auto width, so in such cases this config should be set to false.
-     */
-    autoWidth : true,
-    /**
-     * @cfg {Boolean} titleCollapse
-     * True to allow expand/collapse of each contained panel by clicking anywhere on the title bar, false to allow
-     * expand/collapse only when the toggle tool button is clicked (defaults to true).  When set to false,
-     * {@link #hideCollapseTool} should be false also.
-     */
-    titleCollapse : true,
-    /**
-     * @cfg {Boolean} hideCollapseTool
-     * True to hide the contained panels' collapse/expand toggle buttons, false to display them (defaults to false).
-     * When set to true, {@link #titleCollapse} should be true also.
-     */
-    hideCollapseTool : false,
-    /**
-     * @cfg {Boolean} collapseFirst
-     * True to make sure the collapse/expand toggle button always renders first (to the left of) any other tools
-     * in the contained panels' title bars, false to render it last (defaults to false).
-     */
-    collapseFirst : false,
-    /**
-     * @cfg {Boolean} animate
-     * True to slide the contained panels open and closed during expand/collapse using animation, false to open and
-     * close directly with no animation (defaults to false).  Note: to defer to the specific config setting of each
-     * contained panel for this property, set this to undefined at the layout level.
-     */
-    animate : false,
-    /**
-     * @cfg {Boolean} sequence
-     * Experimental. If animate is set to true, this will result in each animation running in sequence.
-     */
-    sequence : false,
-    /**
-     * @cfg {Boolean} activeOnTop
-     * True to swap the position of each panel as it is expanded so that it becomes the first item in the container,
-     * false to keep the panels in the rendered order. This is NOT compatible with "animate:true" (defaults to false).
-     */
-    activeOnTop : false,
-
-    type: 'accordion',
-
-    renderItem : function(c){
-        if(this.animate === false){
-            c.animCollapse = false;
-        }
-        c.collapsible = true;
-        if(this.autoWidth){
-            c.autoWidth = true;
-        }
-        if(this.titleCollapse){
-            c.titleCollapse = true;
-        }
-        if(this.hideCollapseTool){
-            c.hideCollapseTool = true;
-        }
-        if(this.collapseFirst !== undefined){
-            c.collapseFirst = this.collapseFirst;
-        }
-        if(!this.activeItem && !c.collapsed){
-            this.setActiveItem(c, true);
-        }else if(this.activeItem && this.activeItem != c){
-            c.collapsed = true;
-        }
-        Ext.layout.AccordionLayout.superclass.renderItem.apply(this, arguments);
-        c.header.addClass('x-accordion-hd');
-        c.on('beforeexpand', this.beforeExpand, this);
-    },
-
-    onRemove: function(c){
-        Ext.layout.AccordionLayout.superclass.onRemove.call(this, c);
-        if(c.rendered){
-            c.header.removeClass('x-accordion-hd');
-        }
-        c.un('beforeexpand', this.beforeExpand, this);
-    },
-
-    // private
-    beforeExpand : function(p, anim){
-        var ai = this.activeItem;
-        if(ai){
-            if(this.sequence){
-                delete this.activeItem;
-                if (!ai.collapsed){
-                    ai.collapse({callback:function(){
-                        p.expand(anim || true);
-                    }, scope: this});
-                    return false;
-                }
-            }else{
-                ai.collapse(this.animate);
-            }
-        }
-        this.setActive(p);
-        if(this.activeOnTop){
-            p.el.dom.parentNode.insertBefore(p.el.dom, p.el.dom.parentNode.firstChild);
-        }
-        // Items have been hidden an possibly rearranged, we need to get the container size again.
-        this.layout();
-    },
-
-    // private
-    setItemSize : function(item, size){
-        if(this.fill && item){
-            var hh = 0, i, ct = this.getRenderedItems(this.container), len = ct.length, p;
-            // Add up all the header heights
-            for (i = 0; i < len; i++) {
-                if((p = ct[i]) != item){
-                    hh += p.header.getHeight();
-                }
-            };
-            // Subtract the header heights from the container size
-            size.height -= hh;
-            // Call setSize on the container to set the correct height.  For Panels, deferedHeight
-            // will simply store this size for when the expansion is done.
-            item.setSize(size);
-        }
-    },
-
-    /**
-     * Sets the active (expanded) item in the layout.
-     * @param {String/Number} item The string component id or numeric index of the item to activate
-     */
-    setActiveItem : function(item){
-        this.setActive(item, true);
-    },
-
-    // private
-    setActive : function(item, expand){
-        var ai = this.activeItem;
-        item = this.container.getComponent(item);
-        if(ai != item){
-            if(item.rendered && item.collapsed && expand){
-                item.expand();
-            }else{
-                if(ai){
-                   ai.fireEvent('deactivate', ai);
-                }
-                this.activeItem = item;
-                item.fireEvent('activate', item);
-            }
-        }
-    }
-});
-Ext.Container.LAYOUTS.accordion = Ext.layout.AccordionLayout;
-
-//backwards compat
-Ext.layout.Accordion = Ext.layout.AccordionLayout;/**
- * @class Ext.layout.TableLayout
- * @extends Ext.layout.ContainerLayout
- * This layout allows you to easily render content into an HTML table.  The total number of columns can be
- * specified, and rowspan and colspan can be used to create complex layouts within the table.
- * This class is intended to be extended or created via the layout:'table' {@link Ext.Container#layout} config,
- * and should generally not need to be created directly via the new keyword.
- * Note that when creating a layout via config, the layout-specific config properties must be passed in via
- * the {@link Ext.Container#layoutConfig} object which will then be applied internally to the layout.  In the
- * case of TableLayout, the only valid layout config property is {@link #columns}.  However, the items added to a
- * TableLayout can supply the following table-specific config properties:
- * 
- * rowspan Applied to the table cell containing the item.
- * colspan Applied to the table cell containing the item.
- * cellId An id applied to the table cell containing the item.
- * cellCls A CSS class name added to the table cell containing the item.
- * 
- * The basic concept of building up a TableLayout is conceptually very similar to building up a standard
- * HTML table.  You simply add each panel (or "cell") that you want to include along with any span attributes
- * specified as the special config properties of rowspan and colspan which work exactly like their HTML counterparts.
- * Rather than explicitly creating and nesting rows and columns as you would in HTML, you simply specify the
- * total column count in the layoutConfig and start adding panels in their natural order from left to right,
- * top to bottom.  The layout will automatically figure out, based on the column count, rowspans and colspans,
- * how to position each panel within the table.  Just like with HTML tables, your rowspans and colspans must add
- * up correctly in your overall layout or you'll end up with missing and/or extra cells!  Example usage:
- * 
-// This code will generate a layout table that is 3 columns by 2 rows
-// with some spanning included.  The basic layout will be:
-// +--------+-----------------+
-// |   A    |   B             |
-// |        |--------+--------|
-// |        |   C    |   D    |
-// +--------+--------+--------+
-var table = new Ext.Panel({
-    title: 'Table Layout',
-    layout:'table',
-    defaults: {
-        // applied to each contained panel
-        bodyStyle:'padding:20px'
-    },
-    layoutConfig: {
-        // The total column count must be specified here
-        columns: 3
-    },
-    items: [{
-        html: '<p>Cell A content</p>',
-        rowspan: 2
-    },{
-        html: '<p>Cell B content</p>',
-        colspan: 2
-    },{
-        html: '<p>Cell C content</p>',
-        cellCls: 'highlight'
-    },{
-        html: '<p>Cell D content</p>'
-    }]
-});
-
- */
-Ext.layout.TableLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    /**
-     * @cfg {Number} columns
-     * The total number of columns to create in the table for this layout.  If not specified, all Components added to
-     * this layout will be rendered into a single row using one column per Component.
-     */
-
-    // private
-    monitorResize:false,
-
-    type: 'table',
-
-    targetCls: 'x-table-layout-ct',
-
-    /**
-     * @cfg {Object} tableAttrs
-     * An object containing properties which are added to the {@link Ext.DomHelper DomHelper} specification
-     * used to create the layout's <table> element. Example:

-{
-    xtype: 'panel',
-    layout: 'table',
-    layoutConfig: {
-        tableAttrs: {
-            style: {
-                width: '100%'
-            }
-        },
-        columns: 3
-    }
-}
-     */
-    tableAttrs:null,
-
-    // private
-    setContainer : function(ct){
-        Ext.layout.TableLayout.superclass.setContainer.call(this, ct);
-
-        this.currentRow = 0;
-        this.currentColumn = 0;
-        this.cells = [];
-    },
-    
-    // private
-    onLayout : function(ct, target){
-        var cs = ct.items.items, len = cs.length, c, i;
-
-        if(!this.table){
-            target.addClass('x-table-layout-ct');
-
-            this.table = target.createChild(
-                Ext.apply({tag:'table', cls:'x-table-layout', cellspacing: 0, cn: {tag: 'tbody'}}, this.tableAttrs), null, true);
-        }
-        this.renderAll(ct, target);
-    },
-
-    // private
-    getRow : function(index){
-        var row = this.table.tBodies[0].childNodes[index];
-        if(!row){
-            row = document.createElement('tr');
-            this.table.tBodies[0].appendChild(row);
-        }
-        return row;
-    },
-
-    // private
-    getNextCell : function(c){
-        var cell = this.getNextNonSpan(this.currentColumn, this.currentRow);
-        var curCol = this.currentColumn = cell[0], curRow = this.currentRow = cell[1];
-        for(var rowIndex = curRow; rowIndex < curRow + (c.rowspan || 1); rowIndex++){
-            if(!this.cells[rowIndex]){
-                this.cells[rowIndex] = [];
-            }
-            for(var colIndex = curCol; colIndex < curCol + (c.colspan || 1); colIndex++){
-                this.cells[rowIndex][colIndex] = true;
-            }
-        }
-        var td = document.createElement('td');
-        if(c.cellId){
-            td.id = c.cellId;
-        }
-        var cls = 'x-table-layout-cell';
-        if(c.cellCls){
-            cls += ' ' + c.cellCls;
-        }
-        td.className = cls;
-        if(c.colspan){
-            td.colSpan = c.colspan;
-        }
-        if(c.rowspan){
-            td.rowSpan = c.rowspan;
-        }
-        this.getRow(curRow).appendChild(td);
-        return td;
-    },
-
-    // private
-    getNextNonSpan: function(colIndex, rowIndex){
-        var cols = this.columns;
-        while((cols && colIndex >= cols) || (this.cells[rowIndex] && this.cells[rowIndex][colIndex])) {
-            if(cols && colIndex >= cols){
-                rowIndex++;
-                colIndex = 0;
-            }else{
-                colIndex++;
-            }
-        }
-        return [colIndex, rowIndex];
-    },
-
-    // private
-    renderItem : function(c, position, target){
-        // Ensure we have our inner table to get cells to render into.
-        if(!this.table){
-            this.table = target.createChild(
-                Ext.apply({tag:'table', cls:'x-table-layout', cellspacing: 0, cn: {tag: 'tbody'}}, this.tableAttrs), null, true);
-        }
-        if(c && !c.rendered){
-            c.render(this.getNextCell(c));
-            this.configureItem(c, position);
-        }else if(c && !this.isValidParent(c, target)){
-            var container = this.getNextCell(c);
-            container.insertBefore(c.getPositionEl().dom, null);
-            c.container = Ext.get(container);
-            this.configureItem(c, position);
-        }
-    },
-
-    // private
-    isValidParent : function(c, target){
-        return c.getPositionEl().up('table', 5).dom.parentNode === (target.dom || target);
-    }
-
-    /**
-     * @property activeItem
-     * @hide
-     */
-});
-
-Ext.Container.LAYOUTS['table'] = Ext.layout.TableLayout;/**
- * @class Ext.layout.AbsoluteLayout
- * @extends Ext.layout.AnchorLayout
- * This is a layout that inherits the anchoring of {@link Ext.layout.AnchorLayout} and adds the
- * ability for x/y positioning using the standard x and y component config options.
- * This class is intended to be extended or created via the {@link Ext.Container#layout layout}
- * configuration property.  See {@link Ext.Container#layout} for additional details.
- * Example usage:
- * 
-var form = new Ext.form.FormPanel({
-    title: 'Absolute Layout',
-    layout:'absolute',
-    layoutConfig: {
-        // layout-specific configs go here
-        extraCls: 'x-abs-layout-item',
+    isFiltered : function(){
+        return !!this.snapshot && this.snapshot != this.data;
     },
-    baseCls: 'x-plain',
-    url:'save-form.php',
-    defaultType: 'textfield',
-    items: [{
-        x: 0,
-        y: 5,
-        xtype:'label',
-        text: 'Send To:'
-    },{
-        x: 60,
-        y: 0,
-        name: 'to',
-        anchor:'100%'  // anchor width by percentage
-    },{
-        x: 0,
-        y: 35,
-        xtype:'label',
-        text: 'Subject:'
-    },{
-        x: 60,
-        y: 30,
-        name: 'subject',
-        anchor: '100%'  // anchor width by percentage
-    },{
-        x:0,
-        y: 60,
-        xtype: 'textarea',
-        name: 'msg',
-        anchor: '100% 100%'  // anchor width and height
-    }]
-});
-
- */
-Ext.layout.AbsoluteLayout = Ext.extend(Ext.layout.AnchorLayout, {
-
-    extraCls: 'x-abs-layout-item',
 
-    type: 'anchor',
-
-    onLayout : function(ct, target){
-        target.position();
-        this.paddingLeft = target.getPadding('l');
-        this.paddingTop = target.getPadding('t');
-        Ext.layout.AbsoluteLayout.superclass.onLayout.call(this, ct, target);
+    /**
+     * Query the records by a specified property.
+     * @param {String} field A field on your records
+     * @param {String/RegExp} value Either a string that the field
+     * should begin with, or a RegExp to test against the field.
+     * @param {Boolean} anyMatch (optional) True to match any part not just the beginning
+     * @param {Boolean} caseSensitive (optional) True for case sensitive comparison
+     * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records
+     */
+    query : function(property, value, anyMatch, caseSensitive){
+        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
+        return fn ? this.queryBy(fn) : this.data.clone();
     },
 
-    // private
-    adjustWidthAnchor : function(value, comp){
-        return value ? value - comp.getPosition(true)[0] + this.paddingLeft : value;
+    /**
+     * Query the cached records in this Store using a filtering function. The specified function
+     * will be called with each record in this Store. If the function returns true the record is
+     * included in the results.
+     * @param {Function} fn The function to be called. It will be passed the following parameters:
+     * record : Ext.data.RecordThe {@link Ext.data.Record record}
+     * to test for filtering. Access field values using {@link Ext.data.Record#get}.
+     * id : ObjectThe ID of the Record passed.
+     * 
+     * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store.
+     * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records
+     **/
+    queryBy : function(fn, scope){
+        var data = this.snapshot || this.data;
+        return data.filterBy(fn, scope||this);
     },
 
-    // private
-    adjustHeightAnchor : function(value, comp){
-        return  value ? value - comp.getPosition(true)[1] + this.paddingTop : value;
-    }
     /**
-     * @property activeItem
-     * @hide
+     * Finds the index of the first matching Record in this store by a specific field value.
+     * @param {String} fieldName The name of the Record field to test.
+     * @param {String/RegExp} value Either a string that the field value
+     * should begin with, or a RegExp to test against the field.
+     * @param {Number} startIndex (optional) The index to start searching at
+     * @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
      */
-});
-Ext.Container.LAYOUTS['absolute'] = Ext.layout.AbsoluteLayout;
-/**
- * @class Ext.layout.BoxLayout
- * @extends Ext.layout.ContainerLayout
- * Base Class for HBoxLayout and VBoxLayout Classes. Generally it should not need to be used directly.
- */
-Ext.layout.BoxLayout = Ext.extend(Ext.layout.ContainerLayout, {
+    find : function(property, value, start, anyMatch, caseSensitive){
+        var fn = this.createFilterFn(property, value, anyMatch, caseSensitive);
+        return fn ? this.data.findIndexBy(fn, null, start) : -1;
+    },
+
     /**
-     * @cfg {Object} defaultMargins
-     * If the individual contained items do not have a margins
-     * property specified, the default margins from this property will be
-     * applied to each item.
-     * 
This property may be specified as an object containing margins
-     * to apply in the format:

-{
-    top: (top margin),
-    right: (right margin),
-    bottom: (bottom margin),
-    left: (left margin)
-}
-     * This property may also be specified as a string containing
-     * space-separated, numeric margin values. The order of the sides associated
-     * with each value matches the way CSS processes margin values:
-     * 
-     * If there is only one value, it applies to all sides.
-     * If there are two values, the top and bottom borders are set to the
-     * first value and the right and left are set to the second.
-     * If there are three values, the top is set to the first value, the left
-     * and right are set to the second, and the bottom is set to the third.
-     * If there are four values, they apply to the top, right, bottom, and
-     * left, respectively.
-     * 
-     * Defaults to:

-     * {top:0, right:0, bottom:0, left:0}
-     * 
+     * Finds the index of the first matching Record in this store by a specific field value.
+     * @param {String} fieldName The name of the Record field to test.
+     * @param {Mixed} value The value to match the field against.
+     * @param {Number} startIndex (optional) The index to start searching at
+     * @return {Number} The matched index or -1
      */
-    defaultMargins : {left:0,top:0,right:0,bottom:0},
+    findExact: function(property, value, start){
+        return this.data.findIndexBy(function(rec){
+            return rec.get(property) === value;
+        }, this, start);
+    },
+
     /**
-     * @cfg {String} padding
-     * Sets the padding to be applied to all child items managed by this layout.
-     * This property must be specified as a string containing
-     * space-separated, numeric padding values. The order of the sides associated
-     * with each value matches the way CSS processes padding values:
-     * 
-     * If there is only one value, it applies to all sides.
-     * If there are two values, the top and bottom borders are set to the
-     * first value and the right and left are set to the second.
-     * If there are three values, the top is set to the first value, the left
-     * and right are set to the second, and the bottom is set to the third.
-     * If there are four values, they apply to the top, right, bottom, and
-     * left, respectively.
-     * 
-     * Defaults to: "0"
+     * Find the index of the first matching Record in this Store by a function.
+     * If the function returns true it is considered a match.
+     * @param {Function} fn The function to be called. It will be passed the following parameters:
+     * record : Ext.data.RecordThe {@link Ext.data.Record record}
+     * to test for filtering. Access field values using {@link Ext.data.Record#get}.
+     * id : ObjectThe ID of the Record passed.
+     * 
+     * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store.
+     * @param {Number} startIndex (optional) The index to start searching at
+     * @return {Number} The matched index or -1
      */
-    padding : '0',
-    // documented in subclasses
-    pack : 'start',
-
-    // private
-    monitorResize : true,
-    type: 'box',
-    scrollOffset : 0,
-    extraCls : 'x-box-item',
-    targetCls : 'x-box-layout-ct',
-    innerCls : 'x-box-inner',
-
-    constructor : function(config){
-        Ext.layout.BoxLayout.superclass.constructor.call(this, config);
-        if(Ext.isString(this.defaultMargins)){
-            this.defaultMargins = this.parseMargins(this.defaultMargins);
-        }
+    findBy : function(fn, scope, start){
+        return this.data.findIndexBy(fn, scope, start);
     },
 
-    // private
-    isValidParent : function(c, target){
-        return this.innerCt && c.getPositionEl().dom.parentNode == this.innerCt.dom;
+    /**
+     * Collects unique values for a particular dataIndex from this store.
+     * @param {String} dataIndex The property to collect
+     * @param {Boolean} allowNull (optional) Pass true to allow null, undefined or empty string values
+     * @param {Boolean} bypassFilter (optional) Pass true to collect from all records, even ones which are filtered
+     * @return {Array} An array of the unique values
+     **/
+    collect : function(dataIndex, allowNull, bypassFilter){
+        var d = (bypassFilter === true && this.snapshot) ?
+                this.snapshot.items : this.data.items;
+        var v, sv, r = [], l = {};
+        for(var i = 0, len = d.length; i < len; i++){
+            v = d[i].data[dataIndex];
+            sv = String(v);
+            if((allowNull || !Ext.isEmpty(v)) && !l[sv]){
+                l[sv] = true;
+                r[r.length] = v;
+            }
+        }
+        return r;
     },
 
     // private
-    renderAll : function(ct, target){
-        if(!this.innerCt){
-            // the innerCt prevents wrapping and shuffling while
-            // the container is resizing
-            this.innerCt = target.createChild({cls:this.innerCls});
-            this.padding = this.parseMargins(this.padding);
+    afterEdit : function(record){
+        if(this.modified.indexOf(record) == -1){
+            this.modified.push(record);
         }
-        Ext.layout.BoxLayout.superclass.renderAll.call(this, ct, this.innerCt);
-    },
-
-    onLayout : function(ct, target){
-        this.renderAll(ct, target);
+        this.fireEvent('update', this, record, Ext.data.Record.EDIT);
     },
 
-    getLayoutTargetSize : function(){
-        var target = this.container.getLayoutTarget(), ret;
-        if (target) {
-            ret = target.getViewSize();
-            ret.width -= target.getPadding('lr');
-            ret.height -= target.getPadding('tb');
-        }
-        return ret;
+    // private
+    afterReject : function(record){
+        this.modified.remove(record);
+        this.fireEvent('update', this, record, Ext.data.Record.REJECT);
     },
 
     // private
-    renderItem : function(c){
-        if(Ext.isString(c.margins)){
-            c.margins = this.parseMargins(c.margins);
-        }else if(!c.margins){
-            c.margins = this.defaultMargins;
-        }
-        Ext.layout.BoxLayout.superclass.renderItem.apply(this, arguments);
-    }
-});
+    afterCommit : function(record){
+        this.modified.remove(record);
+        this.fireEvent('update', this, record, Ext.data.Record.COMMIT);
+    },
 
-/**
- * @class Ext.layout.VBoxLayout
- * @extends Ext.layout.BoxLayout
- * A layout that arranges items vertically down a Container. This layout optionally divides available vertical
- * space between child items containing a numeric flex configuration.
- * This layout may also be used to set the widths of child items by configuring it with the {@link #align} option.
- */
-Ext.layout.VBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
-    /**
-     * @cfg {String} align
-     * Controls how the child items of the container are aligned. Acceptable configuration values for this
-     * property are:
-     * 
-     * left : Defaultchild items are aligned horizontally
-     * at the left side of the container
-     * center : child items are aligned horizontally at the
-     * mid-width of the container
-     * stretch : child items are stretched horizontally to fill
-     * the width of the container
-     * stretchmax : child items are stretched horizontally to
-     * the size of the largest item.
-     * 
-     */
-    align : 'left', // left, center, stretch, strechmax
-    type: 'vbox',
     /**
-     * @cfg {String} pack
-     * Controls how the child items of the container are packed together. Acceptable configuration values
-     * for this property are:
-     * 
-     * start : Defaultchild items are packed together at
-     * top side of container
-     * center : child items are packed together at
-     * mid-height of container
-     * end : child items are packed together at bottom
-     * side of container
-     * 
+     * Commit all Records with {@link #getModifiedRecords outstanding changes}. To handle updates for changes,
+     * subscribe to the Store's {@link #update update event}, and perform updating when the third parameter is
+     * Ext.data.Record.COMMIT.
      */
+    commitChanges : function(){
+        var m = this.modified.slice(0);
+        this.modified = [];
+        for(var i = 0, len = m.length; i < len; i++){
+            m[i].commit();
+        }
+    },
+
     /**
-     * @cfg {Number} flex
-     * This configuation option is to be applied to child items of the container managed
-     * by this layout. Each child item with a flex property will be flexed vertically
-     * according to each item's relative flex value compared to the sum of all items with
-     * a flex value specified.  Any child items that have either a flex = 0 or
-     * flex = undefined will not be 'flexed' (the initial size will not be changed).
+     * {@link Ext.data.Record#reject Reject} outstanding changes on all {@link #getModifiedRecords modified records}.
      */
-
-    // private
-    onLayout : function(ct, target){
-        Ext.layout.VBoxLayout.superclass.onLayout.call(this, ct, target);
-
-        var cs = this.getRenderedItems(ct), csLen = cs.length,
-            c, i, cm, ch, margin, cl, diff, aw, availHeight,
-            size = this.getLayoutTargetSize(),
-            w = size.width,
-            h = size.height - this.scrollOffset,
-            l = this.padding.left,
-            t = this.padding.top,
-            isStart = this.pack == 'start',
-            extraHeight = 0,
-            maxWidth = 0,
-            totalFlex = 0,
-            usedHeight = 0,
-            idx = 0,
-            heights = [],
-            restore = [];
-
-        // Do only width calculations and apply those first, as they can affect height
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            cm = c.margins;
-            margin = cm.top + cm.bottom;
-            // Max height for align
-            maxWidth = Math.max(maxWidth, c.getWidth() + cm.left + cm.right);
+    rejectChanges : function(){
+        var m = this.modified.slice(0);
+        this.modified = [];
+        for(var i = 0, len = m.length; i < len; i++){
+            m[i].reject();
         }
-
-        var innerCtWidth = maxWidth + this.padding.left + this.padding.right;
-        switch(this.align){
-            case 'stretch':
-                this.innerCt.setSize(w, h);
-                break;
-            case 'stretchmax':
-            case 'left':
-                this.innerCt.setSize(innerCtWidth, h);
-                break;
-            case 'center':
-                this.innerCt.setSize(w = Math.max(w, innerCtWidth), h);
-                break;
+        var m = this.removed.slice(0).reverse();
+        this.removed = [];
+        for(var i = 0, len = m.length; i < len; i++){
+            this.insert(m[i].lastIndex||0, m[i]);
+            m[i].reject();
         }
+    },
 
-        var availableWidth = Math.max(0, w - this.padding.left - this.padding.right);
-        // Apply widths
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            cm = c.margins;
-            if(this.align == 'stretch'){
-                c.setWidth(((w - (this.padding.left + this.padding.right)) - (cm.left + cm.right)).constrain(
-                    c.minWidth || 0, c.maxWidth || 1000000));
-            }else if(this.align == 'stretchmax'){
-                c.setWidth((maxWidth - (cm.left + cm.right)).constrain(
-                    c.minWidth || 0, c.maxWidth || 1000000));
-            }else if(isStart && c.flex){
-                c.setWidth();
-            }
-
+    // private
+    onMetaChange : function(meta){
+        this.recordType = this.reader.recordType;
+        this.fields = this.recordType.prototype.fields;
+        delete this.snapshot;
+        if(this.reader.meta.sortInfo){
+            this.sortInfo = this.reader.meta.sortInfo;
+        }else if(this.sortInfo  && !this.fields.get(this.sortInfo.field)){
+            delete this.sortInfo;
         }
-
-        // Height calculations
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            // Total of all the flex values
-            totalFlex += c.flex || 0;
-            // Don't run height calculations on flexed items
-            if (!c.flex) {
-                // Render and layout sub-containers without a flex or height, once
-                if (!c.height && !c.hasLayout && c.doLayout) {
-                    c.doLayout();
-                }
-                ch = c.getHeight();
-            } else {
-                ch = 0;
-            }
-
-            cm = c.margins;
-            // Determine how much height is available to flex
-            extraHeight += ch + cm.top + cm.bottom;
+        if(this.writer){
+            this.writer.meta = this.reader.meta;
         }
-        // Final avail height calc
-        availHeight = Math.max(0, (h - extraHeight - this.padding.top - this.padding.bottom));
+        this.modified = [];
+        this.fireEvent('metachange', this, this.reader.meta);
+    },
 
-        var leftOver = availHeight;
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            if(isStart && c.flex){
-                ch = Math.floor(availHeight * (c.flex / totalFlex));
-                leftOver -= ch;
-                heights.push(ch);
-            }
-        }
-        if(this.pack == 'center'){
-            t += availHeight ? availHeight / 2 : 0;
-        }else if(this.pack == 'end'){
-            t += availHeight;
-        }
-        idx = 0;
-        // Apply heights
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            cm = c.margins;
-            t += cm.top;
-            aw = availableWidth;
-            cl = l + cm.left // default left pos
-
-            // Adjust left pos for centering
-            if(this.align == 'center'){
-                if((diff = availableWidth - (c.getWidth() + cm.left + cm.right)) > 0){
-                    cl += (diff/2);
-                    aw -= diff;
-                }
-            }
+    // private
+    findInsertIndex : function(record){
+        this.suspendEvents();
+        var data = this.data.clone();
+        this.data.add(record);
+        this.applySort();
+        var index = this.data.indexOf(record);
+        this.data = data;
+        this.resumeEvents();
+        return index;
+    },
 
-            c.setPosition(cl, t);
-            if(isStart && c.flex){
-                ch = Math.max(0, heights[idx++] + (leftOver-- > 0 ? 1 : 0));
-                c.setSize(aw, ch);
-            }else{
-                ch = c.getHeight();
-            }
-            t += ch + cm.bottom;
-        }
-        // Putting a box layout into an overflowed container is NOT correct and will make a second layout pass necessary.
-        if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
-            var ts = this.getLayoutTargetSize();
-            if (ts.width != size.width || ts.height != size.height){
-                this.adjustmentPass = true;
-                this.onLayout(ct, target);
-            }
-        }
-        delete this.adjustmentPass;
+    /**
+     * Set the value for a property name in this store's {@link #baseParams}.  Usage:

+myStore.setBaseParam('foo', {bar:3});
+
+     * @param {String} name Name of the property to assign
+     * @param {Mixed} value Value to assign the named property
+     **/
+    setBaseParam : function (name, value){
+        this.baseParams = this.baseParams || {};
+        this.baseParams[name] = value;
     }
 });
 
-Ext.Container.LAYOUTS.vbox = Ext.layout.VBoxLayout;
+Ext.reg('store', Ext.data.Store);
 
 /**
- * @class Ext.layout.HBoxLayout
- * @extends Ext.layout.BoxLayout
- * A layout that arranges items horizontally across a Container. This layout optionally divides available horizontal
- * space between child items containing a numeric flex configuration.
- * This layout may also be used to set the heights of child items by configuring it with the {@link #align} option.
+ * @class Ext.data.Store.Error
+ * @extends Ext.Error
+ * Store Error extension.
+ * @param {String} name
  */
-Ext.layout.HBoxLayout = Ext.extend(Ext.layout.BoxLayout, {
-    /**
-     * @cfg {String} align
-     * Controls how the child items of the container are aligned. Acceptable configuration values for this
-     * property are:
-     *


-     * top : Defaultchild items are aligned vertically
-     * at the top of the container
-     * middle : child items are aligned vertically in the
-     * middle of the container
-     * stretch : child items are stretched vertically to fill
-     * the height of the container
-     * stretchmax : child items are stretched vertically to
-     * the height of the largest item.
-     */
-    align : 'top', // top, middle, stretch, strechmax
-    type: 'hbox',
-    /**
-     * @cfg {String} pack
-     * Controls how the child items of the container are packed together. Acceptable configuration values
-     * for this property are:
-     * 
-     * start : Defaultchild items are packed together at
-     * left side of container
-     * center : child items are packed together at
-     * mid-width of container
-     * end : child items are packed together at right
-     * side of container
-     * 
-     */
-    /**
-     * @cfg {Number} flex
-     * This configuation option is to be applied to child items of the container managed
-     * by this layout. Each child item with a flex property will be flexed horizontally
-     * according to each item's relative flex value compared to the sum of all items with
-     * a flex value specified.  Any child items that have either a flex = 0 or
-     * flex = undefined will not be 'flexed' (the initial size will not be changed).
-     */
-
-    // private
-    onLayout : function(ct, target){
-        Ext.layout.HBoxLayout.superclass.onLayout.call(this, ct, target);
-
-        var cs = this.getRenderedItems(ct), csLen = cs.length,
-            c, i, cm, cw, ch, diff, availWidth,
-            size = this.getLayoutTargetSize(),
-            w = size.width - this.scrollOffset,
-            h = size.height,
-            l = this.padding.left,
-            t = this.padding.top,
-            isStart = this.pack == 'start',
-            isRestore = ['stretch', 'stretchmax'].indexOf(this.align) == -1,
-            extraWidth = 0,
-            maxHeight = 0,
-            totalFlex = 0,
-            usedWidth = 0;
-
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            // Total of all the flex values
-            totalFlex += c.flex || 0;
-            // Don't run width calculations on flexed items
-            if (!c.flex) {
-                // Render and layout sub-containers without a flex or width, once
-                if (!c.width && !c.hasLayout && c.doLayout) {
-                    c.doLayout();
-                }
-                cw = c.getWidth();
-            } else {
-                cw = 0;
-            }
-            cm = c.margins;
-            // Determine how much width is available to flex
-            extraWidth += cw + cm.left + cm.right;
-            // Max height for align
-            maxHeight = Math.max(maxHeight, c.getHeight() + cm.top + cm.bottom);
-        }
-        // Final avail width calc
-        availWidth = Math.max(0, (w - extraWidth - this.padding.left - this.padding.right));
-
-        var innerCtHeight = maxHeight + this.padding.top + this.padding.bottom;
-        switch(this.align){
-            case 'stretch':
-                this.innerCt.setSize(w, h);
-                break;
-            case 'stretchmax':
-            case 'top':
-                this.innerCt.setSize(w, innerCtHeight);
-                break;
-            case 'middle':
-                this.innerCt.setSize(w, h = Math.max(h, innerCtHeight));
-                break;
-        }
-
-        var leftOver = availWidth,
-            widths = [],
-            restore = [],
-            idx = 0,
-            availableHeight = Math.max(0, h - this.padding.top - this.padding.bottom);
-
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            if(isStart && c.flex){
-                cw = Math.floor(availWidth * (c.flex / totalFlex));
-                leftOver -= cw;
-                widths.push(cw);
-            }
-        }
-
-        if(this.pack == 'center'){
-            l += availWidth ? availWidth / 2 : 0;
-        }else if(this.pack == 'end'){
-            l += availWidth;
-        }
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            cm = c.margins;
-            l += cm.left;
-            c.setPosition(l, t + cm.top);
-            if(isStart && c.flex){
-                cw = Math.max(0, widths[idx++] + (leftOver-- > 0 ? 1 : 0));
-                if(isRestore){
-                    restore.push(c.getHeight());
-                }
-                c.setSize(cw, availableHeight);
-            }else{
-                cw = c.getWidth();
-            }
-            l += cw + cm.right;
-        }
-
-        idx = 0;
-        for (i = 0 ; i < csLen; i++) {
-            c = cs[i];
-            cm = c.margins;
-            ch = c.getHeight();
-            if(isStart && c.flex){
-                ch = restore[idx++];
-            }
-            if(this.align == 'stretch'){
-                c.setHeight(((h - (this.padding.top + this.padding.bottom)) - (cm.top + cm.bottom)).constrain(
-                    c.minHeight || 0, c.maxHeight || 1000000));
-            }else if(this.align == 'stretchmax'){
-                c.setHeight((maxHeight - (cm.top + cm.bottom)).constrain(
-                    c.minHeight || 0, c.maxHeight || 1000000));
-            }else{
-                if(this.align == 'middle'){
-                    diff = availableHeight - (ch + cm.top + cm.bottom);
-                    ch = t + cm.top + (diff/2);
-                    if(diff > 0){
-                        c.setPosition(c.x, ch);
-                    }
-                }
-                if(isStart && c.flex){
-                    c.setHeight(ch);
-                }
-            }
-        }
-        // Putting a box layout into an overflowed container is NOT correct and will make a second layout pass necessary.
-        if (i = target.getStyle('overflow') && i != 'hidden' && !this.adjustmentPass) {
-            var ts = this.getLayoutTargetSize();
-            if (ts.width != size.width || ts.height != size.height){
-                this.adjustmentPass = true;
-                this.onLayout(ct, target);
-            }
-        }
-        delete this.adjustmentPass;
+Ext.data.Store.Error = Ext.extend(Ext.Error, {
+    name: 'Ext.data.Store'
+});
+Ext.apply(Ext.data.Store.Error.prototype, {
+    lang: {
+        'writer-undefined' : 'Attempted to execute a write-action without a DataWriter installed.'
     }
 });
-
-Ext.Container.LAYOUTS.hbox = Ext.layout.HBoxLayout;
 /**
- * @class Ext.layout.ToolbarLayout
- * @extends Ext.layout.ContainerLayout
- * Layout manager implicitly used by Ext.Toolbar.
+ * @class Ext.data.Field
+ * This class encapsulates the field definition information specified in the field definition objects
+ * passed to {@link Ext.data.Record#create}.
+ * Developers do not need to instantiate this class. Instances are created by {@link Ext.data.Record.create}
+ * and cached in the {@link Ext.data.Record#fields fields} property of the created Record constructor's prototype.
  */
-Ext.layout.ToolbarLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    monitorResize : true,
-    triggerWidth : 18,
-    lastOverflow : false,
-
-    noItemsMenuText : '(None)',
-
-    // private
-    onLayout : function(ct, target){
-        if(!this.leftTr){
-            var align = ct.buttonAlign == 'center' ? 'center' : 'left';
-            target.addClass('x-toolbar-layout-ct');
-            target.insertHtml('beforeEnd',
-                 ' ');
-            this.leftTr = target.child('tr.x-toolbar-left-row', true);
-            this.rightTr = target.child('tr.x-toolbar-right-row', true);
-            this.extrasTr = target.child('tr.x-toolbar-extras-row', true);
+Ext.data.Field = Ext.extend(Object, {
+    
+    constructor : function(config){
+        if(Ext.isString(config)){
+            config = {name: config};
         }
+        Ext.apply(this, config);
+        
+        var types = Ext.data.Types,
+            st = this.sortType,
+            t;
 
-        var side = ct.buttonAlign == 'right' ? this.rightTr : this.leftTr,
-            pos = 0,
-            items = ct.items.items;
-
-        for(var i = 0, len = items.length, c; i < len; i++, pos++) {
-            c = items[i];
-            if(c.isFill){
-                side = this.rightTr;
-                pos = -1;
-            }else if(!c.rendered){
-                c.render(this.insertCell(c, side, pos));
-            }else{
-                if(!c.xtbHidden && !this.isValidParent(c, side.childNodes[pos])){
-                    var td = this.insertCell(c, side, pos);
-                    td.appendChild(c.getPositionEl().dom);
-                    c.container = Ext.get(td);
-                }
+        if(this.type){
+            if(Ext.isString(this.type)){
+                this.type = Ext.data.Types[this.type.toUpperCase()] || types.AUTO;
             }
+        }else{
+            this.type = types.AUTO;
         }
-        //strip extra empty cells
-        this.cleanup(this.leftTr);
-        this.cleanup(this.rightTr);
-        this.cleanup(this.extrasTr);
-        this.fitToSize(target);
-    },
 
-    cleanup : function(row){
-        var cn = row.childNodes, i, c;
-        for(i = cn.length-1; i >= 0 && (c = cn[i]); i--){
-            if(!c.firstChild){
-                row.removeChild(c);
-            }
+        // named sortTypes are supported, here we look them up
+        if(Ext.isString(st)){
+            this.sortType = Ext.data.SortTypes[st];
+        }else if(Ext.isEmpty(st)){
+            this.sortType = this.type.sortType;
         }
-    },
 
-    insertCell : function(c, side, pos){
-        var td = document.createElement('td');
-        td.className='x-toolbar-cell';
-        side.insertBefore(td, side.childNodes[pos]||null);
-        return td;
+        if(!this.convert){
+            this.convert = this.type.convert;
+        }
     },
+    
+    /**
+     * @cfg {String} name
+     * The name by which the field is referenced within the Record. This is referenced by, for example,
+     * the dataIndex property in column definition objects passed to {@link Ext.grid.ColumnModel}.
+     * Note: In the simplest case, if no properties other than name are required, a field
+     * definition may consist of just a String for the field name.
+     */
+    /**
+     * @cfg {Mixed} type
+     * (Optional) The data type for automatic conversion from received data to the stored value if {@link Ext.data.Field#convert convert}
+     * has not been specified. This may be specified as a string value. Possible values are
+     * 
+     * auto (Default, implies no conversion)
+     * string
+     * int
+     * float
+     * boolean
+     * date
+     * This may also be specified by referencing a member of the {@link Ext.data.Types} class.
+     * Developers may create their own application-specific data types by defining new members of the
+     * {@link Ext.data.Types} class.
+     */
+    /**
+     * @cfg {Function} convert
+     * (Optional) A function which converts the value provided by the Reader into an object that will be stored
+     * in the Record. It is passed the following parameters:
+     * v : MixedThe data value as read by the Reader, if undefined will use
+     * the configured {@link Ext.data.Field#defaultValue defaultValue}.
+     * rec : MixedThe data object containing the row as read by the Reader.
+     * Depending on the Reader type, this could be an Array ({@link Ext.data.ArrayReader ArrayReader}), an object
+     *  ({@link Ext.data.JsonReader JsonReader}), or an XML element ({@link Ext.data.XMLReader XMLReader}).
+     * 
+     * 
+// example of convert function
+function fullName(v, record){
+    return record.name.last + ', ' + record.name.first;
+}
 
-    hideItem : function(item){
-        var h = (this.hiddens = this.hiddens || []);
-        h.push(item);
-        item.xtbHidden = true;
-        item.xtbWidth = item.getPositionEl().dom.parentNode.offsetWidth;
-        item.hide();
-    },
+function location(v, record){
+    return !record.city ? '' : (record.city + ', ' + record.state);
+}
 
-    unhideItem : function(item){
-        item.show();
-        item.xtbHidden = false;
-        this.hiddens.remove(item);
-        if(this.hiddens.length < 1){
-            delete this.hiddens;
-        }
-    },
+var Dude = Ext.data.Record.create([
+    {name: 'fullname',  convert: fullName},
+    {name: 'firstname', mapping: 'name.first'},
+    {name: 'lastname',  mapping: 'name.last'},
+    {name: 'city', defaultValue: 'homeless'},
+    'state',
+    {name: 'location',  convert: location}
+]);
 
-    getItemWidth : function(c){
-        return c.hidden ? (c.xtbWidth || 0) : c.getPositionEl().dom.parentNode.offsetWidth;
-    },
+// create the data store
+var store = new Ext.data.Store({
+    reader: new Ext.data.JsonReader(
+        {
+            idProperty: 'key',
+            root: 'daRoot',
+            totalProperty: 'total'
+        },
+        Dude  // recordType
+    )
+});
 
-    fitToSize : function(t){
-        if(this.container.enableOverflow === false){
-            return;
-        }
-        var w = t.dom.clientWidth,
-            lw = this.lastWidth || 0,
-            iw = t.dom.firstChild.offsetWidth,
-            clipWidth = w - this.triggerWidth,
-            hideIndex = -1;
+var myData = [
+    { key: 1,
+      name: { first: 'Fat',    last:  'Albert' }
+      // notice no city, state provided in data object
+    },
+    { key: 2,
+      name: { first: 'Barney', last:  'Rubble' },
+      city: 'Bedrock', state: 'Stoneridge'
+    },
+    { key: 3,
+      name: { first: 'Cliff',  last:  'Claven' },
+      city: 'Boston',  state: 'MA'
+    }
+];
+     * 
+     */
+    /**
+     * @cfg {String} dateFormat
+     * (Optional) Used when converting received data into a Date when the {@link #type} is specified as "date".
+     * A format string for the {@link Date#parseDate Date.parseDate} function, or "timestamp" if the
+     * value provided by the Reader is a UNIX timestamp, or "time" if the value provided by the Reader is a
+     * javascript millisecond timestamp. See {@link Date}
+     */
+    dateFormat: null,
+    /**
+     * @cfg {Mixed} defaultValue
+     * (Optional) The default value used when a Record is being created by a {@link Ext.data.Reader Reader}
+     * when the item referenced by the {@link Ext.data.Field#mapping mapping} does not exist in the data
+     * object (i.e. undefined). (defaults to "")
+     */
+    defaultValue: "",
+    /**
+     * @cfg {String/Number} mapping
+     * (Optional) A path expression for use by the {@link Ext.data.DataReader} implementation
+     * that is creating the {@link Ext.data.Record Record} to extract the Field value from the data object.
+     * If the path expression is the same as the field name, the mapping may be omitted.
+     * The form of the mapping expression depends on the Reader being used.
+     * 
+     * {@link Ext.data.JsonReader}The mapping is a string containing the javascript
+     * expression to reference the data from an element of the data item's {@link Ext.data.JsonReader#root root} Array. Defaults to the field name.
+     * {@link Ext.data.XmlReader}The mapping is an {@link Ext.DomQuery} path to the data
+     * item relative to the DOM element that represents the {@link Ext.data.XmlReader#record record}. Defaults to the field name.
+     * {@link Ext.data.ArrayReader}The mapping is a number indicating the Array index
+     * of the field's value. Defaults to the field specification's Array position.
+     * 
+     * If a more complex value extraction strategy is required, then configure the Field with a {@link #convert}
+     * function. This is passed the whole row object, and may interrogate it in whatever way is necessary in order to
+     * return the desired data.
+     */
+    mapping: null,
+    /**
+     * @cfg {Function} sortType
+     * (Optional) A function which converts a Field's value to a comparable value in order to ensure
+     * correct sort ordering. Predefined functions are provided in {@link Ext.data.SortTypes}. A custom
+     * sort example:
+// current sort     after sort we want
+// +-+------+          +-+------+
+// |1|First |          |1|First |
+// |2|Last  |          |3|Second|
+// |3|Second|          |2|Last  |
+// +-+------+          +-+------+
 
-        this.lastWidth = w;
+sortType: function(value) {
+   switch (value.toLowerCase()) // native toLowerCase():
+   {
+      case 'first': return 1;
+      case 'second': return 2;
+      default: return 3;
+   }
+}
+     * 
+     */
+    sortType : null,
+    /**
+     * @cfg {String} sortDir
+     * (Optional) Initial direction to sort ("ASC" or  "DESC").  Defaults to
+     * "ASC".
+     */
+    sortDir : "ASC",
+    /**
+     * @cfg {Boolean} allowBlank
+     * (Optional) Used for validating a {@link Ext.data.Record record}, defaults to true.
+     * An empty value here will cause {@link Ext.data.Record}.{@link Ext.data.Record#isValid isValid}
+     * to evaluate to false.
+     */
+    allowBlank : true
+});
+/**
+ * @class Ext.data.DataReader
+ * Abstract base class for reading structured data from a data source and converting
+ * it into an object containing {@link Ext.data.Record} objects and metadata for use
+ * by an {@link Ext.data.Store}.  This class is intended to be extended and should not
+ * be created directly. For existing implementations, see {@link Ext.data.ArrayReader},
+ * {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}.
+ * @constructor Create a new DataReader
+ * @param {Object} meta Metadata configuration options (implementation-specific).
+ * @param {Array/Object} recordType
+ * Either an Array of {@link Ext.data.Field Field} definition objects (which
+ * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+ * constructor created using {@link Ext.data.Record#create}.
+ */
+Ext.data.DataReader = function(meta, recordType){
+    /**
+     * This DataReader's configured metadata as passed to the constructor.
+     * @type Mixed
+     * @property meta
+     */
+    this.meta = meta;
+    /**
+     * @cfg {Array/Object} fields
+     * Either an Array of {@link Ext.data.Field Field} definition objects (which
+     * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+     * constructor created from {@link Ext.data.Record#create}.
+     */
+    this.recordType = Ext.isArray(recordType) ?
+        Ext.data.Record.create(recordType) : recordType;
 
-        if(iw > w || (this.hiddens && w >= lw)){
-            var i, items = this.container.items.items,
-                len = items.length, c,
-                loopWidth = 0;
+    // if recordType defined make sure extraction functions are defined
+    if (this.recordType){
+        this.buildExtractors();
+    }
+};
 
-            for(i = 0; i < len; i++) {
-                c = items[i];
-                if(!c.isFill){
-                    loopWidth += this.getItemWidth(c);
-                    if(loopWidth > clipWidth){
-                        if(!(c.hidden || c.xtbHidden)){
-                            this.hideItem(c);
-                        }
-                    }else if(c.xtbHidden){
-                        this.unhideItem(c);
-                    }
+Ext.data.DataReader.prototype = {
+    /**
+     * @cfg {String} messageProperty [undefined] Optional name of a property within a server-response that represents a user-feedback message.
+     */
+    /**
+     * Abstract method created in extension's buildExtractors impl.
+     */
+    getTotal: Ext.emptyFn,
+    /**
+     * Abstract method created in extension's buildExtractors impl.
+     */
+    getRoot: Ext.emptyFn,
+    /**
+     * Abstract method created in extension's buildExtractors impl.
+     */
+    getMessage: Ext.emptyFn,
+    /**
+     * Abstract method created in extension's buildExtractors impl.
+     */
+    getSuccess: Ext.emptyFn,
+    /**
+     * Abstract method created in extension's buildExtractors impl.
+     */
+    getId: Ext.emptyFn,
+    /**
+     * Abstract method, overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}
+     */
+    buildExtractors : Ext.emptyFn,
+    /**
+     * Abstract method overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}
+     */
+    extractValues : Ext.emptyFn,
+
+    /**
+     * Used for un-phantoming a record after a successful database insert.  Sets the records pk along with new data from server.
+     * You must return at least the database pk using the idProperty defined in your DataReader configuration.  The incoming
+     * data from server will be merged with the data in the local record.
+     * In addition, you must return record-data from the server in the same order received.
+     * Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be suppressed.
+     * @param {Record/Record[]} record The phantom record to be realized.
+     * @param {Object/Object[]} data The new record data to apply.  Must include the primary-key from database defined in idProperty field.
+     */
+    realize: function(rs, data){
+        if (Ext.isArray(rs)) {
+            for (var i = rs.length - 1; i >= 0; i--) {
+                // recurse
+                if (Ext.isArray(data)) {
+                    this.realize(rs.splice(i,1).shift(), data.splice(i,1).shift());
+                }
+                else {
+                    // weird...rs is an array but data isn't??  recurse but just send in the whole invalid data object.
+                    // the else clause below will detect !this.isData and throw exception.
+                    this.realize(rs.splice(i,1).shift(), data);
                 }
             }
         }
-        if(this.hiddens){
-            this.initMore();
-            if(!this.lastOverflow){
-                this.container.fireEvent('overflowchange', this.container, true);
-                this.lastOverflow = true;
+        else {
+            // If rs is NOT an array but data IS, see if data contains just 1 record.  If so extract it and carry on.
+            if (Ext.isArray(data) && data.length == 1) {
+                data = data.shift();
             }
-        }else if(this.more){
-            this.clearMenu();
-            this.more.destroy();
-            delete this.more;
-            if(this.lastOverflow){
-                this.container.fireEvent('overflowchange', this.container, false);
-                this.lastOverflow = false;
+            if (!this.isData(data)) {
+                // TODO: Let exception-handler choose to commit or not rather than blindly rs.commit() here.
+                //rs.commit();
+                throw new Ext.data.DataReader.Error('realize', rs);
             }
+            rs.phantom = false; // <-- That's what it's all about
+            rs._phid = rs.id;  // <-- copy phantom-id -> _phid, so we can remap in Store#onCreateRecords
+            rs.id = this.getId(data);
+            rs.data = data;
+
+            rs.commit();
         }
     },
 
-    createMenuConfig : function(c, hideOnClick){
-        var cfg = Ext.apply({}, c.initialConfig),
-            group = c.toggleGroup;
-
-        Ext.apply(cfg, {
-            text: c.overflowText || c.text,
-            iconCls: c.iconCls,
-            icon: c.icon,
-            itemId: c.itemId,
-            disabled: c.disabled,
-            handler: c.handler,
-            scope: c.scope,
-            menu: c.menu,
-            hideOnClick: hideOnClick
-        });
-        if(group || c.enableToggle){
-            Ext.apply(cfg, {
-                group: group,
-                checked: c.pressed,
-                listeners: {
-                    checkchange: function(item, checked){
-                        c.toggle(checked);
-                    }
+    /**
+     * Used for updating a non-phantom or "real" record's data with fresh data from server after remote-save.
+     * If returning data from multiple-records after a batch-update, you must return record-data from the server in
+     * the same order received.  Will perform a commit as well, un-marking dirty-fields.  Store's "update" event will be
+     * suppressed as the record receives fresh new data-hash
+     * @param {Record/Record[]} rs
+     * @param {Object/Object[]} data
+     */
+    update : function(rs, data) {
+        if (Ext.isArray(rs)) {
+            for (var i=rs.length-1; i >= 0; i--) {
+                if (Ext.isArray(data)) {
+                    this.update(rs.splice(i,1).shift(), data.splice(i,1).shift());
                 }
-            });
+                else {
+                    // weird...rs is an array but data isn't??  recurse but just send in the whole data object.
+                    // the else clause below will detect !this.isData and throw exception.
+                    this.update(rs.splice(i,1).shift(), data);
+                }
+            }
         }
-        delete cfg.ownerCt;
-        delete cfg.xtype;
-        delete cfg.id;
-        return cfg;
-    },
-
-    // private
-    addComponentToMenu : function(m, c){
-        if(c instanceof Ext.Toolbar.Separator){
-            m.add('-');
-        }else if(Ext.isFunction(c.isXType)){
-            if(c.isXType('splitbutton')){
-                m.add(this.createMenuConfig(c, true));
-            }else if(c.isXType('button')){
-                m.add(this.createMenuConfig(c, !c.menu));
-            }else if(c.isXType('buttongroup')){
-                c.items.each(function(item){
-                     this.addComponentToMenu(m, item);
-                }, this);
+        else {
+            // If rs is NOT an array but data IS, see if data contains just 1 record.  If so extract it and carry on.
+            if (Ext.isArray(data) && data.length == 1) {
+                data = data.shift();
             }
+            if (this.isData(data)) {
+                rs.data = Ext.apply(rs.data, data);
+            }
+            rs.commit();
         }
     },
 
-    clearMenu : function(){
-        var m = this.moreMenu;
-        if(m && m.items){
-            m.items.each(function(item){
-                delete item.menu;
-            });
-        }
-    },
+    /**
+     * returns extracted, type-cast rows of data.  Iterates to call #extractValues for each row
+     * @param {Object[]/Object} data-root from server response
+     * @param {Boolean} returnRecords [false] Set true to return instances of Ext.data.Record
+     * @private
+     */
+    extractData : function(root, returnRecords) {
+        // A bit ugly this, too bad the Record's raw data couldn't be saved in a common property named "raw" or something.
+        var rawName = (this instanceof Ext.data.JsonReader) ? 'json' : 'node';
 
-    // private
-    beforeMoreShow : function(m){
-        var h = this.container.items.items,
-            len = h.length,
-            c,
-            prev,
-            needsSep = function(group, item){
-                return group.isXType('buttongroup') && !(item instanceof Ext.Toolbar.Separator);
-            };
+        var rs = [];
 
-        this.clearMenu();
-        m.removeAll();
-        for(var i = 0; i < len; i++){
-            c = h[i];
-            if(c.xtbHidden){
-                if(prev && (needsSep(c, prev) || needsSep(prev, c))){
-                    m.add('-');
-                }
-                this.addComponentToMenu(m, c);
-                prev = c;
+        // Had to add Check for XmlReader, #isData returns true if root is an Xml-object.  Want to check in order to re-factor
+        // #extractData into DataReader base, since the implementations are almost identical for JsonReader, XmlReader
+        if (this.isData(root) && !(this instanceof Ext.data.XmlReader)) {
+            root = [root];
+        }
+        var f       = this.recordType.prototype.fields,
+            fi      = f.items,
+            fl      = f.length,
+            rs      = [];
+        if (returnRecords === true) {
+            var Record = this.recordType;
+            for (var i = 0; i < root.length; i++) {
+                var n = root[i];
+                var record = new Record(this.extractValues(n, fi, fl), this.getId(n));
+                record[rawName] = n;    // <-- There's implementation of ugly bit, setting the raw record-data.
+                rs.push(record);
             }
         }
-        // put something so the menu isn't empty
-        // if no compatible items found
-        if(m.items.length < 1){
-            m.add(this.noItemsMenuText);
+        else {
+            for (var i = 0; i < root.length; i++) {
+                var data = this.extractValues(root[i], fi, fl);
+                data[this.meta.idProperty] = this.getId(root[i]);
+                rs.push(data);
+            }
         }
+        return rs;
     },
 
-    initMore : function(){
-        if(!this.more){
-            this.moreMenu = new Ext.menu.Menu({
-                ownerCt : this.container,
-                listeners: {
-                    beforeshow: this.beforeMoreShow,
-                    scope: this
-                }
-
-            });
-            this.more = new Ext.Button({
-                iconCls : 'x-toolbar-more-icon',
-                cls     : 'x-toolbar-more',
-                menu    : this.moreMenu,
-                ownerCt : this.container
-            });
-            var td = this.insertCell(this.more, this.extrasTr, 100);
-            this.more.render(td);
-        }
+    /**
+     * Returns true if the supplied data-hash looks and quacks like data.  Checks to see if it has a key
+     * corresponding to idProperty defined in your DataReader config containing non-empty pk.
+     * @param {Object} data
+     * @return {Boolean}
+     */
+    isData : function(data) {
+        return (data && Ext.isObject(data) && !Ext.isEmpty(this.getId(data))) ? true : false;
     },
 
-    destroy : function(){
-        Ext.destroy(this.more, this.moreMenu);
-        delete this.leftTr;
-        delete this.rightTr;
-        delete this.extrasTr;
-        Ext.layout.ToolbarLayout.superclass.destroy.call(this);
+    // private function a store will createSequence upon
+    onMetaChange : function(meta){
+        delete this.ef;
+        this.meta = meta;
+        this.recordType = Ext.data.Record.create(meta.fields);
+        this.buildExtractors();
     }
-});
+};
 
-Ext.Container.LAYOUTS.toolbar = Ext.layout.ToolbarLayout;/**
- * @class Ext.layout.MenuLayout
- * @extends Ext.layout.ContainerLayout
- * Layout manager used by {@link Ext.menu.Menu}. Generally this class should not need to be used directly.
+/**
+ * @class Ext.data.DataReader.Error
+ * @extends Ext.Error
+ * General error class for Ext.data.DataReader
  */
- Ext.layout.MenuLayout = Ext.extend(Ext.layout.ContainerLayout, {
-    monitorResize : true,
-
-    setContainer : function(ct){
-        this.monitorResize = !ct.floating;
-        // This event is only fired by the menu in IE, used so we don't couple
-        // the menu with the layout.
-        ct.on('autosize', this.doAutoSize, this);
-        Ext.layout.MenuLayout.superclass.setContainer.call(this, ct);
+Ext.data.DataReader.Error = Ext.extend(Ext.Error, {
+    constructor : function(message, arg) {
+        this.arg = arg;
+        Ext.Error.call(this, message);
     },
-
-    renderItem : function(c, position, target){
-        if (!this.itemTpl) {
-            this.itemTpl = Ext.layout.MenuLayout.prototype.itemTpl = new Ext.XTemplate(
-                '',
-                    '',
-                        '',
-                    '',
-                ''
-            );
-        }
-
-        if(c && !c.rendered){
-            if(Ext.isNumber(position)){
-                position = target.dom.childNodes[position];
-            }
-            var a = this.getItemArgs(c);
-
-//          The Component's positionEl is the  it is rendered into
-            c.render(c.positionEl = position ?
-                this.itemTpl.insertBefore(position, a, true) :
-                this.itemTpl.append(target, a, true));
-
-//          Link the containing

 to the item.
-            c.positionEl.menuItemId = c.getItemId();
-
-//          If rendering a regular Component, and it needs an icon,
-//          move the Component rightwards.
-            if (!a.isMenuItem && a.needsIcon) {
-                c.positionEl.addClass('x-menu-list-item-indent');
-            }
-            this.configureItem(c, position);
-        }else if(c && !this.isValidParent(c, target)){
-            if(Ext.isNumber(position)){
-                position = target.dom.childNodes[position];
-            }
-            target.dom.insertBefore(c.getActionEl().dom, position || null);
+    name: 'Ext.data.DataReader'
+});
+Ext.apply(Ext.data.DataReader.Error.prototype, {
+    lang : {
+        'update': "#update received invalid data from server.  Please see docs for DataReader#update and review your DataReader configuration.",
+        'realize': "#realize was called with invalid remote-data.  Please see the docs for DataReader#realize and review your DataReader configuration.",
+        'invalid-response': "#readResponse received an invalid response from the server."
+    }
+});
+/**
+ * @class Ext.data.DataWriter
+ * Ext.data.DataWriter facilitates create, update, and destroy actions between
+ * an Ext.data.Store and a server-side framework. A Writer enabled Store will
+ * automatically manage the Ajax requests to perform CRUD actions on a Store.
+ * Ext.data.DataWriter is an abstract base class which is intended to be extended
+ * and should not be created directly. For existing implementations, see
+ * {@link Ext.data.JsonWriter}.
+ * Creating a writer is simple:
+ * 
+var writer = new Ext.data.JsonWriter({
+    encode: false   // <--- false causes data to be printed to jsonData config-property of Ext.Ajax#reqeust
+});
+ * 
+ * * Same old JsonReader as Ext-2.x:
+ * 
+var reader = new Ext.data.JsonReader({idProperty: 'id'}, [{name: 'first'}, {name: 'last'}, {name: 'email'}]);
+ * 
+ *
+ * The proxy for a writer enabled store can be configured with a simple url:
+ * 
+// Create a standard HttpProxy instance.
+var proxy = new Ext.data.HttpProxy({
+    url: 'app.php/users'    // <--- Supports "provides"-type urls, such as '/users.json', '/products.xml' (Hello Rails/Merb)
+});
+ * 
+ * For finer grained control, the proxy may also be configured with an API:
+ * 
+// Maximum flexibility with the API-configuration
+var proxy = new Ext.data.HttpProxy({
+    api: {
+        read    : 'app.php/users/read',
+        create  : 'app.php/users/create',
+        update  : 'app.php/users/update',
+        destroy : {  // <--- Supports object-syntax as well
+            url: 'app.php/users/destroy',
+            method: "DELETE"
         }
-    },
+    }
+});
+ * 
+ * Pulling it all together into a Writer-enabled Store:
+ * 
+var store = new Ext.data.Store({
+    proxy: proxy,
+    reader: reader,
+    writer: writer,
+    autoLoad: true,
+    autoSave: true  // -- Cell-level updates.
+});
+ * 
+ * Initiating write-actions automatically, using the existing Ext2.0 Store/Record API:
+ * 
+var rec = store.getAt(0);
+rec.set('email', 'foo@bar.com');  // <--- Immediately initiates an UPDATE action through configured proxy.
 
-    getItemArgs : function(c) {
-        var isMenuItem = c instanceof Ext.menu.Item;
-        return {
-            isMenuItem: isMenuItem,
-            needsIcon: !isMenuItem && (c.icon || c.iconCls),
-            icon: c.icon || Ext.BLANK_IMAGE_URL,
-            iconCls: 'x-menu-item-icon ' + (c.iconCls || ''),
-            itemId: 'x-menu-el-' + c.id,
-            itemCls: 'x-menu-list-item '
-        };
-    },
+store.remove(rec);  // <---- Immediately initiates a DESTROY action through configured proxy.
+ * 
+ * For record/batch updates, use the Store-configuration {@link Ext.data.Store#autoSave autoSave:false}
+ * 
+var store = new Ext.data.Store({
+    proxy: proxy,
+    reader: reader,
+    writer: writer,
+    autoLoad: true,
+    autoSave: false  // -- disable cell-updates
+});
 
-    //  Valid if the Component is in a  which is part of our target 
-    isValidParent : function(c, target) {
-        return c.el.up('li.x-menu-list-item', 5).dom.parentNode === (target.dom || target);
-    },
+var urec = store.getAt(0);
+urec.set('email', 'foo@bar.com');
 
-    onLayout : function(ct, target){
-        Ext.layout.MenuLayout.superclass.onLayout.call(this, ct, target);
-        this.doAutoSize();
-    },
+var drec = store.getAt(1);
+store.remove(drec);
 
-    doAutoSize : function(){
-        var ct = this.container, w = ct.width;
-        if(ct.floating){
-            if(w){
-                ct.setWidth(w);
-            }else if(Ext.isIE){
-                ct.setWidth(Ext.isStrict && (Ext.isIE7 || Ext.isIE8) ? 'auto' : ct.minWidth);
-                var el = ct.getEl(), t = el.dom.offsetWidth; // force recalc
-                ct.setWidth(ct.getLayoutTarget().getWidth() + el.getFrameWidth('lr'));
-            }
-        }
-    }
-});
-Ext.Container.LAYOUTS['menu'] = Ext.layout.MenuLayout;/**
- * @class Ext.Viewport
- * @extends Ext.Container
- * A specialized container representing the viewable application area (the browser viewport).
- * The Viewport renders itself to the document body, and automatically sizes itself to the size of
- * the browser viewport and manages window resizing. There may only be one Viewport created
- * in a page. Inner layouts are available by virtue of the fact that all {@link Ext.Panel Panel}s
- * added to the Viewport, either through its {@link #items}, or through the items, or the {@link #add}
- * method of any of its child Panels may themselves have a layout.
- * The Viewport does not provide scrolling, so child Panels within the Viewport should provide
- * for scrolling if needed using the {@link #autoScroll} config.
- * An example showing a classic application border layout:

-new Ext.Viewport({
-    layout: 'border',
-    items: [{
-        region: 'north',
-        html: '<h1 class="x-panel-header">Page Title</h1>',
-        autoHeight: true,
-        border: false,
-        margins: '0 0 5 0'
-    }, {
-        region: 'west',
-        collapsible: true,
-        title: 'Navigation',
-        width: 200
-        // the west region might typically utilize a {@link Ext.tree.TreePanel TreePanel} or a Panel with {@link Ext.layout.AccordionLayout Accordion layout}
-    }, {
-        region: 'south',
-        title: 'Title for Panel',
-        collapsible: true,
-        html: 'Information goes here',
-        split: true,
-        height: 100,
-        minHeight: 100
-    }, {
-        region: 'east',
-        title: 'Title for the Grid Panel',
-        collapsible: true,
-        split: true,
-        width: 200,
-        xtype: 'grid',
-        // remaining grid configuration not shown ...
-        // notice that the GridPanel is added directly as the region
-        // it is not "overnested" inside another Panel
-    }, {
-        region: 'center',
-        xtype: 'tabpanel', // TabPanel itself has no title
-        items: {
-            title: 'Default Tab',
-            html: 'The first tab\'s content. Others may be added dynamically'
-        }
-    }]
-});
-
- * @constructor
- * Create a new Viewport
- * @param {Object} config The config object
- * @xtype viewport
- */
-Ext.Viewport = Ext.extend(Ext.Container, {
-    /*
-     * Privatize config options which, if used, would interfere with the
-     * correct operation of the Viewport as the sole manager of the
-     * layout of the document body.
-     */
-    /**
-     * @cfg {Mixed} applyTo @hide
-     */
-    /**
-     * @cfg {Boolean} allowDomMove @hide
-     */
-    /**
-     * @cfg {Boolean} hideParent @hide
-     */
-    /**
-     * @cfg {Mixed} renderTo @hide
-     */
-    /**
-     * @cfg {Boolean} hideParent @hide
-     */
-    /**
-     * @cfg {Number} height @hide
-     */
-    /**
-     * @cfg {Number} width @hide
-     */
-    /**
-     * @cfg {Boolean} autoHeight @hide
-     */
-    /**
-     * @cfg {Boolean} autoWidth @hide
-     */
-    /**
-     * @cfg {Boolean} deferHeight @hide
-     */
-    /**
-     * @cfg {Boolean} monitorResize @hide
-     */
-
-    initComponent : function() {
-        Ext.Viewport.superclass.initComponent.call(this);
-        document.getElementsByTagName('html')[0].className += ' x-viewport';
-        this.el = Ext.getBody();
-        this.el.setHeight = Ext.emptyFn;
-        this.el.setWidth = Ext.emptyFn;
-        this.el.setSize = Ext.emptyFn;
-        this.el.dom.scroll = 'no';
-        this.allowDomMove = false;
-        this.autoWidth = true;
-        this.autoHeight = true;
-        Ext.EventManager.onWindowResize(this.fireResize, this);
-        this.renderTo = this.el;
-    },
-
-    fireResize : function(w, h){
-        this.fireEvent('resize', this, w, h, w, h);
-    }
-});
-Ext.reg('viewport', Ext.Viewport);
-/**
- * @class Ext.Panel
- * @extends Ext.Container
- * Panel is a container that has specific functionality and structural components that make
- * it the perfect building block for application-oriented user interfaces.
- * Panels are, by virtue of their inheritance from {@link Ext.Container}, capable
- * of being configured with a {@link Ext.Container#layout layout}, and containing child Components.
- * When either specifying child {@link Ext.Component#items items} of a Panel, or dynamically {@link Ext.Container#add adding} Components
- * to a Panel, remember to consider how you wish the Panel to arrange those child elements, and whether
- * those child elements need to be sized using one of Ext's built-in {@link Ext.Container#layout layout} schemes. By
- * default, Panels use the {@link Ext.layout.ContainerLayout ContainerLayout} scheme. This simply renders
- * child components, appending them one after the other inside the Container, and does not apply any sizing
- * at all.
- * A Panel may also contain {@link #bbar bottom} and {@link #tbar top} toolbars, along with separate
- * {@link #header}, {@link #footer} and {@link #body} sections (see {@link #frame} for additional
- * information).
- * Panel also provides built-in {@link #collapsible expandable and collapsible behavior}, along with
- * a variety of {@link #tools prebuilt tool buttons} that can be wired up to provide other customized
- * behavior.  Panels can be easily dropped into any {@link Ext.Container Container} or layout, and the
- * layout and rendering pipeline is {@link Ext.Container#add completely managed by the framework}.
- * @constructor
- * @param {Object} config The config object
- * @xtype panel
+// Push the button!
+store.save();
+ * 
+ * @constructor Create a new DataWriter
+ * @param {Object} meta Metadata configuration options (implementation-specific)
+ * @param {Object} recordType Either an Array of field definition objects as specified
+ * in {@link Ext.data.Record#create}, or an {@link Ext.data.Record} object created
+ * using {@link Ext.data.Record#create}.
  */
-Ext.Panel = Ext.extend(Ext.Container, {
+Ext.data.DataWriter = function(config){
+    Ext.apply(this, config);
+};
+Ext.data.DataWriter.prototype = {
+
     /**
-     * The Panel's header {@link Ext.Element Element}. Read-only.
-     * This Element is used to house the {@link #title} and {@link #tools}
-     * 
Note: see the Note for {@link Ext.Component#el el} also.
-     * @type Ext.Element
-     * @property header
+     * @cfg {Boolean} writeAllFields
+     * false by default.  Set true to have DataWriter return ALL fields of a modified
+     * record -- not just those that changed.
+     * false to have DataWriter only request modified fields from a record.
      */
+    writeAllFields : false,
     /**
-     * The Panel's body {@link Ext.Element Element} which may be used to contain HTML content.
-     * The content may be specified in the {@link #html} config, or it may be loaded using the
-     * {@link autoLoad} config, or through the Panel's {@link #getUpdater Updater}. Read-only.
-     * If this is used to load visible HTML elements in either way, then
-     * the Panel may not be used as a Layout for hosting nested Panels.
-     * If this Panel is intended to be used as the host of a Layout (See {@link #layout}
-     * then the body Element must not be loaded or changed - it is under the control
-     * of the Panel's Layout.
-     * 
Note: see the Note for {@link Ext.Component#el el} also.
-     * @type Ext.Element
-     * @property body
+     * @cfg {Boolean} listful
+     * false by default.  Set true to have the DataWriter always write HTTP params as a list,
+     * even when acting upon a single record.
      */
+    listful : false,    // <-- listful is actually not used internally here in DataWriter.  @see Ext.data.Store#execute.
+
     /**
-     * The Panel's bwrap {@link Ext.Element Element} used to contain other Panel elements
-     * (tbar, body, bbar, footer). See {@link #bodyCfg}. Read-only.
-     * @type Ext.Element
-     * @property bwrap
+     * Compiles a Store recordset into a data-format defined by an extension such as {@link Ext.data.JsonWriter} or {@link Ext.data.XmlWriter} in preparation for a {@link Ext.data.Api#actions server-write action}.  The first two params are similar similar in nature to {@link Ext#apply},
+     * Where the first parameter is the receiver of paramaters and the second, baseParams, the source.
+     * @param {Object} params The request-params receiver.
+     * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}.  The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}.
+     * @param {String} action [{@link Ext.data.Api#actions create|update|destroy}]
+     * @param {Record/Record[]} rs The recordset to write, the subject(s) of the write action.
      */
+    apply : function(params, baseParams, action, rs) {
+        var data    = [],
+        renderer    = action + 'Record';
+        // TODO implement @cfg listful here
+        if (Ext.isArray(rs)) {
+            Ext.each(rs, function(rec){
+                data.push(this[renderer](rec));
+            }, this);
+        }
+        else if (rs instanceof Ext.data.Record) {
+            data = this[renderer](rs);
+        }
+        this.render(params, baseParams, data);
+    },
+
     /**
-     * True if this panel is collapsed. Read-only.
-     * @type Boolean
-     * @property collapsed
+     * abstract method meant to be overridden by all DataWriter extensions.  It's the extension's job to apply the "data" to the "params".
+     * The data-object provided to render is populated with data according to the meta-info defined in the user's DataReader config,
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Record[]} rs Store recordset
+     * @param {Object} params Http params to be sent to server.
+     * @param {Object} data object populated according to DataReader meta-data.
      */
+    render : Ext.emptyFn,
+
     /**
-     * @cfg {Object} bodyCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object may be specified for any
-     * Panel Element.
-     * By default, the Default element in the table below will be used for the html markup to
-     * create a child element with the commensurate Default class name (baseCls will be
-     * replaced by {@link #baseCls}):
-     * -     * Panel      Default  Default             Custom      Additional       Additional
-     * Element    element  class               element     class            style
-     * ========   ==========================   =========   ==============   ===========
-     * {@link #header}     div      {@link #baseCls}+'-header'   {@link #headerCfg}   headerCssClass   headerStyle
-     * {@link #bwrap}      div      {@link #baseCls}+'-bwrap'     {@link #bwrapCfg}    bwrapCssClass    bwrapStyle
-     * + tbar     div      {@link #baseCls}+'-tbar'       {@link #tbarCfg}     tbarCssClass     tbarStyle
-     * + {@link #body}     div      {@link #baseCls}+'-body'       {@link #bodyCfg}     {@link #bodyCssClass}     {@link #bodyStyle}
-     * + bbar     div      {@link #baseCls}+'-bbar'       {@link #bbarCfg}     bbarCssClass     bbarStyle
-     * + {@link #footer}   div      {@link #baseCls}+'-footer'   {@link #footerCfg}   footerCssClass   footerStyle
-     * 
-     * Configuring a Custom element may be used, for example, to force the {@link #body} Element
-     * to use a different form of markup than is created by default. An example of this might be
-     * to {@link Ext.Element#createChild create a child} Panel containing a custom content, such as
-     * a header, or forcing centering of all Panel content by having the body be a <center>
-     * element:
-     * 
-new Ext.Panel({
-    title: 'Message Title',
-    renderTo: Ext.getBody(),
-    width: 200, height: 130,
-    bodyCfg: {
-        tag: 'center',
-        cls: 'x-panel-body',  // Default class not applied if Custom element specified
-        html: 'Message'
-    },
-    footerCfg: {
-        tag: 'h2',
-        cls: 'x-panel-footer'        // same as the Default class
-        html: 'footer html'
-    },
-    footerCssClass: 'custom-footer', // additional css class, see {@link Ext.element#addClass addClass}
-    footerStyle:    'background-color:red' // see {@link #bodyStyle}
-});
-     * 
-     * The example above also explicitly creates a {@link #footer} with custom markup and
-     * styling applied.
+     * @cfg {Function} updateRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#updateRecord JsonWriter.updateRecord}
      */
+    updateRecord : Ext.emptyFn,
+
     /**
-     * @cfg {Object} headerCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
-     * of this Panel's {@link #header} Element.  See {@link #bodyCfg} also.
+     * @cfg {Function} createRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#createRecord JsonWriter.createRecord})
      */
+    createRecord : Ext.emptyFn,
+
     /**
-     * @cfg {Object} bwrapCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
-     * of this Panel's {@link #bwrap} Element.  See {@link #bodyCfg} also.
+     * @cfg {Function} destroyRecord Abstract method that should be implemented in all subclasses
+     * (e.g.: {@link Ext.data.JsonWriter#destroyRecord JsonWriter.destroyRecord})
      */
+    destroyRecord : Ext.emptyFn,
+
     /**
-     * @cfg {Object} tbarCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
-     * of this Panel's {@link #tbar} Element.  See {@link #bodyCfg} also.
+     * Converts a Record to a hash, taking into account the state of the Ext.data.Record along with configuration properties
+     * related to its rendering, such as {@link #writeAllFields}, {@link Ext.data.Record#phantom phantom}, {@link Ext.data.Record#getChanges getChanges} and
+     * {@link Ext.data.DataReader#idProperty idProperty}
+     * @param {Ext.data.Record} rec The Record from which to create a hash.
+     * @param {Object} config NOT YET IMPLEMENTED.  Will implement an exlude/only configuration for fine-control over which fields do/don't get rendered.
+     * @return {Object}
+     * @protected
+     * TODO Implement excludes/only configuration with 2nd param?
      */
+    toHash : function(rec, config) {
+        var map = rec.fields.map,
+            data = {},
+            raw = (this.writeAllFields === false && rec.phantom === false) ? rec.getChanges() : rec.data,
+            m;
+        Ext.iterate(raw, function(prop, value){
+            if((m = map[prop])){
+                data[m.mapping ? m.mapping : m.name] = value;
+            }
+        });
+        // we don't want to write Ext auto-generated id to hash.  Careful not to remove it on Models not having auto-increment pk though.
+        // We can tell its not auto-increment if the user defined a DataReader field for it *and* that field's value is non-empty.
+        // we could also do a RegExp here for the Ext.data.Record AUTO_ID prefix.
+        if (rec.phantom) {
+            if (rec.fields.containsKey(this.meta.idProperty) && Ext.isEmpty(rec.data[this.meta.idProperty])) {
+                delete data[this.meta.idProperty];
+            }
+        } else {
+            data[this.meta.idProperty] = rec.id
+        }
+        return data;
+    },
+
     /**
-     * @cfg {Object} bbarCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
-     * of this Panel's {@link #bbar} Element.  See {@link #bodyCfg} also.
+     * Converts a {@link Ext.data.DataWriter#toHash Hashed} {@link Ext.data.Record} to fields-array array suitable
+     * for encoding to xml via XTemplate, eg:
+<tpl for="."><{name}>{value}</{name}</tpl>
+     * eg, non-phantom:
+{id: 1, first: 'foo', last: 'bar'} --> [{name: 'id', value: 1}, {name: 'first', value: 'foo'}, {name: 'last', value: 'bar'}]
+     * {@link Ext.data.Record#phantom Phantom} records will have had their idProperty omitted in {@link #toHash} if determined to be auto-generated.
+     * Non AUTOINCREMENT pks should have been protected.
+     * @param {Hash} data Hashed by Ext.data.DataWriter#toHash
+     * @return {[Object]} Array of attribute-objects.
+     * @protected
      */
+    toArray : function(data) {
+        var fields = [];
+        Ext.iterate(data, function(k, v) {fields.push({name: k, value: v});},this);
+        return fields;
+    }
+};/**
+ * @class Ext.data.DataProxy
+ * @extends Ext.util.Observable
+ * Abstract base class for implementations which provide retrieval of unformatted data objects.
+ * This class is intended to be extended and should not be created directly. For existing implementations,
+ * see {@link Ext.data.DirectProxy}, {@link Ext.data.HttpProxy}, {@link Ext.data.ScriptTagProxy} and
+ * {@link Ext.data.MemoryProxy}.
+ * DataProxy implementations are usually used in conjunction with an implementation of {@link Ext.data.DataReader}
+ * (of the appropriate type which knows how to parse the data object) to provide a block of
+ * {@link Ext.data.Records} to an {@link Ext.data.Store}.
+ * The parameter to a DataProxy constructor may be an {@link Ext.data.Connection} or can also be the
+ * config object to an {@link Ext.data.Connection}.
+ * Custom implementations must implement either the doRequest method (preferred) or the
+ * load method (deprecated). See
+ * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#doRequest doRequest} or
+ * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#load load} for additional details.
+ * Example 1
+ * 
+proxy: new Ext.data.ScriptTagProxy({
+    {@link Ext.data.Connection#url url}: 'http://extjs.com/forum/topics-remote.php'
+}),
+ * 
+ * Example 2
+ * 
+proxy : new Ext.data.HttpProxy({
+    {@link Ext.data.Connection#method method}: 'GET',
+    {@link Ext.data.HttpProxy#prettyUrls prettyUrls}: false,
+    {@link Ext.data.Connection#url url}: 'local/default.php', // see options parameter for {@link Ext.Ajax#request}
+    {@link #api}: {
+        // all actions except the following will use above url
+        create  : 'local/new.php',
+        update  : 'local/update.php'
+    }
+}),
+ * 
+ * And new in Ext version 3, attach centralized event-listeners upon the DataProxy class itself!  This is a great place
+ * to implement a messaging system to centralize your application's user-feedback and error-handling.
+ * 
+// Listen to all "beforewrite" event fired by all proxies.
+Ext.data.DataProxy.on('beforewrite', function(proxy, action) {
+    console.log('beforewrite: ', action);
+});
+
+// Listen to "write" event fired by all proxies
+Ext.data.DataProxy.on('write', function(proxy, action, data, res, rs) {
+    console.info('write: ', action);
+});
+
+// Listen to "exception" event fired by all proxies
+Ext.data.DataProxy.on('exception', function(proxy, type, action) {
+    console.error(type + action + ' exception);
+});
+ * 
+ * Note: These three events are all fired with the signature of the corresponding DataProxy instance event {@link #beforewrite beforewrite}, {@link #write write} and {@link #exception exception}.
+ */
+Ext.data.DataProxy = function(conn){
+    // make sure we have a config object here to support ux proxies.
+    // All proxies should now send config into superclass constructor.
+    conn = conn || {};
+
+    // This line caused a bug when people use custom Connection object having its own request method.
+    // http://extjs.com/forum/showthread.php?t=67194.  Have to set DataProxy config
+    //Ext.applyIf(this, conn);
+
+    this.api     = conn.api;
+    this.url     = conn.url;
+    this.restful = conn.restful;
+    this.listeners = conn.listeners;
+
+    // deprecated
+    this.prettyUrls = conn.prettyUrls;
+
     /**
-     * @cfg {Object} footerCfg
-     * A {@link Ext.DomHelper DomHelper} element specification object specifying the element structure
-     * of this Panel's {@link #footer} Element.  See {@link #bodyCfg} also.
+     * @cfg {Object} api
+     * Specific urls to call on CRUD action methods "read", "create", "update" and "destroy".
+     * Defaults to:
+api: {
+    read    : undefined,
+    create  : undefined,
+    update  : undefined,
+    destroy : undefined
+}
+     * 
+     * The url is built based upon the action being executed [load|create|save|destroy]
+     * using the commensurate {@link #api} property, or if undefined default to the
+     * configured {@link Ext.data.Store}.{@link Ext.data.Store#url url}.


+     * For example:
+     * 
+api: {
+    load :    '/controller/load',
+    create :  '/controller/new',  // Server MUST return idProperty of new record
+    save :    '/controller/update',
+    destroy : '/controller/destroy_action'
+}
+
+// Alternatively, one can use the object-form to specify each API-action
+api: {
+    load: {url: 'read.php', method: 'GET'},
+    create: 'create.php',
+    destroy: 'destroy.php',
+    save: 'update.php'
+}
+     * 
+     * If the specific URL for a given CRUD action is undefined, the CRUD action request
+     * will be directed to the configured {@link Ext.data.Connection#url url}.
+     * 
Note: To modify the URL for an action dynamically the appropriate API
+     * property should be modified before the action is requested using the corresponding before
+     * action event.  For example to modify the URL associated with the load action:
+     * 

+// modify the url for the action
+myStore.on({
+    beforeload: {
+        fn: function (store, options) {
+            // use {@link Ext.data.HttpProxy#setUrl setUrl} to change the URL for *just* this request.
+            store.proxy.setUrl('changed1.php');
+
+            // set optional second parameter to true to make this URL change
+            // permanent, applying this URL for all subsequent requests.
+            store.proxy.setUrl('changed1.php', true);
+
+            // Altering the proxy API should be done using the public
+            // method {@link Ext.data.DataProxy#setApi setApi}.
+            store.proxy.setApi('read', 'changed2.php');
+
+            // Or set the entire API with a config-object.
+            // When using the config-object option, you must redefine the entire
+            // API -- not just a specific action of it.
+            store.proxy.setApi({
+                read    : 'changed_read.php',
+                create  : 'changed_create.php',
+                update  : 'changed_update.php',
+                destroy : 'changed_destroy.php'
+            });
+        }
+    }
+});
+     * 
+     * 
      */
+
+    this.addEvents(
+        /**
+         * @event exception
+         * Fires if an exception occurs in the Proxy during a remote request. This event is relayed
+         * through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception},
+         * so any Store instance may observe this event.
+         * In addition to being fired through the DataProxy instance that raised the event, this event is also fired
+         * through the Ext.data.DataProxy class to allow for centralized processing of exception events from all
+         * DataProxies by attaching a listener to the Ext.data.Proxy class itself.
+         * This event can be fired for one of two reasons:
+         * 
+         * remote-request failed : 
+         * The server did not return status === 200.
+         * 
+         * remote-request succeeded : 
+         * The remote-request succeeded but the reader could not read the response.
+         * This means the server returned data, but the configured Reader threw an
+         * error while reading the response.  In this case, this event will be
+         * raised and the caught error will be passed along into this event.
+         * 
+         * 
+         * 
This event fires with two different contexts based upon the 2nd
+         * parameter type [remote|response].  The first four parameters
+         * are identical between the two contexts -- only the final two parameters
+         * differ.
+         * @param {DataProxy} this The proxy that sent the request
+         * @param {String} type
+         * The value of this parameter will be either 'response' or 'remote'.
+         * 
+         * 'response' : 
+         * An invalid response from the server was returned: either 404,
+         * 500 or the response meta-data does not match that defined in the DataReader
+         * (e.g.: root, idProperty, successProperty).
+         * 
+         * 'remote' : 
+         * A valid response was returned from the server having
+         * successProperty === false.  This response might contain an error-message
+         * sent from the server.  For example, the user may have failed
+         * authentication/authorization or a database validation error occurred.
+         * 
+         * 
+         * @param {String} action Name of the action (see {@link Ext.data.Api#actions}.
+         * @param {Object} options The options for the action that were specified in the {@link #request}.
+         * @param {Object} response
+         * The value of this parameter depends on the value of the type parameter:
+         * 
+         * 'response' : 
+         * The raw browser response object (e.g.: XMLHttpRequest)
+         * 
+         * 'remote' : 
+         * The decoded response object sent from the server.
+         * 
+         * 
+         * @param {Mixed} arg
+         * The type and value of this parameter depends on the value of the type parameter:
+         * 
+         * 'response' : Error
+         * The JavaScript Error object caught if the configured Reader could not read the data.
+         * If the remote request returns success===false, this parameter will be null.
+         * 
+         * 'remote' : Record/Record[]
+         * This parameter will only exist if the action was a write action
+         * (Ext.data.Api.actions.create|update|destroy).
+         * 
+         * 
+         */
+        'exception',
+        /**
+         * @event beforeload
+         * Fires before a request to retrieve a data object.
+         * @param {DataProxy} this The proxy for the request
+         * @param {Object} params The params object passed to the {@link #request} function
+         */
+        'beforeload',
+        /**
+         * @event load
+         * Fires before the load method's callback is called.
+         * @param {DataProxy} this The proxy for the request
+         * @param {Object} o The request transaction object
+         * @param {Object} options The callback's options property as passed to the {@link #request} function
+         */
+        'load',
+        /**
+         * @event loadexception
+         * This event is deprecated.  The signature of the loadexception event
+         * varies depending on the proxy, use the catch-all {@link #exception} event instead.
+         * This event will fire in addition to the {@link #exception} event.
+         * @param {misc} misc See {@link #exception}.
+         * @deprecated
+         */
+        'loadexception',
+        /**
+         * @event beforewrite
+         * Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy
+         * In addition to being fired through the DataProxy instance that raised the event, this event is also fired
+         * through the Ext.data.DataProxy class to allow for centralized processing of beforewrite events from all
+         * DataProxies by attaching a listener to the Ext.data.Proxy class itself.
+         * @param {DataProxy} this The proxy for the request
+         * @param {String} action [Ext.data.Api.actions.create|update|destroy]
+         * @param {Record/Record[]} rs The Record(s) to create|update|destroy.
+         * @param {Object} params The request params object.  Edit params to add parameters to the request.
+         */
+        'beforewrite',
+        /**
+         * @event write
+         * Fires before the request-callback is called
+         * In addition to being fired through the DataProxy instance that raised the event, this event is also fired
+         * through the Ext.data.DataProxy class to allow for centralized processing of write events from all
+         * DataProxies by attaching a listener to the Ext.data.Proxy class itself.
+         * @param {DataProxy} this The proxy that sent the request
+         * @param {String} action [Ext.data.Api.actions.create|upate|destroy]
+         * @param {Object} data The data object extracted from the server-response
+         * @param {Object} response The decoded response from server
+         * @param {Record/Record[]} rs The Record(s) from Store
+         * @param {Object} options The callback's options property as passed to the {@link #request} function
+         */
+        'write'
+    );
+    Ext.data.DataProxy.superclass.constructor.call(this);
+
+    // Prepare the proxy api.  Ensures all API-actions are defined with the Object-form.
+    try {
+        Ext.data.Api.prepare(this);
+    } catch (e) {
+        if (e instanceof Ext.data.Api.Error) {
+            e.toConsole();
+        }
+    }
+    // relay each proxy's events onto Ext.data.DataProxy class for centralized Proxy-listening
+    Ext.data.DataProxy.relayEvents(this, ['beforewrite', 'write', 'exception']);
+};
+
+Ext.extend(Ext.data.DataProxy, Ext.util.Observable, {
     /**
-     * @cfg {Boolean} closable
-     * Panels themselves do not directly support being closed, but some Panel subclasses do (like
-     * {@link Ext.Window}) or a Panel Class within an {@link Ext.TabPanel}.  Specify true
-     * to enable closing in such situations. Defaults to false.
+     * @cfg {Boolean} restful
+     * Defaults to false.  Set to true to operate in a RESTful manner.
+     * 
 Note: this parameter will automatically be set to true if the
+     * {@link Ext.data.Store} it is plugged into is set to restful: true. If the
+     * Store is RESTful, there is no need to set this option on the proxy.
+     * 
RESTful implementations enable the serverside framework to automatically route
+     * actions sent to one url based upon the HTTP method, for example:
+     * 

+store: new Ext.data.Store({
+    restful: true,
+    proxy: new Ext.data.HttpProxy({url:'/users'}); // all requests sent to /users
+    ...
+)}
+     * 
+     * If there is no {@link #api} specified in the configuration of the proxy,
+     * all requests will be marshalled to a single RESTful url (/users) so the serverside
+     * framework can inspect the HTTP Method and act accordingly:
+     * +Method   url        action
+POST     /users     create
+GET      /users     read
+PUT      /users/23  update
+DESTROY  /users/23  delete
+     * 

+     * If set to true, a {@link Ext.data.Record#phantom non-phantom} record's
+     * {@link Ext.data.Record#id id} will be appended to the url. Some MVC (e.g., Ruby on Rails,
+     * Merb and Django) support segment based urls where the segments in the URL follow the
+     * Model-View-Controller approach:

+     * someSite.com/controller/action/id
+     * 
+     * Where the segments in the url are typically:
+     * The first segment : represents the controller class that should be invoked.
+     * The second segment : represents the class function, or method, that should be called.
+     * The third segment : represents the ID (a variable typically passed to the method).
+     * 

+     * 
Refer to {@link Ext.data.DataProxy#api} for additional information.
      */
+    restful: false,
+
     /**
-     * The Panel's footer {@link Ext.Element Element}. Read-only.
-     * This Element is used to house the Panel's {@link #buttons} or {@link #fbar}.
-     * 
Note: see the Note for {@link Ext.Component#el el} also.
-     * @type Ext.Element
-     * @property footer
+     * Redefines the Proxy's API or a single action of an API. Can be called with two method signatures.
+     * If called with an object as the only parameter, the object should redefine the entire API, e.g.:

+proxy.setApi({
+    read    : '/users/read',
+    create  : '/users/create',
+    update  : '/users/update',
+    destroy : '/users/destroy'
+});
+
+     * If called with two parameters, the first parameter should be a string specifying the API action to
+     * redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.:

+proxy.setApi(Ext.data.Api.actions.read, '/users/new_load_url');
+
+     * @param {String/Object} api An API specification object, or the name of an action.
+     * @param {String/Function} url The URL (or function if using DirectProxy) to call for the action.
      */
+    setApi : function() {
+        if (arguments.length == 1) {
+            var valid = Ext.data.Api.isValid(arguments[0]);
+            if (valid === true) {
+                this.api = arguments[0];
+            }
+            else {
+                throw new Ext.data.Api.Error('invalid', valid);
+            }
+        }
+        else if (arguments.length == 2) {
+            if (!Ext.data.Api.isAction(arguments[0])) {
+                throw new Ext.data.Api.Error('invalid', arguments[0]);
+            }
+            this.api[arguments[0]] = arguments[1];
+        }
+        Ext.data.Api.prepare(this);
+    },
+
     /**
-     * @cfg {Mixed} applyTo
-     * The id of the node, a DOM node or an existing Element corresponding to a DIV that is already present in
-     * the document that specifies some panel-specific structural markup.  When applyTo is used,
-     * constituent parts of the panel can be specified by CSS class name within the main element, and the panel
-     * will automatically create those components from that markup. Any required components not specified in the
-     * markup will be autogenerated if necessary.
-     * The following class names are supported (baseCls will be replaced by {@link #baseCls}):
-     * baseCls + '-header'
-     * baseCls + '-header-text'
-     * baseCls + '-bwrap'
-     * baseCls + '-tbar'
-     * baseCls + '-body'
-     * baseCls + '-bbar'
-     * baseCls + '-footer'
-     * Using this config, a call to render() is not required.  If applyTo is specified, any value passed for
-     * {@link #renderTo} will be ignored and the target element's parent node will automatically be used as the
-     * panel's container.
+     * Returns true if the specified action is defined as a unique action in the api-config.
+     * request.  If all API-actions are routed to unique urls, the xaction parameter is unecessary.  However, if no api is defined
+     * and all Proxy actions are routed to DataProxy#url, the server-side will require the xaction parameter to perform a switch to
+     * the corresponding code for CRUD action.
+     * @param {String [Ext.data.Api.CREATE|READ|UPDATE|DESTROY]} action
+     * @return {Boolean}
      */
+    isApiAction : function(action) {
+        return (this.api[action]) ? true : false;
+    },
+
     /**
-     * @cfg {Object/Array} tbar
-     * The top toolbar of the panel. This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of
-     * buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render.
-     * To access the top toolbar after render, use {@link #getTopToolbar}.
-     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
-     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
-     * so are not scanned to collect form items. However, the values will be submitted because form
-     * submission parameters are collected from the DOM tree.
+     * All proxy actions are executed through this method.  Automatically fires the "before" + action event
+     * @param {String} action Name of the action
+     * @param {Ext.data.Record/Ext.data.Record[]/null} rs Will be null when action is 'load'
+     * @param {Object} params
+     * @param {Ext.data.DataReader} reader
+     * @param {Function} callback
+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the Proxy object.
+     * @param {Object} options Any options specified for the action (e.g. see {@link Ext.data.Store#load}.
      */
+    request : function(action, rs, params, reader, callback, scope, options) {
+        if (!this.api[action] && !this.load) {
+            throw new Ext.data.DataProxy.Error('action-undefined', action);
+        }
+        params = params || {};
+        if ((action === Ext.data.Api.actions.read) ? this.fireEvent("beforeload", this, params) : this.fireEvent("beforewrite", this, action, rs, params) !== false) {
+            this.doRequest.apply(this, arguments);
+        }
+        else {
+            callback.call(scope || this, null, options, false);
+        }
+    },
+
+
     /**
-     * @cfg {Object/Array} bbar
-     * The bottom toolbar of the panel. This can be a {@link Ext.Toolbar} object, a toolbar config, or an array of
-     * buttons/button configs to be added to the toolbar.  Note that this is not available as a property after render.
-     * To access the bottom toolbar after render, use {@link #getBottomToolbar}.
-     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
-     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
-     * so are not scanned to collect form items. However, the values will be submitted because form
-     * submission parameters are collected from the DOM tree.
-     */
-    /** @cfg {Object/Array} fbar
-     * A {@link Ext.Toolbar Toolbar} object, a Toolbar config, or an array of
-     * {@link Ext.Button Button}s/{@link Ext.Button Button} configs, describing a {@link Ext.Toolbar Toolbar} to be rendered into this Panel's footer element.
-     * After render, the fbar property will be an {@link Ext.Toolbar Toolbar} instance.
-     * If {@link #buttons} are specified, they will supersede the fbar configuration property.
-     * The Panel's {@link #buttonAlign} configuration affects the layout of these items, for example:
-     * 
-var w = new Ext.Window({
-    height: 250,
-    width: 500,
-    bbar: new Ext.Toolbar({
-        items: [{
-            text: 'bbar Left'
-        },'->',{
-            text: 'bbar Right'
-        }]
-    }),
-    {@link #buttonAlign}: 'left', // anything but 'center' or 'right' and you can use '-', and '->'
-                                  // to control the alignment of fbar items
-    fbar: [{
-        text: 'fbar Left'
-    },'->',{
-        text: 'fbar Right'
-    }]
-}).show();
-     * 
-     * Note: Although a Toolbar may contain Field components, these will not be updated by a load
-     * of an ancestor FormPanel. A Panel's toolbars are not part of the standard Container->Component hierarchy, and
-     * so are not scanned to collect form items. However, the values will be submitted because form
-     * submission parameters are collected from the DOM tree.
+     * Deprecated load method using old method signature. See {@doRequest} for preferred method.
+     * @deprecated
+     * @param {Object} params
+     * @param {Object} reader
+     * @param {Object} callback
+     * @param {Object} scope
+     * @param {Object} arg
      */
+    load : null,
+
     /**
-     * @cfg {Boolean} header
-     * true to create the Panel's header element explicitly, false to skip creating
-     * it.  If a {@link #title} is set the header will be created automatically, otherwise it will not.
-     * If a {@link #title} is set but header is explicitly set to false, the header
-     * will not be rendered.
+     * @cfg {Function} doRequest Abstract method that should be implemented in all subclasses.  Note: Should only be used by custom-proxy developers.
+     * (e.g.: {@link Ext.data.HttpProxy#doRequest HttpProxy.doRequest},
+     * {@link Ext.data.DirectProxy#doRequest DirectProxy.doRequest}).
      */
+    doRequest : function(action, rs, params, reader, callback, scope, options) {
+        // default implementation of doRequest for backwards compatibility with 2.0 proxies.
+        // If we're executing here, the action is probably "load".
+        // Call with the pre-3.0 method signature.
+        this.load(params, reader, callback, scope, options);
+    },
+
     /**
-     * @cfg {Boolean} footer
-     * true to create the footer element explicitly, false to skip creating it. The footer
-     * will be created automatically if {@link #buttons} or a {@link #fbar} have
-     * been configured.  See {@link #bodyCfg} for an example.
+     * @cfg {Function} onRead Abstract method that should be implemented in all subclasses.  Note: Should only be used by custom-proxy developers.  Callback for read {@link Ext.data.Api#actions action}.
+     * @param {String} action Action name as per {@link Ext.data.Api.actions#read}.
+     * @param {Object} o The request transaction object
+     * @param {Object} res The server response
+     * @fires loadexception (deprecated)
+     * @fires exception
+     * @fires load
+     * @protected
      */
+    onRead : Ext.emptyFn,
     /**
-     * @cfg {String} title
-     * The title text to be used as innerHTML (html tags are accepted) to display in the panel
-     * {@link #header} (defaults to ''). When a title is specified the
-     * {@link #header} element will automatically be created and displayed unless
-     * {@link #header} is explicitly set to false.  If you do not want to specify a
-     * title at config time, but you may want one later, you must either specify a non-empty
-     * title (a blank space ' ' will do) or header:true so that the container
-     * element will get created.
+     * @cfg {Function} onWrite Abstract method that should be implemented in all subclasses.  Note: Should only be used by custom-proxy developers.  Callback for create, update and destroy {@link Ext.data.Api#actions actions}.
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @fires exception
+     * @fires write
+     * @protected
      */
+    onWrite : Ext.emptyFn,
     /**
-     * @cfg {Array} buttons
-     * buttons will be used as {@link Ext.Container#items items} for the toolbar in
-     * the footer ({@link #fbar}). Typically the value of this configuration property will be
-     * an array of {@link Ext.Button}s or {@link Ext.Button} configuration objects.
-     * If an item is configured with minWidth or the Panel is configured with minButtonWidth,
-     * that width will be applied to the item.
+     * buildUrl
+     * Sets the appropriate url based upon the action being executed.  If restful is true, and only a single record is being acted upon,
+     * url will be built Rails-style, as in "/controller/action/32".  restful will aply iff the supplied record is an
+     * instance of Ext.data.Record rather than an Array of them.
+     * @param {String} action The api action being executed [read|create|update|destroy]
+     * @param {Ext.data.Record/Ext.data.Record[]} record The record or Array of Records being acted upon.
+     * @return {String} url
+     * @private
      */
+    buildUrl : function(action, record) {
+        record = record || null;
+
+        // conn.url gets nullified after each request.  If it's NOT null here, that means the user must have intervened with a call
+        // to DataProxy#setUrl or DataProxy#setApi and changed it before the request was executed.  If that's the case, use conn.url,
+        // otherwise, build the url from the api or this.url.
+        var url = (this.conn && this.conn.url) ? this.conn.url : (this.api[action]) ? this.api[action].url : this.url;
+        if (!url) {
+            throw new Ext.data.Api.Error('invalid-url', action);
+        }
+
+        // look for urls having "provides" suffix used in some MVC frameworks like Rails/Merb and others.  The provides suffice informs
+        // the server what data-format the client is dealing with and returns data in the same format (eg: application/json, application/xml, etc)
+        // e.g.: /users.json, /users.xml, etc.
+        // with restful routes, we need urls like:
+        // PUT /users/1.json
+        // DELETE /users/1.json
+        var provides = null;
+        var m = url.match(/(.*)(\.json|\.xml|\.html)$/);
+        if (m) {
+            provides = m[2];    // eg ".json"
+            url      = m[1];    // eg: "/users"
+        }
+        // prettyUrls is deprectated in favor of restful-config
+        if ((this.restful === true || this.prettyUrls === true) && record instanceof Ext.data.Record && !record.phantom) {
+            url += '/' + record.id;
+        }
+        return (provides === null) ? url : url + provides;
+    },
+
     /**
-     * @cfg {Object/String/Function} autoLoad
-     * A valid url spec according to the Updater {@link Ext.Updater#update} method.
-     * If autoLoad is not null, the panel will attempt to load its contents
-     * immediately upon render.
-     * The URL will become the default URL for this panel's {@link #body} element,
-     * so it may be {@link Ext.Element#refresh refresh}ed at any time.
+     * Destroys the proxy by purging any event listeners and cancelling any active requests.
      */
-    /**
-     * @cfg {Boolean} frame
-     * false by default to render with plain 1px square borders. true to render with
-     * 9 elements, complete with custom rounded corners (also see {@link Ext.Element#boxWrap}).
-     * The template generated for each condition is depicted below:

-     *
-// frame = false
-<div id="developer-specified-id-goes-here" class="x-panel">
-
-    <div class="x-panel-header"><span class="x-panel-header-text">Title: (frame:false)</span></div>
+    destroy: function(){
+        this.purgeListeners();
+    }
+});
 
-    <div class="x-panel-bwrap">
-        <div class="x-panel-body"><p>html value goes here</p></div>
-    </div>
-</div>
+// Apply the Observable prototype to the DataProxy class so that proxy instances can relay their
+// events to the class.  Allows for centralized listening of all proxy instances upon the DataProxy class.
+Ext.apply(Ext.data.DataProxy, Ext.util.Observable.prototype);
+Ext.util.Observable.call(Ext.data.DataProxy);
 
-// frame = true (create 9 elements)
-<div id="developer-specified-id-goes-here" class="x-panel">
-    <div class="x-panel-tl"><div class="x-panel-tr"><div class="x-panel-tc">
-        <div class="x-panel-header"><span class="x-panel-header-text">Title: (frame:true)</span></div>
-    </div></div></div>
+/**
+ * @class Ext.data.DataProxy.Error
+ * @extends Ext.Error
+ * DataProxy Error extension.
+ * constructor
+ * @param {String} message Message describing the error.
+ * @param {Record/Record[]} arg
+ */
+Ext.data.DataProxy.Error = Ext.extend(Ext.Error, {
+    constructor : function(message, arg) {
+        this.arg = arg;
+        Ext.Error.call(this, message);
+    },
+    name: 'Ext.data.DataProxy'
+});
+Ext.apply(Ext.data.DataProxy.Error.prototype, {
+    lang: {
+        'action-undefined': "DataProxy attempted to execute an API-action but found an undefined url / function.  Please review your Proxy url/api-configuration.",
+        'api-invalid': 'Recieved an invalid API-configuration.  Please ensure your proxy API-configuration contains only the actions from Ext.data.Api.actions.'
+    }
+});
 
-    <div class="x-panel-bwrap">
-        <div class="x-panel-ml"><div class="x-panel-mr"><div class="x-panel-mc">
-            <div class="x-panel-body"><p>html value goes here</p></div>
-        </div></div></div>
 
-        <div class="x-panel-bl"><div class="x-panel-br"><div class="x-panel-bc"/>
-        </div></div></div>
-</div>
-     * 
+/**
+ * @class Ext.data.Request
+ * A simple Request class used internally to the data package to provide more generalized remote-requests
+ * to a DataProxy.
+ * TODO Not yet implemented.  Implement in Ext.data.Store#execute
+ */
+Ext.data.Request = function(params) {
+    Ext.apply(this, params);
+};
+Ext.data.Request.prototype = {
+    /**
+     * @cfg {String} action
      */
+    action : undefined,
     /**
-     * @cfg {Boolean} border
-     * True to display the borders of the panel's body element, false to hide them (defaults to true).  By default,
-     * the border is a 2px wide inset border, but this can be further altered by setting {@link #bodyBorder} to false.
+     * @cfg {Ext.data.Record[]/Ext.data.Record} rs The Store recordset associated with the request.
      */
+    rs : undefined,
     /**
-     * @cfg {Boolean} bodyBorder
-     * True to display an interior border on the body element of the panel, false to hide it (defaults to true).
-     * This only applies when {@link #border} == true.  If border == true and bodyBorder == false, the border will display
-     * as a 1px wide inset border, giving the entire body element an inset appearance.
+     * @cfg {Object} params HTTP request params
      */
+    params: undefined,
     /**
-     * @cfg {String/Object/Function} bodyCssClass
-     * Additional css class selector to be applied to the {@link #body} element in the format expected by
-     * {@link Ext.Element#addClass} (defaults to null). See {@link #bodyCfg}.
+     * @cfg {Function} callback The function to call when request is complete
      */
+    callback : Ext.emptyFn,
     /**
-     * @cfg {String/Object/Function} bodyStyle
-     * Custom CSS styles to be applied to the {@link #body} element in the format expected by
-     * {@link Ext.Element#applyStyles} (defaults to null). See {@link #bodyCfg}.
+     * @cfg {Object} scope The scope of the callback funtion
      */
+    scope : undefined,
     /**
-     * @cfg {String} iconCls
-     * The CSS class selector that specifies a background image to be used as the header icon (defaults to '').
-     * An example of specifying a custom icon class would be something like:
-     * 

-// specify the property in the config for the class:
-     ...
-     iconCls: 'my-icon'
-
-// css class that specifies background image to be used as the icon image:
-.my-icon { background-image: url(../images/my-icon.gif) 0 6px no-repeat !important; }
-
+     * @cfg {Ext.data.DataReader} reader The DataReader instance which will parse the received response
      */
+    reader : undefined
+};
+/**
+ * @class Ext.data.Response
+ * A generic response class to normalize response-handling internally to the framework.
+ */
+Ext.data.Response = function(params) {
+    Ext.apply(this, params);
+};
+Ext.data.Response.prototype = {
     /**
-     * @cfg {Boolean} collapsible
-     * True to make the panel collapsible and have the expand/collapse toggle button automatically rendered into
-     * the header tool button area, false to keep the panel statically sized with no button (defaults to false).
+     * @cfg {String} action {@link Ext.data.Api#actions}
      */
+    action: undefined,
     /**
-     * @cfg {Array} tools
-     * An array of tool button configs to be added to the header tool area. When rendered, each tool is
-     * stored as an {@link Ext.Element Element} referenced by a public property called tools.<tool-type>
-     * Each tool config may contain the following properties:
-     * 

-     * id : StringRequired. The type
-     * of tool to create. By default, this assigns a CSS class of the form x-tool-<tool-type> to the
-     * resulting tool Element. Ext provides CSS rules, and an icon sprite containing images for the tool types listed below.
-     * The developer may implement custom tools by supplying alternate CSS rules and background images:
-     * 
-     *  
 toggle (Created by default when {@link #collapsible} is true)
-     *  
 close
-     *  
 minimize
-     *  
 maximize
-     *  
 restore
-     *  
 gear
-     *  
 pin
-     *  
 unpin
-     *  
 right
-     *  
 left
-     *  
 up
-     *  
 down
-     *  
 refresh
-     *  
 minus
-     *  
 plus
-     *  
 help
-     *  
 search
-     *  
 save
-     *  
 print
-     * 
-     * handler : FunctionRequired. The function to
-     * call when clicked. Arguments passed are:
-     * event : Ext.EventObjectThe click event.
-     * toolEl : Ext.ElementThe tool Element.
-     * panel : Ext.PanelThe host Panel
-     * tc : ObjectThe tool configuration object
-     * 
-     * stopEvent : BooleanDefaults to true. Specify as false to allow click event to propagate.
-     * scope : ObjectThe scope in which to call the handler.
-     * qtip : String/ObjectA tip string, or
-     * a config argument to {@link Ext.QuickTip#register}
-     * hidden : BooleanTrue to initially render hidden.
-     * on : ObjectA listener config object specifiying
-     * event listeners in the format of an argument to {@link #addListener}
-     * 
-     * Note that, apart from the toggle tool which is provided when a panel is collapsible, these
-     * tools only provide the visual button. Any required functionality must be provided by adding
-     * handlers that implement the necessary behavior.
-     * Example usage:
-     * 
-tools:[{
-    id:'refresh',
-    qtip: 'Refresh form Data',
-    // hidden:true,
-    handler: function(event, toolEl, panel){
-        // refresh logic
-    }
-},
-{
-    id:'help',
-    qtip: 'Get Help',
-    handler: function(event, toolEl, panel){
-        // whatever
-    }
-}]
-
-     * For the custom id of 'help' define two relevant css classes with a link to
-     * a 15x15 image:
-     * 
-.x-tool-help {background-image: url(images/help.png);}
-.x-tool-help-over {background-image: url(images/help_over.png);}
-// if using an image sprite:
-.x-tool-help {background-image: url(images/help.png) no-repeat 0 0;}
-.x-tool-help-over {background-position:-15px 0;}
-
+     * @cfg {Boolean} success
      */
+    success : undefined,
     /**
-     * @cfg {Ext.Template/Ext.XTemplate} toolTemplate
-     * A Template used to create {@link #tools} in the {@link #header} Element. Defaults to:

-new Ext.Template('<div class="x-tool x-tool-{id}">&#160;</div>')
-     * This may may be overridden to provide a custom DOM structure for tools based upon a more
-     * complex XTemplate. The template's data is a single tool configuration object (Not the entire Array)
-     * as specified in {@link #tools}.  In the following example an <a> tag is used to provide a
-     * visual indication when hovering over the tool:

-var win = new Ext.Window({
-    tools: [{
-        id: 'download',
-        href: '/MyPdfDoc.pdf'
-    }],
-    toolTemplate: new Ext.XTemplate(
-        '<tpl if="id==\'download\'">',
-            '<a class="x-tool x-tool-pdf" href="{href}"></a>',
-        '</tpl>',
-        '<tpl if="id!=\'download\'">',
-            '<div class="x-tool x-tool-{id}">&#160;</div>',
-        '</tpl>'
-    ),
-    width:500,
-    height:300,
-    closeAction:'hide'
-});
-     * Note that the CSS class 'x-tool-pdf' should have an associated style rule which provides an
-     * appropriate background image, something like:
-    
-    a.x-tool-pdf {background-image: url(../shared/extjs/images/pdf.gif)!important;}
-    
+     * @cfg {String} message
      */
+    message : undefined,
     /**
-     * @cfg {Boolean} hideCollapseTool
-     * true to hide the expand/collapse toggle button when {@link #collapsible} == true,
-     * false to display it (defaults to false).
+     * @cfg {Array/Object} data
      */
+    data: undefined,
     /**
-     * @cfg {Boolean} titleCollapse
-     * true to allow expanding and collapsing the panel (when {@link #collapsible} = true)
-     * by clicking anywhere in the header bar, false) to allow it only by clicking to tool button
-     * (defaults to false)). If this panel is a child item of a border layout also see the
-     * {@link Ext.layout.BorderLayout.Region BorderLayout.Region}
-     * {@link Ext.layout.BorderLayout.Region#floatable floatable} config option.
+     * @cfg {Object} raw The raw response returned from server-code
      */
-
+    raw: undefined,
     /**
-     * @cfg {Mixed} floating
-     * This property is used to configure the underlying {@link Ext.Layer}. Acceptable values for this
-     * configuration property are:

-     * false : Default.Display the panel inline where it is
-     * rendered.
-     * true : Float the panel (absolute position it with automatic
-     * shimming and shadow).
-     * Setting floating to true will create an Ext.Layer for this panel and display the
-     * panel at negative offsets so that it is hidden.
-     * Since the panel will be absolute positioned, the position must be set explicitly
-     * after render (e.g., myPanel.setPosition(100,100);).
-     * Note: when floating a panel you should always assign a fixed width,
-     * otherwise it will be auto width and will expand to fill to the right edge of the viewport.
-     * 
-     * {@link Ext.Layer object} : The specified object will be used
-     * as the configuration object for the {@link Ext.Layer} that will be created.
-     * 
+     * @cfg {Ext.data.Record/Ext.data.Record[]} records related to the Request action
+     */
+    records: undefined
+};
+/**
+ * @class Ext.data.ScriptTagProxy
+ * @extends Ext.data.DataProxy
+ * An implementation of Ext.data.DataProxy that reads a data object from a URL which may be in a domain
+ * other than the originating domain of the running page.

+ * 
+ * Note that if you are retrieving data from a page that is in a domain that is NOT the same as the originating domain
+ * of the running page, you must use this class, rather than HttpProxy.

+ * 

+ * The content passed back from a server resource requested by a ScriptTagProxy must be executable JavaScript
+ * source code because it is used as the source inside a <script> tag.

+ * 

+ * In order for the browser to process the returned data, the server must wrap the data object
+ * with a call to a callback function, the name of which is passed as a parameter by the ScriptTagProxy.
+ * Below is a Java example for a servlet which returns data for either a ScriptTagProxy, or an HttpProxy
+ * depending on whether the callback name was passed:
+ * 

+ * 

+boolean scriptTag = false;
+String cb = request.getParameter("callback");
+if (cb != null) {
+    scriptTag = true;
+    response.setContentType("text/javascript");
+} else {
+    response.setContentType("application/x-json");
+}
+Writer out = response.getWriter();
+if (scriptTag) {
+    out.write(cb + "(");
+}
+out.print(dataBlock.toJsonString());
+if (scriptTag) {
+    out.write(");");
+}
+
+ * Below is a PHP example to do the same thing:

+$callback = $_REQUEST['callback'];
+
+// Create the output object.
+$output = array('a' => 'Apple', 'b' => 'Banana');
+
+//start output
+if ($callback) {
+    header('Content-Type: text/javascript');
+    echo $callback . '(' . json_encode($output) . ');';
+} else {
+    header('Content-Type: application/x-json');
+    echo json_encode($output);
+}
+
+ * Below is the ASP.Net code to do the same thing:

+String jsonString = "{success: true}";
+String cb = Request.Params.Get("callback");
+String responseString = "";
+if (!String.IsNullOrEmpty(cb)) {
+    responseString = cb + "(" + jsonString + ")";
+} else {
+    responseString = jsonString;
+}
+Response.Write(responseString);
+
+ *
+ * @constructor
+ * @param {Object} config A configuration object.
+ */
+Ext.data.ScriptTagProxy = function(config){
+    Ext.apply(this, config);
+
+    Ext.data.ScriptTagProxy.superclass.constructor.call(this, config);
+
+    this.head = document.getElementsByTagName("head")[0];
+
+    /**
+     * @event loadexception
+     * Deprecated in favor of 'exception' event.
+     * Fires if an exception occurs in the Proxy during data loading.  This event can be fired for one of two reasons:
+     * The load call timed out.  This means the load callback did not execute within the time limit
+     * specified by {@link #timeout}.  In this case, this event will be raised and the
+     * fourth parameter (read error) will be null.
+     * The load succeeded but the reader could not read the response.  This means the server returned
+     * data, but the configured Reader threw an error while reading the data.  In this case, this event will be
+     * raised and the caught error will be passed along as the fourth parameter of this event.
+     * Note that this event is also relayed through {@link Ext.data.Store}, so you can listen for it directly
+     * on any Store instance.
+     * @param {Object} this
+     * @param {Object} options The loading options that were specified (see {@link #load} for details).  If the load
+     * call timed out, this parameter will be null.
+     * @param {Object} arg The callback's arg object passed to the {@link #load} function
+     * @param {Error} e The JavaScript Error object caught if the configured Reader could not read the data.
+     * If the remote request returns success: false, this parameter will be null.
      */
+};
+
+Ext.data.ScriptTagProxy.TRANS_ID = 1000;
+
+Ext.extend(Ext.data.ScriptTagProxy, Ext.data.DataProxy, {
     /**
-     * @cfg {Boolean/String} shadow
-     * true (or a valid Ext.Shadow {@link Ext.Shadow#mode} value) to display a shadow behind the
-     * panel, false to display no shadow (defaults to 'sides').  Note that this option
-     * only applies when {@link #floating} = true.
+     * @cfg {String} url The URL from which to request the data object.
      */
     /**
-     * @cfg {Number} shadowOffset
-     * The number of pixels to offset the shadow if displayed (defaults to 4). Note that this
-     * option only applies when {@link #floating} = true.
+     * @cfg {Number} timeout (optional) The number of milliseconds to wait for a response. Defaults to 30 seconds.
      */
+    timeout : 30000,
     /**
-     * @cfg {Boolean} shim
-     * false to disable the iframe shim in browsers which need one (defaults to true).
-     * Note that this option only applies when {@link #floating} = true.
+     * @cfg {String} callbackParam (Optional) The name of the parameter to pass to the server which tells
+     * the server the name of the callback function set up by the load call to process the returned data object.
+     * Defaults to "callback".The server-side processing must read this parameter value, and generate
+     * javascript output which calls this named function passing the data object as its only parameter.
      */
+    callbackParam : "callback",
     /**
-     * @cfg {Object/Array} keys
-     * A {@link Ext.KeyMap} config object (in the format expected by {@link Ext.KeyMap#addBinding}
-     * used to assign custom key handling to this panel (defaults to null).
+     *  @cfg {Boolean} nocache (optional) Defaults to true. Disable caching by adding a unique parameter
+     * name to the request.
      */
+    nocache : true,
+
     /**
-     * @cfg {Boolean/Object} draggable
-     * 
true to enable dragging of this Panel (defaults to false).
-     * For custom drag/drop implementations, an Ext.Panel.DD config could also be passed
-     * in this config instead of true. Ext.Panel.DD is an internal, undocumented class which
-     * moves a proxy Element around in place of the Panel's element, but provides no other behaviour
-     * during dragging or on drop. It is a subclass of {@link Ext.dd.DragSource}, so behaviour may be
-     * added by implementing the interface methods of {@link Ext.dd.DragDrop} e.g.:
-     * 

-new Ext.Panel({
-    title: 'Drag me',
-    x: 100,
-    y: 100,
-    renderTo: Ext.getBody(),
-    floating: true,
-    frame: true,
-    width: 400,
-    height: 200,
-    draggable: {
-//      Config option of Ext.Panel.DD class.
-//      It's a floating Panel, so do not show a placeholder proxy in the original position.
-        insertProxy: false,
+     * HttpProxy implementation of DataProxy#doRequest
+     * @param {String} action
+     * @param {Ext.data.Record/Ext.data.Record[]} rs If action is read, rs will be null
+     * @param {Object} params An object containing properties which are to be used as HTTP parameters
+     * for the request to the remote server.
+     * @param {Ext.data.DataReader} reader The Reader object which converts the data
+     * object into a block of Ext.data.Records.
+     * @param {Function} callback The function into which to pass the block of Ext.data.Records.
+     * The function must be passed 
+     * The Record block object
+     * The "arg" argument from the load function
+     * A boolean success indicator
+     * 
+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window.
+     * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
+     */
+    doRequest : function(action, rs, params, reader, callback, scope, arg) {
+        var p = Ext.urlEncode(Ext.apply(params, this.extraParams));
 
-//      Called for each mousemove event while dragging the DD object.
-        onDrag : function(e){
-//          Record the x,y position of the drag proxy so that we can
-//          position the Panel at end of drag.
-            var pel = this.proxy.getEl();
-            this.x = pel.getLeft(true);
-            this.y = pel.getTop(true);
+        var url = this.buildUrl(action, rs);
+        if (!url) {
+            throw new Ext.data.Api.Error('invalid-url', url);
+        }
+        url = Ext.urlAppend(url, p);
 
-//          Keep the Shadow aligned if there is one.
-            var s = this.panel.getEl().shadow;
-            if (s) {
-                s.realign(this.x, this.y, pel.getWidth(), pel.getHeight());
+        if(this.nocache){
+            url = Ext.urlAppend(url, '_dc=' + (new Date().getTime()));
+        }
+        var transId = ++Ext.data.ScriptTagProxy.TRANS_ID;
+        var trans = {
+            id : transId,
+            action: action,
+            cb : "stcCallback"+transId,
+            scriptId : "stcScript"+transId,
+            params : params,
+            arg : arg,
+            url : url,
+            callback : callback,
+            scope : scope,
+            reader : reader
+        };
+        window[trans.cb] = this.createCallback(action, rs, trans);
+        url += String.format("&{0}={1}", this.callbackParam, trans.cb);
+        if(this.autoAbort !== false){
+            this.abort();
+        }
+
+        trans.timeoutId = this.handleFailure.defer(this.timeout, this, [trans]);
+
+        var script = document.createElement("script");
+        script.setAttribute("src", url);
+        script.setAttribute("type", "text/javascript");
+        script.setAttribute("id", trans.scriptId);
+        this.head.appendChild(script);
+
+        this.trans = trans;
+    },
+
+    // @private createCallback
+    createCallback : function(action, rs, trans) {
+        var self = this;
+        return function(res) {
+            self.trans = false;
+            self.destroyTrans(trans, true);
+            if (action === Ext.data.Api.actions.read) {
+                self.onRead.call(self, action, trans, res);
+            } else {
+                self.onWrite.call(self, action, trans, res, rs);
             }
-        },
+        };
+    },
+    /**
+     * Callback for read actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @protected
+     */
+    onRead : function(action, trans, res) {
+        var result;
+        try {
+            result = trans.reader.readRecords(res);
+        }catch(e){
+            // @deprecated: fire loadexception
+            this.fireEvent("loadexception", this, trans, res, e);
 
-//      Called on the mouseup event.
-        endDrag : function(e){
-            this.panel.setPosition(this.x, this.y);
+            this.fireEvent('exception', this, 'response', action, trans, res, e);
+            trans.callback.call(trans.scope||window, null, trans.arg, false);
+            return;
         }
-    }
-}).show();
-
-     */
-    /**
-     * @cfg {Boolean} disabled
-     * Render this panel disabled (default is false). An important note when using the disabled
-     * config on panels is that IE will often fail to initialize the disabled mask element correectly if
-     * the panel's layout has not yet completed by the time the Panel is disabled during the render process.
-     * If you experience this issue, you may need to instead use the {@link #afterlayout} event to initialize
-     * the disabled state:
-     * 
-new Ext.Panel({
-    ...
-    listeners: {
-        'afterlayout': {
-            fn: function(p){
-                p.disable();
-            },
-            single: true // important, as many layouts can occur
+        if (result.success === false) {
+            // @deprecated: fire old loadexception for backwards-compat.
+            this.fireEvent('loadexception', this, trans, res);
+
+            this.fireEvent('exception', this, 'remote', action, trans, res, null);
+        } else {
+            this.fireEvent("load", this, res, trans.arg);
         }
-    }
-});
-
+        trans.callback.call(trans.scope||window, result, trans.arg, result.success);
+    },
+    /**
+     * Callback for write actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @protected
      */
+    onWrite : function(action, trans, response, rs) {
+        var reader = trans.reader;
+        try {
+            // though we already have a response object here in STP, run through readResponse to catch any meta-data exceptions.
+            var res = reader.readResponse(action, response);
+        } catch (e) {
+            this.fireEvent('exception', this, 'response', action, trans, res, e);
+            trans.callback.call(trans.scope||window, null, res, false);
+            return;
+        }
+        if(!res.success === true){
+            this.fireEvent('exception', this, 'remote', action, trans, res, rs);
+            trans.callback.call(trans.scope||window, null, res, false);
+            return;
+        }
+        this.fireEvent("write", this, action, res.data, res, rs, trans.arg );
+        trans.callback.call(trans.scope||window, res.data, res, true);
+    },
+
+    // private
+    isLoading : function(){
+        return this.trans ? true : false;
+    },
+
     /**
-     * @cfg {Boolean} autoHeight
-     * true to use height:'auto', false to use fixed height (defaults to false).
-     * Note: Setting autoHeight: true means that the browser will manage the panel's height
-     * based on its contents, and that Ext will not manage it at all. If the panel is within a layout that
-     * manages dimensions (fit, border, etc.) then setting autoHeight: true
-     * can cause issues with scrolling and will not generally work as expected since the panel will take
-     * on the height of its contents rather than the height required by the Ext layout.
+     * Abort the current server request.
      */
+    abort : function(){
+        if(this.isLoading()){
+            this.destroyTrans(this.trans);
+        }
+    },
+
+    // private
+    destroyTrans : function(trans, isLoaded){
+        this.head.removeChild(document.getElementById(trans.scriptId));
+        clearTimeout(trans.timeoutId);
+        if(isLoaded){
+            window[trans.cb] = undefined;
+            try{
+                delete window[trans.cb];
+            }catch(e){}
+        }else{
+            // if hasn't been loaded, wait for load to remove it to prevent script error
+            window[trans.cb] = function(){
+                window[trans.cb] = undefined;
+                try{
+                    delete window[trans.cb];
+                }catch(e){}
+            };
+        }
+    },
+
+    // private
+    handleFailure : function(trans){
+        this.trans = false;
+        this.destroyTrans(trans, false);
+        if (trans.action === Ext.data.Api.actions.read) {
+            // @deprecated firing loadexception
+            this.fireEvent("loadexception", this, null, trans.arg);
+        }
 
+        this.fireEvent('exception', this, 'response', trans.action, {
+            response: null,
+            options: trans.arg
+        });
+        trans.callback.call(trans.scope||window, null, trans.arg, false);
+    },
+
+    // inherit docs
+    destroy: function(){
+        this.abort();
+        Ext.data.ScriptTagProxy.superclass.destroy.call(this);
+    }
+});/**
+ * @class Ext.data.HttpProxy
+ * @extends Ext.data.DataProxy
+ * An implementation of {@link Ext.data.DataProxy} that processes data requests within the same
+ * domain of the originating page.
+ * Note: this class cannot be used to retrieve data from a domain other
+ * than the domain from which the running page was served. For cross-domain requests, use a
+ * {@link Ext.data.ScriptTagProxy ScriptTagProxy}.
+ * Be aware that to enable the browser to parse an XML document, the server must set
+ * the Content-Type header in the HTTP response to "text/xml".
+ * @constructor
+ * @param {Object} conn
+ * An {@link Ext.data.Connection} object, or options parameter to {@link Ext.Ajax#request}.
+ * Note that if this HttpProxy is being used by a {@link Ext.data.Store Store}, then the
+ * Store's call to {@link #load} will override any specified callback and params
+ * options. In this case, use the Store's {@link Ext.data.Store#events events} to modify parameters,
+ * or react to loading events. The Store's {@link Ext.data.Store#baseParams baseParams} may also be
+ * used to pass parameters known at instantiation time.
+ * If an options parameter is passed, the singleton {@link Ext.Ajax} object will be used to make
+ * the request.
+ */
+Ext.data.HttpProxy = function(conn){
+    Ext.data.HttpProxy.superclass.constructor.call(this, conn);
 
     /**
-     * @cfg {String} baseCls
-     * The base CSS class to apply to this panel's element (defaults to 'x-panel').
-     * Another option available by default is to specify 'x-plain' which strips all styling
-     * except for required attributes for Ext layouts to function (e.g. overflow:hidden).
-     * See {@link #unstyled} also.
+     * The Connection object (Or options parameter to {@link Ext.Ajax#request}) which this HttpProxy
+     * uses to make requests to the server. Properties of this object may be changed dynamically to
+     * change the way data is requested.
+     * @property
      */
-    baseCls : 'x-panel',
+    this.conn = conn;
+
+    // nullify the connection url.  The url param has been copied to 'this' above.  The connection
+    // url will be set during each execution of doRequest when buildUrl is called.  This makes it easier for users to override the
+    // connection url during beforeaction events (ie: beforeload, beforewrite, etc).
+    // Url is always re-defined during doRequest.
+    this.conn.url = null;
+
+    this.useAjax = !conn || !conn.events;
+
+    // A hash containing active requests, keyed on action [Ext.data.Api.actions.create|read|update|destroy]
+    var actions = Ext.data.Api.actions;
+    this.activeRequest = {};
+    for (var verb in actions) {
+        this.activeRequest[actions[verb]] = undefined;
+    }
+};
+
+Ext.extend(Ext.data.HttpProxy, Ext.data.DataProxy, {
     /**
-     * @cfg {String} collapsedCls
-     * A CSS class to add to the panel's element after it has been collapsed (defaults to
-     * 'x-panel-collapsed').
+     * Return the {@link Ext.data.Connection} object being used by this Proxy.
+     * @return {Connection} The Connection object. This object may be used to subscribe to events on
+     * a finer-grained basis than the DataProxy events.
      */
-    collapsedCls : 'x-panel-collapsed',
+    getConnection : function() {
+        return this.useAjax ? Ext.Ajax : this.conn;
+    },
+
     /**
-     * @cfg {Boolean} maskDisabled
-     * true to mask the panel when it is {@link #disabled}, false to not mask it (defaults
-     * to true).  Either way, the panel will always tell its contained elements to disable themselves
-     * when it is disabled, but masking the panel can provide an additional visual cue that the panel is
-     * disabled.
+     * Used for overriding the url used for a single request.  Designed to be called during a beforeaction event.  Calling setUrl
+     * will override any urls set via the api configuration parameter.  Set the optional parameter makePermanent to set the url for
+     * all subsequent requests.  If not set to makePermanent, the next request will use the same url or api configuration defined
+     * in the initial proxy configuration.
+     * @param {String} url
+     * @param {Boolean} makePermanent (Optional) [false]
+     *
+     * (e.g.: beforeload, beforesave, etc).
      */
-    maskDisabled : true,
+    setUrl : function(url, makePermanent) {
+        this.conn.url = url;
+        if (makePermanent === true) {
+            this.url = url;
+            this.api = null;
+            Ext.data.Api.prepare(this);
+        }
+    },
+
     /**
-     * @cfg {Boolean} animCollapse
-     * true to animate the transition when the panel is collapsed, false to skip the
-     * animation (defaults to true if the {@link Ext.Fx} class is available, otherwise false).
+     * HttpProxy implementation of DataProxy#doRequest
+     * @param {String} action The crud action type (create, read, update, destroy)
+     * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null
+     * @param {Object} params An object containing properties which are to be used as HTTP parameters
+     * for the request to the remote server.
+     * @param {Ext.data.DataReader} reader The Reader object which converts the data
+     * object into a block of Ext.data.Records.
+     * @param {Function} callback
+     * A function to be called after the request.
+     * The callback is passed the following arguments:

+     * r : Ext.data.Record[] The block of Ext.data.Records.
+     * options: Options object from the action request
+     * success: Boolean success indicator

+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window.
+     * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
+     * @protected
      */
-    animCollapse : Ext.enableFx,
+    doRequest : function(action, rs, params, reader, cb, scope, arg) {
+        var  o = {
+            method: (this.api[action]) ? this.api[action]['method'] : undefined,
+            request: {
+                callback : cb,
+                scope : scope,
+                arg : arg
+            },
+            reader: reader,
+            callback : this.createCallback(action, rs),
+            scope: this
+        };
+
+        // If possible, transmit data using jsonData || xmlData on Ext.Ajax.request (An installed DataWriter would have written it there.).
+        // Use std HTTP params otherwise.
+        if (params.jsonData) {
+            o.jsonData = params.jsonData;
+        } else if (params.xmlData) {
+            o.xmlData = params.xmlData;
+        } else {
+            o.params = params || {};
+        }
+        // Set the connection url.  If this.conn.url is not null here,
+        // the user must have overridden the url during a beforewrite/beforeload event-handler.
+        // this.conn.url is nullified after each request.
+        this.conn.url = this.buildUrl(action, rs);
+
+        if(this.useAjax){
+
+            Ext.applyIf(o, this.conn);
+
+            // If a currently running request is found for this action, abort it.
+            if (this.activeRequest[action]) {
+                ////
+                // Disabled aborting activeRequest while implementing REST.  activeRequest[action] will have to become an array
+                // TODO ideas anyone?
+                //
+                //Ext.Ajax.abort(this.activeRequest[action]);
+            }
+            this.activeRequest[action] = Ext.Ajax.request(o);
+        }else{
+            this.conn.request(o);
+        }
+        // request is sent, nullify the connection url in preparation for the next request
+        this.conn.url = null;
+    },
+
     /**
-     * @cfg {Boolean} headerAsText
-     * true to display the panel {@link #title} in the {@link #header},
-     * false to hide it (defaults to true).
+     * Returns a callback function for a request.  Note a special case is made for the
+     * read action vs all the others.
+     * @param {String} action [create|update|delete|load]
+     * @param {Ext.data.Record[]} rs The Store-recordset being acted upon
+     * @private
      */
-    headerAsText : true,
+    createCallback : function(action, rs) {
+        return function(o, success, response) {
+            this.activeRequest[action] = undefined;
+            if (!success) {
+                if (action === Ext.data.Api.actions.read) {
+                    // @deprecated: fire loadexception for backwards compat.
+                    // TODO remove
+                    this.fireEvent('loadexception', this, o, response);
+                }
+                this.fireEvent('exception', this, 'response', action, o, response);
+                o.request.callback.call(o.request.scope, null, o.request.arg, false);
+                return;
+            }
+            if (action === Ext.data.Api.actions.read) {
+                this.onRead(action, o, response);
+            } else {
+                this.onWrite(action, o, response, rs);
+            }
+        };
+    },
+
     /**
-     * @cfg {String} buttonAlign
-     * The alignment of any {@link #buttons} added to this panel.  Valid values are 'right',
-     * 'left' and 'center' (defaults to 'right').
+     * Callback for read action
+     * @param {String} action Action name as per {@link Ext.data.Api.actions#read}.
+     * @param {Object} o The request transaction object
+     * @param {Object} res The server response
+     * @fires loadexception (deprecated)
+     * @fires exception
+     * @fires load
+     * @protected
      */
-    buttonAlign : 'right',
+    onRead : function(action, o, response) {
+        var result;
+        try {
+            result = o.reader.read(response);
+        }catch(e){
+            // @deprecated: fire old loadexception for backwards-compat.
+            // TODO remove
+            this.fireEvent('loadexception', this, o, response, e);
+
+            this.fireEvent('exception', this, 'response', action, o, response, e);
+            o.request.callback.call(o.request.scope, null, o.request.arg, false);
+            return;
+        }
+        if (result.success === false) {
+            // @deprecated: fire old loadexception for backwards-compat.
+            // TODO remove
+            this.fireEvent('loadexception', this, o, response);
+
+            // Get DataReader read-back a response-object to pass along to exception event
+            var res = o.reader.readResponse(action, response);
+            this.fireEvent('exception', this, 'remote', action, o, res, null);
+        }
+        else {
+            this.fireEvent('load', this, o, o.request.arg);
+        }
+        // TODO refactor onRead, onWrite to be more generalized now that we're dealing with Ext.data.Response instance
+        // the calls to request.callback(...) in each will have to be made identical.
+        // NOTE reader.readResponse does not currently return Ext.data.Response
+        o.request.callback.call(o.request.scope, result, o.request.arg, result.success);
+    },
     /**
-     * @cfg {Boolean} collapsed
-     * true to render the panel collapsed, false to render it expanded (defaults to
-     * false).
+     * Callback for write actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} res The server response
+     * @fires exception
+     * @fires write
+     * @protected
      */
-    collapsed : false,
+    onWrite : function(action, o, response, rs) {
+        var reader = o.reader;
+        var res;
+        try {
+            res = reader.readResponse(action, response);
+        } catch (e) {
+            this.fireEvent('exception', this, 'response', action, o, response, e);
+            o.request.callback.call(o.request.scope, null, o.request.arg, false);
+            return;
+        }
+        if (res.success === true) {
+            this.fireEvent('write', this, action, res.data, res, rs, o.request.arg);
+        } else {
+            this.fireEvent('exception', this, 'remote', action, o, res, rs);
+        }
+        // TODO refactor onRead, onWrite to be more generalized now that we're dealing with Ext.data.Response instance
+        // the calls to request.callback(...) in each will have to be made similar.
+        // NOTE reader.readResponse does not currently return Ext.data.Response
+        o.request.callback.call(o.request.scope, res.data, res, res.success);
+    },
+
+    // inherit docs
+    destroy: function(){
+        if(!this.useAjax){
+            this.conn.abort();
+        }else if(this.activeRequest){
+            var actions = Ext.data.Api.actions;
+            for (var verb in actions) {
+                if(this.activeRequest[actions[verb]]){
+                    Ext.Ajax.abort(this.activeRequest[actions[verb]]);
+                }
+            }
+        }
+        Ext.data.HttpProxy.superclass.destroy.call(this);
+    }
+});/**
+ * @class Ext.data.MemoryProxy
+ * @extends Ext.data.DataProxy
+ * An implementation of Ext.data.DataProxy that simply passes the data specified in its constructor
+ * to the Reader when its load method is called.
+ * @constructor
+ * @param {Object} data The data object which the Reader uses to construct a block of Ext.data.Records.
+ */
+Ext.data.MemoryProxy = function(data){
+    // Must define a dummy api with "read" action to satisfy DataProxy#doRequest and Ext.data.Api#prepare *before* calling super
+    var api = {};
+    api[Ext.data.Api.actions.read] = true;
+    Ext.data.MemoryProxy.superclass.constructor.call(this, {
+        api: api
+    });
+    this.data = data;
+};
+
+Ext.extend(Ext.data.MemoryProxy, Ext.data.DataProxy, {
     /**
-     * @cfg {Boolean} collapseFirst
-     * true to make sure the collapse/expand toggle button always renders first (to the left of)
-     * any other tools in the panel's title bar, false to render it last (defaults to true).
+     * @event loadexception
+     * Fires if an exception occurs in the Proxy during data loading. Note that this event is also relayed
+     * through {@link Ext.data.Store}, so you can listen for it directly on any Store instance.
+     * @param {Object} this
+     * @param {Object} arg The callback's arg object passed to the {@link #load} function
+     * @param {Object} null This parameter does not apply and will always be null for MemoryProxy
+     * @param {Error} e The JavaScript Error object caught if the configured Reader could not read the data
      */
-    collapseFirst : true,
+
+       /**
+     * MemoryProxy implementation of DataProxy#doRequest
+     * @param {String} action
+     * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null
+     * @param {Object} params An object containing properties which are to be used as HTTP parameters
+     * for the request to the remote server.
+     * @param {Ext.data.DataReader} reader The Reader object which converts the data
+     * object into a block of Ext.data.Records.
+     * @param {Function} callback The function into which to pass the block of Ext.data.Records.
+     * The function must be passed 
+     * The Record block object
+     * The "arg" argument from the load function
+     * A boolean success indicator
+     * 
+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window.
+     * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
+     */
+    doRequest : function(action, rs, params, reader, callback, scope, arg) {
+        // No implementation for CRUD in MemoryProxy.  Assumes all actions are 'load'
+        params = params || {};
+        var result;
+        try {
+            result = reader.readRecords(this.data);
+        }catch(e){
+            // @deprecated loadexception
+            this.fireEvent("loadexception", this, null, arg, e);
+
+            this.fireEvent('exception', this, 'response', action, arg, null, e);
+            callback.call(scope, null, arg, false);
+            return;
+        }
+        callback.call(scope, result, arg, true);
+    }
+});/**
+ * @class Ext.data.Types
+ * This is s static class containing the system-supplied data types which may be given to a {@link Ext.data.Field Field}.

+ * 
The properties in this class are used as type indicators in the {@link Ext.data.Field Field} class, so to
+ * test whether a Field is of a certain type, compare the {@link Ext.data.Field#type type} property against properties
+ * of this class.
+ * Developers may add their own application-specific data types to this class. Definition names must be UPPERCASE.
+ * each type definition must contain three properties:
+ * 
+ * convert : FunctionA function to convert raw data values from a data block into the data
+ * to be stored in the Field. The function is passed the collowing parameters:
+ * 
+ * v : MixedThe data value as read by the Reader, if undefined will use
+ * the configured {@link Ext.data.Field#defaultValue defaultValue}.
+ * rec : MixedThe data object containing the row as read by the Reader.
+ * Depending on the Reader type, this could be an Array ({@link Ext.data.ArrayReader ArrayReader}), an object
+ * ({@link Ext.data.JsonReader JsonReader}), or an XML element ({@link Ext.data.XMLReader XMLReader}).
+ * 
+ * sortType : Function A function to convert the stored data into comparable form, as defined by {@link Ext.data.SortTypes}.
+ * type : String A textual data type name.
+ * 
+ * For example, to create a VELatLong field (See the Microsoft Bing Mapping API) containing the latitude/longitude value of a datapoint on a map from a JsonReader data block
+ * which contained the properties lat and long, you would define a new data type like this:
+ *
+// Add a new Field data type which stores a VELatLong object in the Record.
+Ext.data.Types.VELATLONG = {
+    convert: function(v, data) {
+        return new VELatLong(data.lat, data.long);
+    },
+    sortType: function(v) {
+        return v.Latitude;  // When sorting, order by latitude
+    },
+    type: 'VELatLong'
+};
+
+ * Then, when declaring a Record, use 

+var types = Ext.data.Types; // allow shorthand type access
+UnitRecord = Ext.data.Record.create([
+    { name: 'unitName', mapping: 'UnitName' },
+    { name: 'curSpeed', mapping: 'CurSpeed', type: types.INT },
+    { name: 'latitude', mapping: 'lat', type: types.FLOAT },
+    { name: 'latitude', mapping: 'lat', type: types.FLOAT },
+    { name: 'position', type: types.VELATLONG }
+]);
+
+ * @singleton
+ */
+Ext.data.Types = new function(){
+    var st = Ext.data.SortTypes;
+    Ext.apply(this, {
+        /**
+         * @type Regexp
+         * @property stripRe
+         * A regular expression for stripping non-numeric characters from a numeric value. Defaults to /[\$,%]/g.
+         * This should be overridden for localization.
+         */
+        stripRe: /[\$,%]/g,
+        
+        /**
+         * @type Object.
+         * @property AUTO
+         * This data type means that no conversion is applied to the raw data before it is placed into a Record.
+         */
+        AUTO: {
+            convert: function(v){ return v; },
+            sortType: st.none,
+            type: 'auto'
+        },
+
+        /**
+         * @type Object.
+         * @property STRING
+         * This data type means that the raw data is converted into a String before it is placed into a Record.
+         */
+        STRING: {
+            convert: function(v){ return (v === undefined || v === null) ? '' : String(v); },
+            sortType: st.asUCString,
+            type: 'string'
+        },
+
+        /**
+         * @type Object.
+         * @property INT
+         * This data type means that the raw data is converted into an integer before it is placed into a Record.
+         * The synonym INTEGER is equivalent.
+         */
+        INT: {
+            convert: function(v){
+                return v !== undefined && v !== null && v !== '' ?
+                    parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : 0;
+            },
+            sortType: st.none,
+            type: 'int'
+        },
+        
+        /**
+         * @type Object.
+         * @property FLOAT
+         * This data type means that the raw data is converted into a number before it is placed into a Record.
+         * The synonym NUMBER is equivalent.
+         */
+        FLOAT: {
+            convert: function(v){
+                return v !== undefined && v !== null && v !== '' ?
+                    parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : 0;
+            },
+            sortType: st.none,
+            type: 'float'
+        },
+        
+        /**
+         * @type Object.
+         * @property BOOL
+         * This data type means that the raw data is converted into a boolean before it is placed into
+         * a Record. The string "true" and the number 1 are converted to boolean true.
+         * The synonym BOOLEAN is equivalent.
+         */
+        BOOL: {
+            convert: function(v){ return v === true || v === 'true' || v == 1; },
+            sortType: st.none,
+            type: 'bool'
+        },
+        
+        /**
+         * @type Object.
+         * @property DATE
+         * This data type means that the raw data is converted into a Date before it is placed into a Record.
+         * The date format is specified in the constructor of the {@link Ext.data.Field} to which this type is
+         * being applied.
+         */
+        DATE: {
+            convert: function(v){
+                var df = this.dateFormat;
+                if(!v){
+                    return null;
+                }
+                if(Ext.isDate(v)){
+                    return v;
+                }
+                if(df){
+                    if(df == 'timestamp'){
+                        return new Date(v*1000);
+                    }
+                    if(df == 'time'){
+                        return new Date(parseInt(v, 10));
+                    }
+                    return Date.parseDate(v, df);
+                }
+                var parsed = Date.parse(v);
+                return parsed ? new Date(parsed) : null;
+            },
+            sortType: st.asDate,
+            type: 'date'
+        }
+    });
+    
+    Ext.apply(this, {
+        /**
+         * @type Object.
+         * @property BOOLEAN
+         * This data type means that the raw data is converted into a boolean before it is placed into
+         * a Record. The string "true" and the number 1 are converted to boolean true.
+         * The synonym BOOL is equivalent.
+         */
+        BOOLEAN: this.BOOL,
+        /**
+         * @type Object.
+         * @property INTEGER
+         * This data type means that the raw data is converted into an integer before it is placed into a Record.
+         * The synonym INT is equivalent.
+         */
+        INTEGER: this.INT,
+        /**
+         * @type Object.
+         * @property NUMBER
+         * This data type means that the raw data is converted into a number before it is placed into a Record.
+         * The synonym FLOAT is equivalent.
+         */
+        NUMBER: this.FLOAT    
+    });
+};/**
+ * @class Ext.data.JsonWriter
+ * @extends Ext.data.DataWriter
+ * DataWriter extension for writing an array or single {@link Ext.data.Record} object(s) in preparation for executing a remote CRUD action.
+ */
+Ext.data.JsonWriter = Ext.extend(Ext.data.DataWriter, {
     /**
-     * @cfg {Number} minButtonWidth
-     * Minimum width in pixels of all {@link #buttons} in this panel (defaults to 75)
+     * @cfg {Boolean} encode true to {@link Ext.util.JSON#encode encode} the
+     * {@link Ext.data.DataWriter#toHash hashed data}. Defaults to true.  When using
+     * {@link Ext.data.DirectProxy}, set this to false since Ext.Direct.JsonProvider will perform
+     * its own json-encoding.  In addition, if you're using {@link Ext.data.HttpProxy}, setting to false
+     * will cause HttpProxy to transmit data using the jsonData configuration-params of {@link Ext.Ajax#request}
+     * instead of params.  When using a {@link Ext.data.Store#restful} Store, some serverside frameworks are
+     * tuned to expect data through the jsonData mechanism.  In those cases, one will want to set encode: false, as in
+     * let the lower-level connection object (eg: Ext.Ajax) do the encoding.
      */
-    minButtonWidth : 75,
+    encode : true,
     /**
-     * @cfg {Boolean} unstyled
-     * Overrides the {@link #baseCls} setting to {@link #baseCls} = 'x-plain' which renders
-     * the panel unstyled except for required attributes for Ext layouts to function (e.g. overflow:hidden).
+     * @cfg {Boolean} encodeDelete False to send only the id to the server on delete, true to encode it in an object
+     * literal, eg: 
+{id: 1}
+ * 
 Defaults to false
      */
+    encodeDelete: false,
+    
+    constructor : function(config){
+        Ext.data.JsonWriter.superclass.constructor.call(this, config);    
+    },
+
     /**
-     * @cfg {String} elements
-     * A comma-delimited list of panel elements to initialize when the panel is rendered.  Normally, this list will be
-     * generated automatically based on the items added to the panel at config time, but sometimes it might be useful to
-     * make sure a structural element is rendered even if not specified at config time (for example, you may want
-     * to add a button or toolbar dynamically after the panel has been rendered).  Adding those elements to this
-     * list will allocate the required placeholders in the panel when it is rendered.  Valid values are
-     * header
-     * tbar (top bar)
-     * body
-     * bbar (bottom bar)
-     * footer
-     * 
-     * Defaults to 'body'.
+     * Final action of a write event.  Apply the written data-object to params.
+     * @param {Object} http params-object to write-to.
+     * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}.  The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}.
+     * @param {Object/Object[]} data Data-object representing compiled Store-recordset.
      */
-    elements : 'body',
+    render : function(params, baseParams, data) {
+        if (this.encode === true) {
+            // Encode here now.
+            Ext.apply(params, baseParams);
+            params[this.meta.root] = Ext.encode(data);
+        } else {
+            // defer encoding for some other layer, probably in {@link Ext.Ajax#request}.  Place everything into "jsonData" key.
+            var jdata = Ext.apply({}, baseParams);
+            jdata[this.meta.root] = data;
+            params.jsonData = jdata;
+        }
+    },
     /**
-     * @cfg {Boolean} preventBodyReset
-     * Defaults to false.  When set to true, an extra css class 'x-panel-normal'
-     * will be added to the panel's element, effectively applying css styles suggested by the W3C
-     * (see http://www.w3.org/TR/CSS21/sample.html) to the Panel's body element (not the header,
-     * footer, etc.).
+     * Implements abstract Ext.data.DataWriter#createRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Object}
      */
-    preventBodyReset : false,
-
+    createRecord : function(rec) {
+       return this.toHash(rec);
+    },
     /**
-     * @cfg {Number/String} padding
-     * A shortcut for setting a padding style on the body element. The value can either be
-     * a number to be applied to all sides, or a normal css string describing padding.
-     * Defaults to undefined.
-     *
+     * Implements abstract Ext.data.DataWriter#updateRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Object}
      */
-    padding: undefined,
+    updateRecord : function(rec) {
+        return this.toHash(rec);
 
-    /** @cfg {String} resizeEvent
-     * The event to listen to for resizing in layouts. Defaults to 'bodyresize'.
+    },
+    /**
+     * Implements abstract Ext.data.DataWriter#destroyRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Object}
      */
-    resizeEvent: 'bodyresize',
-
-    // protected - these could be used to customize the behavior of the window,
-    // but changing them would not be useful without further mofifications and
-    // could lead to unexpected or undesirable results.
-    toolTarget : 'header',
-    collapseEl : 'bwrap',
-    slideAnchor : 't',
-    disabledClass : '',
+    destroyRecord : function(rec){
+        if(this.encodeDelete){
+            var data = {};
+            data[this.meta.idProperty] = rec.id;
+            return data;
+        }else{
+            return rec.id;
+        }
+    }
+});/**
+ * @class Ext.data.JsonReader
+ * @extends Ext.data.DataReader
+ * Data reader class to create an Array of {@link Ext.data.Record} objects
+ * from a JSON packet based on mappings in a provided {@link Ext.data.Record}
+ * constructor.
+ * Example code:
+ * 
+var myReader = new Ext.data.JsonReader({
+    // metadata configuration options:
+    {@link #idProperty}: 'id'
+    {@link #root}: 'rows',
+    {@link #totalProperty}: 'results',
+    {@link Ext.data.DataReader#messageProperty}: "msg"  // The element within the response that provides a user-feedback message (optional)
 
-    // private, notify box this class will handle heights
-    deferHeight : true,
-    // private
-    expandDefaults: {
-        duration : 0.25
-    },
-    // private
-    collapseDefaults : {
-        duration : 0.25
+    // the fields config option will internally create an {@link Ext.data.Record}
+    // constructor that provides mapping for reading the record data objects
+    {@link Ext.data.DataReader#fields fields}: [
+        // map Record's 'firstname' field to data object's key of same name
+        {name: 'name'},
+        // map Record's 'job' field to data object's 'occupation' key
+        {name: 'job', mapping: 'occupation'}
+    ]
+});
+
+ * This would consume a JSON data object of the form:

+{
+    results: 2000, // Reader's configured {@link #totalProperty}
+    rows: [        // Reader's configured {@link #root}
+        // record data objects:
+        { {@link #idProperty id}: 1, firstname: 'Bill', occupation: 'Gardener' },
+        { {@link #idProperty id}: 2, firstname: 'Ben' , occupation: 'Horticulturalist' },
+        ...
+    ]
+}
+
+ * Automatic configuration using metaData
+ * It is possible to change a JsonReader's metadata at any time by including
+ * a metaData property in the JSON data object. If the JSON data
+ * object has a metaData property, a {@link Ext.data.Store Store}
+ * object using this Reader will reconfigure itself to use the newly provided
+ * field definition and fire its {@link Ext.data.Store#metachange metachange}
+ * event. The metachange event handler may interrogate the metaData
+ * property to perform any configuration required.
+ * Note that reconfiguring a Store potentially invalidates objects which may
+ * refer to Fields or Records which no longer exist.
+ * To use this facility you would create the JsonReader like this:

+var myReader = new Ext.data.JsonReader();
+
+ * The first data packet from the server would configure the reader by
+ * containing a metaData property and the data. For
+ * example, the JSON data object might take the form:

+{
+    metaData: {
+        "{@link #idProperty}": "id",
+        "{@link #root}": "rows",
+        "{@link #totalProperty}": "results"
+        "{@link #successProperty}": "success",
+        "{@link Ext.data.DataReader#fields fields}": [
+            {"name": "name"},
+            {"name": "job", "mapping": "occupation"}
+        ],
+        // used by store to set its sortInfo
+        "sortInfo":{
+           "field": "name",
+           "direction": "ASC"
+        },
+        // {@link Ext.PagingToolbar paging data} (if applicable)
+        "start": 0,
+        "limit": 2,
+        // custom property
+        "foo": "bar"
     },
+    // Reader's configured {@link #successProperty}
+    "success": true,
+    // Reader's configured {@link #totalProperty}
+    "results": 2000,
+    // Reader's configured {@link #root}
+    // (this data simulates 2 results {@link Ext.PagingToolbar per page})
+    "rows": [ // *Note: this must be an Array
+        { "id": 1, "name": "Bill", "occupation": "Gardener" },
+        { "id": 2, "name":  "Ben", "occupation": "Horticulturalist" }
+    ]
+}
+ * 
+ * The metaData property in the JSON data object should contain:
+ * 
+ * any of the configuration options for this class
+ * a {@link Ext.data.Record#fields fields} property which
+ * the JsonReader will use as an argument to the
+ * {@link Ext.data.Record#create data Record create method} in order to
+ * configure the layout of the Records it will produce.
+ * a {@link Ext.data.Store#sortInfo sortInfo} property
+ * which the JsonReader will use to set the {@link Ext.data.Store}'s
+ * {@link Ext.data.Store#sortInfo sortInfo} property
+ * any custom properties needed
+ * 
+ *
+ * @constructor
+ * Create a new JsonReader
+ * @param {Object} meta Metadata configuration options.
+ * @param {Array/Object} recordType
+ * Either an Array of {@link Ext.data.Field Field} definition objects (which
+ * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+ * constructor created from {@link Ext.data.Record#create}.
+ */
+Ext.data.JsonReader = function(meta, recordType){
+    meta = meta || {};
+    /**
+     * @cfg {String} idProperty [id] Name of the property within a row object
+     * that contains a record identifier value.  Defaults to id
+     */
+    /**
+     * @cfg {String} successProperty [success] Name of the property from which to
+     * retrieve the success attribute. Defaults to success.  See
+     * {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception}
+     * for additional information.
+     */
+    /**
+     * @cfg {String} totalProperty [total] Name of the property from which to
+     * retrieve the total number of records in the dataset. This is only needed
+     * if the whole dataset is not passed in one go, but is being paged from
+     * the remote server.  Defaults to total.
+     */
+    /**
+     * @cfg {String} root [undefined] Required.  The name of the property
+     * which contains the Array of row objects.  Defaults to undefined.
+     * An exception will be thrown if the root property is undefined. The data
+     * packet value for this property should be an empty array to clear the data
+     * or show no data.
+     */
+    Ext.applyIf(meta, {
+        idProperty: 'id',
+        successProperty: 'success',
+        totalProperty: 'total'
+    });
 
-    // private
-    initComponent : function(){
-        Ext.Panel.superclass.initComponent.call(this);
-
-        this.addEvents(
-            /**
-             * @event bodyresize
-             * Fires after the Panel has been resized.
-             * @param {Ext.Panel} p the Panel which has been resized.
-             * @param {Number} width The Panel body's new width.
-             * @param {Number} height The Panel body's new height.
-             */
-            'bodyresize',
-            /**
-             * @event titlechange
-             * Fires after the Panel title has been {@link #title set} or {@link #setTitle changed}.
-             * @param {Ext.Panel} p the Panel which has had its title changed.
-             * @param {String} The new title.
-             */
-            'titlechange',
-            /**
-             * @event iconchange
-             * Fires after the Panel icon class has been {@link #iconCls set} or {@link #setIconClass changed}.
-             * @param {Ext.Panel} p the Panel which has had its {@link #iconCls icon class} changed.
-             * @param {String} The new icon class.
-             * @param {String} The old icon class.
-             */
-            'iconchange',
-            /**
-             * @event collapse
-             * Fires after the Panel has been collapsed.
-             * @param {Ext.Panel} p the Panel that has been collapsed.
-             */
-            'collapse',
-            /**
-             * @event expand
-             * Fires after the Panel has been expanded.
-             * @param {Ext.Panel} p The Panel that has been expanded.
-             */
-            'expand',
-            /**
-             * @event beforecollapse
-             * Fires before the Panel is collapsed.  A handler can return false to cancel the collapse.
-             * @param {Ext.Panel} p the Panel being collapsed.
-             * @param {Boolean} animate True if the collapse is animated, else false.
-             */
-            'beforecollapse',
-            /**
-             * @event beforeexpand
-             * Fires before the Panel is expanded.  A handler can return false to cancel the expand.
-             * @param {Ext.Panel} p The Panel being expanded.
-             * @param {Boolean} animate True if the expand is animated, else false.
-             */
-            'beforeexpand',
-            /**
-             * @event beforeclose
-             * Fires before the Panel is closed.  Note that Panels do not directly support being closed, but some
-             * Panel subclasses do (like {@link Ext.Window}) or a Panel within a Ext.TabPanel.  This event only
-             * applies to such subclasses.
-             * A handler can return false to cancel the close.
-             * @param {Ext.Panel} p The Panel being closed.
-             */
-            'beforeclose',
-            /**
-             * @event close
-             * Fires after the Panel is closed.  Note that Panels do not directly support being closed, but some
-             * Panel subclasses do (like {@link Ext.Window}) or a Panel within a Ext.TabPanel.
-             * @param {Ext.Panel} p The Panel that has been closed.
-             */
-            'close',
-            /**
-             * @event activate
-             * Fires after the Panel has been visually activated.
-             * Note that Panels do not directly support being activated, but some Panel subclasses
-             * do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
-             * activate and deactivate events under the control of the TabPanel.
-             * @param {Ext.Panel} p The Panel that has been activated.
-             */
-            'activate',
-            /**
-             * @event deactivate
-             * Fires after the Panel has been visually deactivated.
-             * Note that Panels do not directly support being deactivated, but some Panel subclasses
-             * do (like {@link Ext.Window}). Panels which are child Components of a TabPanel fire the
-             * activate and deactivate events under the control of the TabPanel.
-             * @param {Ext.Panel} p The Panel that has been deactivated.
-             */
-            'deactivate'
-        );
-
-        if(this.unstyled){
-            this.baseCls = 'x-plain';
+    Ext.data.JsonReader.superclass.constructor.call(this, meta, recordType || meta.fields);
+};
+Ext.extend(Ext.data.JsonReader, Ext.data.DataReader, {
+    /**
+     * This JsonReader's metadata as passed to the constructor, or as passed in
+     * the last data packet's metaData property.
+     * @type Mixed
+     * @property meta
+     */
+    /**
+     * This method is only used by a DataProxy which has retrieved data from a remote server.
+     * @param {Object} response The XHR object which contains the JSON data in its responseText.
+     * @return {Object} data A data block which is used by an Ext.data.Store object as
+     * a cache of Ext.data.Records.
+     */
+    read : function(response){
+        var json = response.responseText;
+        var o = Ext.decode(json);
+        if(!o) {
+            throw {message: 'JsonReader.read: Json object not found'};
         }
+        return this.readRecords(o);
+    },
 
-
-        this.toolbars = [];
-        // shortcuts
-        if(this.tbar){
-            this.elements += ',tbar';
-            this.topToolbar = this.createToolbar(this.tbar);
-            delete this.tbar;
-
-        }
-        if(this.bbar){
-            this.elements += ',bbar';
-            this.bottomToolbar = this.createToolbar(this.bbar);
-            delete this.bbar;
+    /*
+     * TODO: refactor code between JsonReader#readRecords, #readResponse into 1 method.
+     * there's ugly duplication going on due to maintaining backwards compat. with 2.0.  It's time to do this.
+     */
+    /**
+     * Decode a JSON response from server.
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} response The XHR object returned through an Ajax server request.
+     * @return {Response} A {@link Ext.data.Response Response} object containing the data response, and also status information.
+     */
+    readResponse : function(action, response) {
+        var o = (response.responseText !== undefined) ? Ext.decode(response.responseText) : response;
+        if(!o) {
+            throw new Ext.data.JsonReader.Error('response');
         }
 
-        if(this.header === true){
-            this.elements += ',header';
-            delete this.header;
-        }else if(this.headerCfg || (this.title && this.header !== false)){
-            this.elements += ',header';
+        var root = this.getRoot(o);
+        if (action === Ext.data.Api.actions.create) {
+            var def = Ext.isDefined(root);
+            if (def && Ext.isEmpty(root)) {
+                throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
+            }
+            else if (!def) {
+                throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
+            }
         }
 
-        if(this.footerCfg || this.footer === true){
-            this.elements += ',footer';
-            delete this.footer;
-        }
+        // instantiate response object
+        var res = new Ext.data.Response({
+            action: action,
+            success: this.getSuccess(o),
+            data: (root) ? this.extractData(root, false) : [],
+            message: this.getMessage(o),
+            raw: o
+        });
 
-        if(this.buttons){
-            this.fbar = this.buttons;
-            delete this.buttons;
-        }
-        if(this.fbar){
-            this.createFbar(this.fbar);
-        }
-        if(this.autoLoad){
-            this.on('render', this.doAutoLoad, this, {delay:10});
+        // blow up if no successProperty
+        if (Ext.isEmpty(res.success)) {
+            throw new Ext.data.JsonReader.Error('successProperty-response', this.meta.successProperty);
         }
+        return res;
     },
 
-    // private
-    createFbar : function(fbar){
-        var min = this.minButtonWidth;
-        this.elements += ',footer';
-        this.fbar = this.createToolbar(fbar, {
-            buttonAlign: this.buttonAlign,
-            toolbarCls: 'x-panel-fbar',
-            enableOverflow: false,
-            defaults: function(c){
-                return {
-                    minWidth: c.minWidth || min
-                };
-            }
-        });
-        //@compat addButton and buttons could possibly be removed
-        //@target 4.0
+    /**
+     * Create a data block containing Ext.data.Records from a JSON object.
+     * @param {Object} o An object which contains an Array of row objects in the property specified
+     * in the config as 'root, and optionally a property, specified in the config as 'totalProperty'
+     * which contains the total size of the dataset.
+     * @return {Object} data A data block which is used by an Ext.data.Store object as
+     * a cache of Ext.data.Records.
+     */
+    readRecords : function(o){
         /**
-         * This Panel's Array of buttons as created from the {@link #buttons}
-         * config property. Read only.
-         * @type Array
-         * @property buttons
+         * After any data loads, the raw JSON data is available for further custom processing.  If no data is
+         * loaded or there is a load exception this property will be undefined.
+         * @type Object
          */
-        this.fbar.items.each(function(c){
-            c.minWidth = c.minWidth || this.minButtonWidth;
-        }, this);
-        this.buttons = this.fbar.items.items;
-    },
-
-    // private
-    createToolbar: function(tb, options){
-        var result;
-        // Convert array to proper toolbar config
-        if(Ext.isArray(tb)){
-            tb = {
-                items: tb
-            };
-        }
-        result = tb.events ? Ext.apply(tb, options) : this.createComponent(Ext.apply({}, tb, options), 'toolbar');
-        this.toolbars.push(result);
-        return result;
-    },
-
-    // private
-    createElement : function(name, pnode){
-        if(this[name]){
-            pnode.appendChild(this[name].dom);
-            return;
+        this.jsonData = o;
+        if(o.metaData){
+            this.onMetaChange(o.metaData);
         }
+        var s = this.meta, Record = this.recordType,
+            f = Record.prototype.fields, fi = f.items, fl = f.length, v;
 
-        if(name === 'bwrap' || this.elements.indexOf(name) != -1){
-            if(this[name+'Cfg']){
-                this[name] = Ext.fly(pnode).createChild(this[name+'Cfg']);
-            }else{
-                var el = document.createElement('div');
-                el.className = this[name+'Cls'];
-                this[name] = Ext.get(pnode.appendChild(el));
-            }
-            if(this[name+'CssClass']){
-                this[name].addClass(this[name+'CssClass']);
+        var root = this.getRoot(o), c = root.length, totalRecords = c, success = true;
+        if(s.totalProperty){
+            v = parseInt(this.getTotal(o), 10);
+            if(!isNaN(v)){
+                totalRecords = v;
             }
-            if(this[name+'Style']){
-                this[name].applyStyles(this[name+'Style']);
+        }
+        if(s.successProperty){
+            v = this.getSuccess(o);
+            if(v === false || v === 'false'){
+                success = false;
             }
         }
+
+        // TODO return Ext.data.Response instance instead.  @see #readResponse
+        return {
+            success : success,
+            records : this.extractData(root, true), // <-- true to return [Ext.data.Record]
+            totalRecords : totalRecords
+        };
     },
 
     // private
-    onRender : function(ct, position){
-        Ext.Panel.superclass.onRender.call(this, ct, position);
-        this.createClasses();
-
-        var el = this.el,
-            d = el.dom,
-            bw,
-            ts;
-
-
-        if(this.collapsible && !this.hideCollapseTool){
-            this.tools = this.tools ? this.tools.slice(0) : [];
-            this.tools[this.collapseFirst?'unshift':'push']({
-                id: 'toggle',
-                handler : this.toggleCollapse,
-                scope: this
-            });
-        }
-
-        if(this.tools){
-            ts = this.tools;
-            this.elements += (this.header !== false) ? ',header' : '';
+    buildExtractors : function() {
+        if(this.ef){
+            return;
         }
-        this.tools = {};
+        var s = this.meta, Record = this.recordType,
+            f = Record.prototype.fields, fi = f.items, fl = f.length;
 
-        el.addClass(this.baseCls);
-        if(d.firstChild){ // existing markup
-            this.header = el.down('.'+this.headerCls);
-            this.bwrap = el.down('.'+this.bwrapCls);
-            var cp = this.bwrap ? this.bwrap : el;
-            this.tbar = cp.down('.'+this.tbarCls);
-            this.body = cp.down('.'+this.bodyCls);
-            this.bbar = cp.down('.'+this.bbarCls);
-            this.footer = cp.down('.'+this.footerCls);
-            this.fromMarkup = true;
+        if(s.totalProperty) {
+            this.getTotal = this.createAccessor(s.totalProperty);
         }
-        if (this.preventBodyReset === true) {
-            el.addClass('x-panel-reset');
+        if(s.successProperty) {
+            this.getSuccess = this.createAccessor(s.successProperty);
         }
-        if(this.cls){
-            el.addClass(this.cls);
+        if (s.messageProperty) {
+            this.getMessage = this.createAccessor(s.messageProperty);
         }
-
-        if(this.buttons){
-            this.elements += ',footer';
+        this.getRoot = s.root ? this.createAccessor(s.root) : function(p){return p;};
+        if (s.id || s.idProperty) {
+            var g = this.createAccessor(s.id || s.idProperty);
+            this.getId = function(rec) {
+                var r = g(rec);
+                return (r === undefined || r === '') ? null : r;
+            };
+        } else {
+            this.getId = function(){return null;};
         }
-
-        // This block allows for maximum flexibility and performance when using existing markup
-
-        // framing requires special markup
-        if(this.frame){
-            el.insertHtml('afterBegin', String.format(Ext.Element.boxMarkup, this.baseCls));
-
-            this.createElement('header', d.firstChild.firstChild.firstChild);
-            this.createElement('bwrap', d);
-
-            // append the mid and bottom frame to the bwrap
-            bw = this.bwrap.dom;
-            var ml = d.childNodes[1], bl = d.childNodes[2];
-            bw.appendChild(ml);
-            bw.appendChild(bl);
-
-            var mc = bw.firstChild.firstChild.firstChild;
-            this.createElement('tbar', mc);
-            this.createElement('body', mc);
-            this.createElement('bbar', mc);
-            this.createElement('footer', bw.lastChild.firstChild.firstChild);
-
-            if(!this.footer){
-                this.bwrap.dom.lastChild.className += ' x-panel-nofooter';
-            }
-            /*
-             * Store a reference to this element so:
-             * a) We aren't looking it up all the time
-             * b) The last element is reported incorrectly when using a loadmask
-             */
-            this.ft = Ext.get(this.bwrap.dom.lastChild);
-            this.mc = Ext.get(mc);
-        }else{
-            this.createElement('header', d);
-            this.createElement('bwrap', d);
-
-            // append the mid and bottom frame to the bwrap
-            bw = this.bwrap.dom;
-            this.createElement('tbar', bw);
-            this.createElement('body', bw);
-            this.createElement('bbar', bw);
-            this.createElement('footer', bw);
-
-            if(!this.header){
-                this.body.addClass(this.bodyCls + '-noheader');
-                if(this.tbar){
-                    this.tbar.addClass(this.tbarCls + '-noheader');
-                }
-            }
+        var ef = [];
+        for(var i = 0; i < fl; i++){
+            f = fi[i];
+            var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
+            ef.push(this.createAccessor(map));
         }
+        this.ef = ef;
+    },
 
-        if(Ext.isDefined(this.padding)){
-            this.body.setStyle('padding', this.body.addUnits(this.padding));
-        }
+    /**
+     * @ignore
+     * TODO This isn't used anywhere??  Don't we want to use this where possible instead of complex #createAccessor?
+     */
+    simpleAccess : function(obj, subsc) {
+        return obj[subsc];
+    },
 
-        if(this.border === false){
-            this.el.addClass(this.baseCls + '-noborder');
-            this.body.addClass(this.bodyCls + '-noborder');
-            if(this.header){
-                this.header.addClass(this.headerCls + '-noborder');
-            }
-            if(this.footer){
-                this.footer.addClass(this.footerCls + '-noborder');
-            }
-            if(this.tbar){
-                this.tbar.addClass(this.tbarCls + '-noborder');
+    /**
+     * @ignore
+     */
+    createAccessor : function(){
+        var re = /[\[\.]/;
+        return function(expr) {
+            if(Ext.isEmpty(expr)){
+                return Ext.emptyFn;
             }
-            if(this.bbar){
-                this.bbar.addClass(this.bbarCls + '-noborder');
+            if(Ext.isFunction(expr)){
+                return expr;
             }
-        }
-
-        if(this.bodyBorder === false){
-           this.body.addClass(this.bodyCls + '-noborder');
-        }
-
-        this.bwrap.enableDisplayMode('block');
-
-        if(this.header){
-            this.header.unselectable();
-
-            // for tools, we need to wrap any existing header markup
-            if(this.headerAsText){
-                this.header.dom.innerHTML =
-                    ''+this.header.dom.innerHTML+'';
-
-                if(this.iconCls){
-                    this.setIconClass(this.iconCls);
-                }
+            var i = String(expr).search(re);
+            if(i >= 0){
+                return new Function('obj', 'return obj' + (i > 0 ? '.' : '') + expr);
             }
-        }
-
-        if(this.floating){
-            this.makeFloating(this.floating);
-        }
-
-        if(this.collapsible && this.titleCollapse && this.header){
-            this.mon(this.header, 'click', this.toggleCollapse, this);
-            this.header.setStyle('cursor', 'pointer');
-        }
-        if(ts){
-            this.addTool.apply(this, ts);
-        }
+            return function(obj){
+                return obj[expr];
+            };
 
-        // Render Toolbars.
-        if(this.fbar){
-            this.footer.addClass('x-panel-btns');
-            this.fbar.ownerCt = this;
-            this.fbar.render(this.footer);
-            this.footer.createChild({cls:'x-clear'});
-        }
-        if(this.tbar && this.topToolbar){
-            this.topToolbar.ownerCt = this;
-            this.topToolbar.render(this.tbar);
-        }
-        if(this.bbar && this.bottomToolbar){
-            this.bottomToolbar.ownerCt = this;
-            this.bottomToolbar.render(this.bbar);
-        }
-    },
+        };
+    }(),
 
     /**
-     * Sets the CSS class that provides the icon image for this panel.  This method will replace any existing
-     * icon class if one has already been set and fire the {@link #iconchange} event after completion.
-     * @param {String} cls The new CSS class name
+     * type-casts a single row of raw-data from server
+     * @param {Object} data
+     * @param {Array} items
+     * @param {Integer} len
+     * @private
      */
-    setIconClass : function(cls){
-        var old = this.iconCls;
-        this.iconCls = cls;
-        if(this.rendered && this.header){
-            if(this.frame){
-                this.header.addClass('x-panel-icon');
-                this.header.replaceClass(old, this.iconCls);
-            }else{
-                var hd = this.header,
-                    img = hd.child('img.x-panel-inline-icon');
-                if(img){
-                    Ext.fly(img).replaceClass(old, this.iconCls);
-                }else{
-                    Ext.DomHelper.insertBefore(hd.dom.firstChild, {
-                        tag:'img', src: Ext.BLANK_IMAGE_URL, cls:'x-panel-inline-icon '+this.iconCls
-                    });
-                 }
-            }
+    extractValues : function(data, items, len) {
+        var f, values = {};
+        for(var j = 0; j < len; j++){
+            f = items[j];
+            var v = this.ef[j](data);
+            values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
         }
-        this.fireEvent('iconchange', this, cls, old);
-    },
+        return values;
+    }
+});
 
-    // private
-    makeFloating : function(cfg){
-        this.floating = true;
-        this.el = new Ext.Layer(Ext.apply({}, cfg, {
-            shadow: Ext.isDefined(this.shadow) ? this.shadow : 'sides',
-            shadowOffset: this.shadowOffset,
-            constrain:false,
-            shim: this.shim === false ? false : undefined
-        }), this.el);
+/**
+ * @class Ext.data.JsonReader.Error
+ * Error class for JsonReader
+ */
+Ext.data.JsonReader.Error = Ext.extend(Ext.Error, {
+    constructor : function(message, arg) {
+        this.arg = arg;
+        Ext.Error.call(this, message);
     },
-
+    name : 'Ext.data.JsonReader'
+});
+Ext.apply(Ext.data.JsonReader.Error.prototype, {
+    lang: {
+        'response': 'An error occurred while json-decoding your server response',
+        'successProperty-response': 'Could not locate your "successProperty" in your server response.  Please review your JsonReader config to ensure the config-property "successProperty" matches the property in your server-response.  See the JsonReader docs.',
+        'root-undefined-config': 'Your JsonReader was configured without a "root" property.  Please review your JsonReader config and make sure to define the root property.  See the JsonReader docs.',
+        'idProperty-undefined' : 'Your JsonReader was configured without an "idProperty"  Please review your JsonReader configuration and ensure the "idProperty" is set (e.g.: "id").  See the JsonReader docs.',
+        'root-empty': 'Data was expected to be returned by the server in the "root" property of the response.  Please review your JsonReader configuration to ensure the "root" property matches that returned in the server-response.  See JsonReader docs.'
+    }
+});
+/**
+ * @class Ext.data.ArrayReader
+ * @extends Ext.data.JsonReader
+ * Data reader class to create an Array of {@link Ext.data.Record} objects from an Array.
+ * Each element of that Array represents a row of data fields. The
+ * fields are pulled into a Record object using as a subscript, the mapping property
+ * of the field definition if it exists, or the field's ordinal position in the definition.
+ * Example code:
+ * 
+var Employee = Ext.data.Record.create([
+    {name: 'name', mapping: 1},         // "mapping" only needed if an "id" field is present which
+    {name: 'occupation', mapping: 2}    // precludes using the ordinal position as the index.
+]);
+var myReader = new Ext.data.ArrayReader({
+    {@link #idIndex}: 0
+}, Employee);
+
+ * This would consume an Array like this:
+ * 
+[ [1, 'Bill', 'Gardener'], [2, 'Ben', 'Horticulturalist'] ]
+ * 
+ * @constructor
+ * Create a new ArrayReader
+ * @param {Object} meta Metadata configuration options.
+ * @param {Array/Object} recordType
+ * Either an Array of {@link Ext.data.Field Field} definition objects (which
+ * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record}
+ * constructor created from {@link Ext.data.Record#create}.
+ */
+Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
     /**
-     * Returns the {@link Ext.Toolbar toolbar} from the top ({@link #tbar}) section of the panel.
-     * @return {Ext.Toolbar} The toolbar
+     * @cfg {String} successProperty
+     * @hide
      */
-    getTopToolbar : function(){
-        return this.topToolbar;
-    },
-
     /**
-     * Returns the {@link Ext.Toolbar toolbar} from the bottom ({@link #bbar}) section of the panel.
-     * @return {Ext.Toolbar} The toolbar
+     * @cfg {Number} id (optional) The subscript within row Array that provides an ID for the Record.
+     * Deprecated. Use {@link #idIndex} instead.
      */
-    getBottomToolbar : function(){
-        return this.bottomToolbar;
-    },
-
     /**
-     * Adds a button to this panel.  Note that this method must be called prior to rendering.  The preferred
-     * approach is to add buttons via the {@link #buttons} config.
-     * @param {String/Object} config A valid {@link Ext.Button} config.  A string will become the text for a default
-     * button config, an object will be treated as a button config object.
-     * @param {Function} handler The function to be called on button {@link Ext.Button#click}
-     * @param {Object} scope The scope (this reference) in which the button handler function is executed. Defaults to the Button.
-     * @return {Ext.Button} The button that was added
+     * @cfg {Number} idIndex (optional) The subscript within row Array that provides an ID for the Record.
      */
-    addButton : function(config, handler, scope){
-        if(!this.fbar){
-            this.createFbar([]);
-        }
-        if(handler){
-            if(Ext.isString(config)){
-                config = {text: config};
+    /**
+     * Create a data block containing Ext.data.Records from an Array.
+     * @param {Object} o An Array of row objects which represents the dataset.
+     * @return {Object} data A data block which is used by an Ext.data.Store object as
+     * a cache of Ext.data.Records.
+     */
+    readRecords : function(o){
+        this.arrayData = o;
+        var s = this.meta,
+            sid = s ? Ext.num(s.idIndex, s.id) : null,
+            recordType = this.recordType,
+            fields = recordType.prototype.fields,
+            records = [],
+            success = true,
+            v;
+
+        var root = this.getRoot(o);
+
+        for(var i = 0, len = root.length; i < len; i++) {
+            var n = root[i],
+                values = {},
+                id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
+            for(var j = 0, jlen = fields.length; j < jlen; j++) {
+                var f = fields.items[j],
+                    k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j;
+                v = n[k] !== undefined ? n[k] : f.defaultValue;
+                v = f.convert(v, n);
+                values[f.name] = v;
             }
-            config = Ext.apply({
-                handler: handler,
-                scope: scope
-            }, config)
+            var record = new recordType(values, id);
+            record.json = n;
+            records[records.length] = record;
         }
-        return this.fbar.add(config);
-    },
 
-    // private
-    addTool : function(){
-        if(!this.rendered){
-            if(!this.tools){
-                this.tools = [];
+        var totalRecords = records.length;
+
+        if(s.totalProperty) {
+            v = parseInt(this.getTotal(o), 10);
+            if(!isNaN(v)) {
+                totalRecords = v;
             }
-            Ext.each(arguments, function(arg){
-                this.tools.push(arg)
-            }, this);
-            return;
-        }
-         // nowhere to render tools!
-        if(!this[this.toolTarget]){
-            return;
-        }
-        if(!this.toolTemplate){
-            // initialize the global tool template on first use
-            var tt = new Ext.Template(
-                 ' '
-            );
-            tt.disableFormats = true;
-            tt.compile();
-            Ext.Panel.prototype.toolTemplate = tt;
         }
-        for(var i = 0, a = arguments, len = a.length; i < len; i++) {
-            var tc = a[i];
-            if(!this.tools[tc.id]){
-                var overCls = 'x-tool-'+tc.id+'-over';
-                var t = this.toolTemplate.insertFirst(this[this.toolTarget], tc, true);
-                this.tools[tc.id] = t;
-                t.enableDisplayMode('block');
-                this.mon(t, 'click',  this.createToolHandler(t, tc, overCls, this));
-                if(tc.on){
-                    this.mon(t, tc.on);
-                }
-                if(tc.hidden){
-                    t.hide();
-                }
-                if(tc.qtip){
-                    if(Ext.isObject(tc.qtip)){
-                        Ext.QuickTips.register(Ext.apply({
-                              target: t.id
-                        }, tc.qtip));
-                    } else {
-                        t.dom.qtip = tc.qtip;
-                    }
-                }
-                t.addClassOnOver(overCls);
+        if(s.successProperty){
+            v = this.getSuccess(o);
+            if(v === false || v === 'false'){
+                success = false;
             }
         }
-    },
 
-    onLayout : function(shallow, force){
-        Ext.Panel.superclass.onLayout.apply(this, arguments);
-        if(this.hasLayout && this.toolbars.length > 0){
-            Ext.each(this.toolbars, function(tb){
-                tb.doLayout(undefined, force);
-            });
-            this.syncHeight();
-        }
+        return {
+            success : success,
+            records : records,
+            totalRecords : totalRecords
+        };
+    }
+});/**
+ * @class Ext.data.ArrayStore
+ * @extends Ext.data.Store
+ * Formerly known as "SimpleStore".
+ * Small helper class to make creating {@link Ext.data.Store}s from Array data easier.
+ * An ArrayStore will be automatically configured with a {@link Ext.data.ArrayReader}.
+ * A store configuration would be something like:

+var store = new Ext.data.ArrayStore({
+    // store configs
+    autoDestroy: true,
+    storeId: 'myStore',
+    // reader configs
+    idIndex: 0,  
+    fields: [
+       'company',
+       {name: 'price', type: 'float'},
+       {name: 'change', type: 'float'},
+       {name: 'pctChange', type: 'float'},
+       {name: 'lastChange', type: 'date', dateFormat: 'n/j h:ia'}
+    ]
+});
+ * 

+ * This store is configured to consume a returned object of the form:

+var myData = [
+    ['3m Co',71.72,0.02,0.03,'9/1 12:00am'],
+    ['Alcoa Inc',29.01,0.42,1.47,'9/1 12:00am'],
+    ['Boeing Co.',75.43,0.53,0.71,'9/1 12:00am'],
+    ['Hewlett-Packard Co.',36.53,-0.03,-0.08,'9/1 12:00am'],
+    ['Wal-Mart Stores, Inc.',45.45,0.73,1.63,'9/1 12:00am']
+];
+ * 
+ * An object literal of this form could also be used as the {@link #data} config option.
+ * *Note: Although not listed here, this class accepts all of the configuration options of 
+ * {@link Ext.data.ArrayReader ArrayReader}.
+ * @constructor
+ * @param {Object} config
+ * @xtype arraystore
+ */
+Ext.data.ArrayStore = Ext.extend(Ext.data.Store, {
+    /**
+     * @cfg {Ext.data.DataReader} reader @hide
+     */
+    constructor: function(config){
+        Ext.data.ArrayStore.superclass.constructor.call(this, Ext.apply(config, {
+            reader: new Ext.data.ArrayReader(config)
+        }));
     },
 
-    syncHeight : function(){
-        var h = this.toolbarHeight,
-                bd = this.body,
-                lsh = this.lastSize.height,
-                sz;
-
-        if(this.autoHeight || !Ext.isDefined(lsh) || lsh == 'auto'){
-            return;
+    loadData : function(data, append){
+        if(this.expandData === true){
+            var r = [];
+            for(var i = 0, len = data.length; i < len; i++){
+                r[r.length] = [data[i]];
+            }
+            data = r;
         }
+        Ext.data.ArrayStore.superclass.loadData.call(this, data, append);
+    }
+});
+Ext.reg('arraystore', Ext.data.ArrayStore);
 
+// backwards compat
+Ext.data.SimpleStore = Ext.data.ArrayStore;
+Ext.reg('simplestore', Ext.data.SimpleStore);/**
+ * @class Ext.data.JsonStore
+ * @extends Ext.data.Store
+ * Small helper class to make creating {@link Ext.data.Store}s from JSON data easier.
+ * A JsonStore will be automatically configured with a {@link Ext.data.JsonReader}.
+ * A store configuration would be something like:

+var store = new Ext.data.JsonStore({
+    // store configs
+    autoDestroy: true,
+    url: 'get-images.php',
+    storeId: 'myStore',
+    // reader configs
+    root: 'images',
+    idProperty: 'name',
+    fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}]
+});
+ * 

+ * This store is configured to consume a returned object of the form:

+{
+    images: [
+        {name: 'Image one', url:'/GetImage.php?id=1', size:46.5, lastmod: new Date(2007, 10, 29)},
+        {name: 'Image Two', url:'/GetImage.php?id=2', size:43.2, lastmod: new Date(2007, 10, 30)}
+    ]
+}
+ * 
+ * An object literal of this form could also be used as the {@link #data} config option.
+ * *Note: Although not listed here, this class accepts all of the configuration options of
+ * {@link Ext.data.JsonReader JsonReader}.
+ * @constructor
+ * @param {Object} config
+ * @xtype jsonstore
+ */
+Ext.data.JsonStore = Ext.extend(Ext.data.Store, {
+    /**
+     * @cfg {Ext.data.DataReader} reader @hide
+     */
+    constructor: function(config){
+        Ext.data.JsonStore.superclass.constructor.call(this, Ext.apply(config, {
+            reader: new Ext.data.JsonReader(config)
+        }));
+    }
+});
+Ext.reg('jsonstore', Ext.data.JsonStore);/**
+ * @class Ext.data.XmlWriter
+ * @extends Ext.data.DataWriter
+ * DataWriter extension for writing an array or single {@link Ext.data.Record} object(s) in preparation for executing a remote CRUD action via XML.
+ * XmlWriter uses an instance of {@link Ext.XTemplate} for maximum flexibility in defining your own custom XML schema if the default schema is not appropriate for your needs.
+ * See the {@link #tpl} configuration-property.
+ */
+Ext.data.XmlWriter = function(params) {
+    Ext.data.XmlWriter.superclass.constructor.apply(this, arguments);
+    // compile the XTemplate for rendering XML documents.
+    this.tpl = (typeof(this.tpl) === 'string') ? new Ext.XTemplate(this.tpl).compile() : this.tpl.compile();
+};
+Ext.extend(Ext.data.XmlWriter, Ext.data.DataWriter, {
+    /**
+     * @cfg {String} documentRoot [xrequest] (Optional) The name of the XML document root-node.  Note:
+     * this parameter is required only when sending extra {@link Ext.data.Store#baseParams baseParams} to the server
+     * during a write-request -- if no baseParams are set, the {@link Ext.data.XmlReader#record} meta-property can
+     * suffice as the XML document root-node for write-actions involving just a single record.  For requests
+     * involving multiple records and NO baseParams, the {@link Ext.data.XmlWriter#root} property can
+     * act as the XML document root.
+     */
+    documentRoot: 'xrequest',
+    /**
+     * @cfg {Boolean} forceDocumentRoot [false] Set to true to force XML documents having a root-node as defined
+     * by {@link #documentRoot}, even with no baseParams defined.
+     */
+    forceDocumentRoot: false,
+    /**
+     * @cfg {String} root [records] The name of the containing element which will contain the nodes of an write-action involving multiple records.  Each
+     * xml-record written to the server will be wrapped in an element named after {@link Ext.data.XmlReader#record} property.
+     * eg:
++<?xml version="1.0" encoding="UTF-8"?>
+<user><first>Barney</first></user>
+
+     * However, when multiple records are written in a batch-operation, these records must be wrapped in a containing
+     * Element.
+     * eg:
++<?xml version="1.0" encoding="UTF-8"?>
+    <records>
+        <first>Barney</first></user>
+        <records><first>Barney</first></user>
+    </records>
+
+     * Defaults to records.  Do not confuse the nature of this property with that of {@link #documentRoot}
+     */
+    root: 'records',
+    /**
+     * @cfg {String} xmlVersion [1.0] The version written to header of xml documents.
+<?xml version="1.0" encoding="ISO-8859-15"?>
+     */
+    xmlVersion : '1.0',
+    /**
+     * @cfg {String} xmlEncoding [ISO-8859-15] The encoding written to header of xml documents.
+<?xml version="1.0" encoding="ISO-8859-15"?>
+     */
+    xmlEncoding: 'ISO-8859-15',
+    /**
+     * @cfg {String/Ext.XTemplate} tpl The XML template used to render {@link Ext.data.Api#actions write-actions} to your server.
+     * One can easily provide his/her own custom {@link Ext.XTemplate#constructor template-definition} if the default does not suffice.
+     * Defaults to:
++<?xml version="{version}" encoding="{encoding}"?>
+    <tpl if="documentRoot"><{documentRoot}>
+    <tpl for="baseParams">
+        <tpl for=".">
+            <{name}>{value}</{name}>
+        </tpl>
+    </tpl>
+    <tpl if="records.length > 1"><{root}>',
+    <tpl for="records">
+        <{parent.record}>
+        <tpl for=".">
+            <{name}>{value}</{name}>
+        </tpl>
+        </{parent.record}>
+    </tpl>
+    <tpl if="records.length > 1"></{root}></tpl>
+    <tpl if="documentRoot"></{documentRoot}></tpl>
+
+     * Templates will be called with the following API
+     * 
+     * {String} version [1.0] The xml version.
+     * {String} encoding [ISO-8859-15] The xml encoding.
+     * {String/false} documentRoot The XML document root-node name or false if not required.  See {@link #documentRoot} and {@link #forceDocumentRoot}.
+     * {String} record The meta-data parameter defined on your {@link Ext.data.XmlReader#record} configuration represents the name of the xml-tag containing each record.
+     * {String} root The meta-data parameter defined by {@link Ext.data.XmlWriter#root} configuration-parameter.  Represents the name of the xml root-tag when sending multiple records to the server.
+     * {Array} records The records being sent to the server, ie: the subject of the write-action being performed.  The records parameter will be always be an array, even when only a single record is being acted upon.
+     *     Each item within the records array will contain an array of field objects having the following properties:
+     *     
+     *         {String} name The field-name of the record as defined by your {@link Ext.data.Record#create Ext.data.Record definition}.  The "mapping" property will be used, otherwise it will match the "name" property.  Use this parameter to define the XML tag-name of the property.
+     *         {Mixed} value The record value of the field enclosed within XML tags specified by name property above.
+     *     
+     * {Array} baseParams.  The baseParams as defined upon {@link Ext.data.Store#baseParams}.  Note that the baseParams have been converted into an array of [{name : "foo", value: "bar"}, ...] pairs in the same manner as the records parameter above.  See {@link #documentRoot} and {@link #forceDocumentRoot}.
+     * 
+     */
+    // Encoding the ? here in case it's being included by some kind of page that will parse it (eg. PHP)
+    tpl: '<\u003fxml version="{version}" encoding="{encoding}"\u003f><{documentRoot}><{name}>{value}<{root}><{parent.record}><{name}>{value}',
 
-        if(h != this.getToolbarHeight()){
-            h = Math.max(0, this.adjustBodyHeight(lsh - this.getFrameHeight()));
-            bd.setHeight(h);
-            sz = bd.getSize();
-            this.toolbarHeight = this.getToolbarHeight();
-            this.onBodyResize(sz.width, sz.height);
-        }
-    },
 
-    // private
-    onShow : function(){
-        if(this.floating){
-            return this.el.show();
-        }
-        Ext.Panel.superclass.onShow.call(this);
+    /**
+     * XmlWriter implementation of the final stage of a write action.
+     * @param {Object} params Transport-proxy's (eg: {@link Ext.Ajax#request}) params-object to write-to.
+     * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}.  The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}.
+     * @param {Object/Object[]} data Data-object representing the compiled Store-recordset.
+     */
+    render : function(params, baseParams, data) {
+        baseParams = this.toArray(baseParams);
+        params.xmlData = this.tpl.applyTemplate({
+            version: this.xmlVersion,
+            encoding: this.xmlEncoding,
+            documentRoot: (baseParams.length > 0 || this.forceDocumentRoot === true) ? this.documentRoot : false,
+            record: this.meta.record,
+            root: this.root,
+            baseParams: baseParams,
+            records: (Ext.isArray(data[0])) ? data : [data]
+        });
     },
 
-    // private
-    onHide : function(){
-        if(this.floating){
-            return this.el.hide();
-        }
-        Ext.Panel.superclass.onHide.call(this);
+    /**
+     * createRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Array} Array of name:value pairs for attributes of the {@link Ext.data.Record}.  See {@link Ext.data.DataWriter#toHash}.
+     */
+    createRecord : function(rec) {
+        return this.toArray(this.toHash(rec));
     },
 
-    // private
-    createToolHandler : function(t, tc, overCls, panel){
-        return function(e){
-            t.removeClass(overCls);
-            if(tc.stopEvent !== false){
-                e.stopEvent();
-            }
-            if(tc.handler){
-                tc.handler.call(tc.scope || t, e, t, panel, tc);
-            }
-        };
-    },
+    /**
+     * updateRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Array} Array of {name:value} pairs for attributes of the {@link Ext.data.Record}.  See {@link Ext.data.DataWriter#toHash}.
+     */
+    updateRecord : function(rec) {
+        return this.toArray(this.toHash(rec));
 
-    // private
-    afterRender : function(){
-        if(this.floating && !this.hidden){
-            this.el.show();
-        }
-        if(this.title){
-            this.setTitle(this.title);
-        }
-        Ext.Panel.superclass.afterRender.call(this); // do sizing calcs last
-        if (this.collapsed) {
-            this.collapsed = false;
-            this.collapse(false);
-        }
-        this.initEvents();
     },
+    /**
+     * destroyRecord
+     * @protected
+     * @param {Ext.data.Record} rec
+     * @return {Array} Array containing a attribute-object (name/value pair) representing the {@link Ext.data.DataReader#idProperty idProperty}.
+     */
+    destroyRecord : function(rec) {
+        var data = {};
+        data[this.meta.idProperty] = rec.id;
+        return this.toArray(data);
+    }
+});
+/**
+ * @class Ext.data.XmlReader
+ * @extends Ext.data.DataReader
+ * Data reader class to create an Array of {@link Ext.data.Record} objects from an XML document
+ * based on mappings in a provided {@link Ext.data.Record} constructor.
+ * Note: that in order for the browser to parse a returned XML document, the Content-Type
+ * header in the HTTP response must be set to "text/xml" or "application/xml".
+ * Example code:
+ * 
+var Employee = Ext.data.Record.create([
+   {name: 'name', mapping: 'name'},     // "mapping" property not needed if it is the same as "name"
+   {name: 'occupation'}                 // This field will use "occupation" as the mapping.
+]);
+var myReader = new Ext.data.XmlReader({
+   totalProperty: "results", // The element which contains the total dataset size (optional)
+   record: "row",           // The repeated element which contains row information
+   idProperty: "id"         // The element within the row that provides an ID for the record (optional)
+   messageProperty: "msg"   // The element within the response that provides a user-feedback message (optional)
+}, Employee);
+
+ * 
+ * This would consume an XML file like this:
+ * 

+<?xml version="1.0" encoding="UTF-8"?>
+<dataset>
+ <results>2</results>
+ <row>
+   <id>1</id>
+   <name>Bill</name>
+   <occupation>Gardener</occupation>
+ </row>
+ <row>
+   <id>2</id>
+   <name>Ben</name>
+   <occupation>Horticulturalist</occupation>
+ </row>
+</dataset>
+
+ * @cfg {String} totalProperty The DomQuery path from which to retrieve the total number of records
+ * in the dataset. This is only needed if the whole dataset is not passed in one go, but is being
+ * paged from the remote server.
+ * @cfg {String} record The DomQuery path to the repeated element which contains record information.
+ * @cfg {String} record The DomQuery path to the repeated element which contains record information.
+ * @cfg {String} successProperty The DomQuery path to the success attribute used by forms.
+ * @cfg {String} idPath The DomQuery path relative from the record element to the element that contains
+ * a record identifier value.
+ * @constructor
+ * Create a new XmlReader.
+ * @param {Object} meta Metadata configuration options
+ * @param {Object} recordType Either an Array of field definition objects as passed to
+ * {@link Ext.data.Record#create}, or a Record constructor object created using {@link Ext.data.Record#create}.
+ */
+Ext.data.XmlReader = function(meta, recordType){
+    meta = meta || {};
 
-    // private
-    getKeyMap : function(){
-        if(!this.keyMap){
-            this.keyMap = new Ext.KeyMap(this.el, this.keys);
-        }
-        return this.keyMap;
-    },
+    // backwards compat, convert idPath or id / success
+    Ext.applyIf(meta, {
+        idProperty: meta.idProperty || meta.idPath || meta.id,
+        successProperty: meta.successProperty || meta.success
+    });
 
-    // private
-    initEvents : function(){
-        if(this.keys){
-            this.getKeyMap();
-        }
-        if(this.draggable){
-            this.initDraggable();
-        }
-        if(this.toolbars.length > 0){
-            Ext.each(this.toolbars, function(tb){
-                tb.doLayout();
-                tb.on({
-                    scope: this,
-                    afterlayout: this.syncHeight,
-                    remove: this.syncHeight
-                });
-            }, this);
-            this.syncHeight();
+    Ext.data.XmlReader.superclass.constructor.call(this, meta, recordType || meta.fields);
+};
+Ext.extend(Ext.data.XmlReader, Ext.data.DataReader, {
+    /**
+     * This method is only used by a DataProxy which has retrieved data from a remote server.
+     * @param {Object} response The XHR object which contains the parsed XML document.  The response is expected
+     * to contain a property called responseXML which refers to an XML document object.
+     * @return {Object} records A data block which is used by an {@link Ext.data.Store} as
+     * a cache of Ext.data.Records.
+     */
+    read : function(response){
+        var doc = response.responseXML;
+        if(!doc) {
+            throw {message: "XmlReader.read: XML Document not available"};
         }
-
+        return this.readRecords(doc);
     },
 
-    // private
-    initDraggable : function(){
+    /**
+     * Create a data block containing Ext.data.Records from an XML document.
+     * @param {Object} doc A parsed XML document.
+     * @return {Object} records A data block which is used by an {@link Ext.data.Store} as
+     * a cache of Ext.data.Records.
+     */
+    readRecords : function(doc){
         /**
-         * If this Panel is configured {@link #draggable}, this property will contain
-         * an instance of {@link Ext.dd.DragSource} which handles dragging the Panel.
-         * The developer must provide implementations of the abstract methods of {@link Ext.dd.DragSource}
-         * in order to supply behaviour for each stage of the drag/drop process. See {@link #draggable}.
-         * @type Ext.dd.DragSource.
-         * @property dd
+         * After any data loads/reads, the raw XML Document is available for further custom processing.
+         * @type XMLDocument
          */
-        this.dd = new Ext.Panel.DD(this, Ext.isBoolean(this.draggable) ? null : this.draggable);
-    },
+        this.xmlData = doc;
 
-    // private
-    beforeEffect : function(anim){
-        if(this.floating){
-            this.el.beforeAction();
+        var root    = doc.documentElement || doc,
+            q       = Ext.DomQuery,
+            totalRecords = 0,
+            success = true;
+
+        if(this.meta.totalProperty){
+            totalRecords = this.getTotal(root, 0);
         }
-        if(anim !== false){
-            this.el.addClass('x-panel-animated');
+        if(this.meta.successProperty){
+            success = this.getSuccess(root);
         }
-    },
 
-    // private
-    afterEffect : function(anim){
-        this.syncShadow();
-        if(anim !== false){
-            this.el.removeClass('x-panel-animated');
-        }
-    },
+        var records = this.extractData(q.select(this.meta.record, root), true); // <-- true to return Ext.data.Record[]
 
-    // private - wraps up an animation param with internal callbacks
-    createEffect : function(a, cb, scope){
-        var o = {
-            scope:scope,
-            block:true
+        // TODO return Ext.data.Response instance.  @see #readResponse
+        return {
+            success : success,
+            records : records,
+            totalRecords : totalRecords || records.length
         };
-        if(a === true){
-            o.callback = cb;
-            return o;
-        }else if(!a.callback){
-            o.callback = cb;
-        }else { // wrap it up
-            o.callback = function(){
-                cb.call(scope);
-                Ext.callback(a.callback, a.scope);
-            };
-        }
-        return Ext.applyIf(o, a);
     },
 
     /**
-     * Collapses the panel body so that it becomes hidden.  Fires the {@link #beforecollapse} event which will
-     * cancel the collapse action if it returns false.
-     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
-     * {@link #animCollapse} panel config)
-     * @return {Ext.Panel} this
+     * Decode an XML response from server.
+     * @param {String} action [{@link Ext.data.Api#actions} create|read|update|destroy]
+     * @param {Object} response HTTP Response object from browser.
+     * @return {Ext.data.Response} An instance of {@link Ext.data.Response}
      */
-    collapse : function(animate){
-        if(this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforecollapse', this, animate) === false){
-            return;
+    readResponse : function(action, response) {
+        var q   = Ext.DomQuery,
+        doc     = response.responseXML;
+
+        // create general Response instance.
+        var res = new Ext.data.Response({
+            action: action,
+            success : this.getSuccess(doc),
+            message: this.getMessage(doc),
+            data: this.extractData(q.select(this.meta.record, doc) || q.select(this.meta.root, doc), false),
+            raw: doc
+        });
+
+        if (Ext.isEmpty(res.success)) {
+            throw new Ext.data.DataReader.Error('successProperty-response', this.meta.successProperty);
         }
-        var doAnim = animate === true || (animate !== false && this.animCollapse);
-        this.beforeEffect(doAnim);
-        this.onCollapse(doAnim, animate);
-        return this;
-    },
 
-    // private
-    onCollapse : function(doAnim, animArg){
-        if(doAnim){
-            this[this.collapseEl].slideOut(this.slideAnchor,
-                    Ext.apply(this.createEffect(animArg||true, this.afterCollapse, this),
-                        this.collapseDefaults));
-        }else{
-            this[this.collapseEl].hide();
-            this.afterCollapse(false);
+        // Create actions from a response having status 200 must return pk
+        if (action === Ext.data.Api.actions.create) {
+            var def = Ext.isDefined(res.data);
+            if (def && Ext.isEmpty(res.data)) {
+                throw new Ext.data.JsonReader.Error('root-empty', this.meta.root);
+            }
+            else if (!def) {
+                throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root);
+            }
         }
+        return res;
     },
 
-    // private
-    afterCollapse : function(anim){
-        this.collapsed = true;
-        this.el.addClass(this.collapsedCls);
-        this.afterEffect(anim);
-        this.fireEvent('collapse', this);
+    getSuccess : function() {
+        return true;
     },
 
     /**
-     * Expands the panel body so that it becomes visible.  Fires the {@link #beforeexpand} event which will
-     * cancel the expand action if it returns false.
-     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
-     * {@link #animCollapse} panel config)
-     * @return {Ext.Panel} this
+     * build response-data extractor functions.
+     * @private
+     * @ignore
      */
-    expand : function(animate){
-        if(!this.collapsed || this.el.hasFxBlock() || this.fireEvent('beforeexpand', this, animate) === false){
+    buildExtractors : function() {
+        if(this.ef){
             return;
         }
-        var doAnim = animate === true || (animate !== false && this.animCollapse);
-        this.el.removeClass(this.collapsedCls);
-        this.beforeEffect(doAnim);
-        this.onExpand(doAnim, animate);
-        return this;
-    },
-
-    // private
-    onExpand : function(doAnim, animArg){
-        if(doAnim){
-            this[this.collapseEl].slideIn(this.slideAnchor,
-                    Ext.apply(this.createEffect(animArg||true, this.afterExpand, this),
-                        this.expandDefaults));
-        }else{
-            this[this.collapseEl].show();
-            this.afterExpand(false);
-        }
-    },
+        var s       = this.meta,
+            Record  = this.recordType,
+            f       = Record.prototype.fields,
+            fi      = f.items,
+            fl      = f.length;
 
-    // private
-    afterExpand : function(anim){
-        this.collapsed = false;
-        this.afterEffect(anim);
-        if (this.deferLayout) {
-            delete this.deferLayout;
-            this.doLayout(true);
+        if(s.totalProperty) {
+            this.getTotal = this.createAccessor(s.totalProperty);
         }
-        this.fireEvent('expand', this);
-    },
-
-    /**
-     * Shortcut for performing an {@link #expand} or {@link #collapse} based on the current state of the panel.
-     * @param {Boolean} animate True to animate the transition, else false (defaults to the value of the
-     * {@link #animCollapse} panel config)
-     * @return {Ext.Panel} this
-     */
-    toggleCollapse : function(animate){
-        this[this.collapsed ? 'expand' : 'collapse'](animate);
-        return this;
-    },
-
-    // private
-    onDisable : function(){
-        if(this.rendered && this.maskDisabled){
-            this.el.mask();
+        if(s.successProperty) {
+            this.getSuccess = this.createAccessor(s.successProperty);
         }
-        Ext.Panel.superclass.onDisable.call(this);
-    },
-
-    // private
-    onEnable : function(){
-        if(this.rendered && this.maskDisabled){
-            this.el.unmask();
+        if (s.messageProperty) {
+            this.getMessage = this.createAccessor(s.messageProperty);
         }
-        Ext.Panel.superclass.onEnable.call(this);
-    },
-
-    // private
-    onResize : function(w, h){
-        if(Ext.isDefined(w) || Ext.isDefined(h)){
-            if(!this.collapsed){
-                // First, set the the Panel's body width.
-                // If we have auto-widthed it, get the resulting full offset width so we can size the Toolbars to match
-                // The Toolbars must not buffer this resize operation because we need to know their heights.
-
-                if(Ext.isNumber(w)){
-                    this.body.setWidth(w = this.adjustBodyWidth(w - this.getFrameWidth()));
-                } else if (w == 'auto') {
-                    w = this.body.setWidth('auto').dom.offsetWidth;
-                } else {
-                    w = this.body.dom.offsetWidth;
-                }
-
-                if(this.tbar){
-                    this.tbar.setWidth(w);
-                    if(this.topToolbar){
-                        this.topToolbar.setSize(w);
-                    }
-                }
-                if(this.bbar){
-                    this.bbar.setWidth(w);
-                    if(this.bottomToolbar){
-                        this.bottomToolbar.setSize(w);
-                        // The bbar does not move on resize without this.
-                        if (Ext.isIE) {
-                            this.bbar.setStyle('position', 'static');
-                            this.bbar.setStyle('position', '');
-                        }
-                    }
-                }
-                if(this.footer){
-                    this.footer.setWidth(w);
-                    if(this.fbar){
-                        this.fbar.setSize(Ext.isIE ? (w - this.footer.getFrameWidth('lr')) : 'auto');
-                    }
-                }
-
-                // At this point, the Toolbars must be layed out for getFrameHeight to find a result.
-                if(Ext.isNumber(h)){
-                    h = Math.max(0, this.adjustBodyHeight(h - this.getFrameHeight()));
-                    this.body.setHeight(h);
-                }else if(h == 'auto'){
-                    this.body.setHeight(h);
-                }
-
-                if(this.disabled && this.el._mask){
-                    this.el._mask.setSize(this.el.dom.clientWidth, this.el.getHeight());
-                }
-            }else{
-                // Adds an event to set the correct height afterExpand.  This accounts for the deferHeight flag in panel
-                this.queuedBodySize = {width: w, height: h};
-                if(!this.queuedExpand && this.allowQueuedExpand !== false){
-                    this.queuedExpand = true;
-                    this.on('expand', function(){
-                        delete this.queuedExpand;
-                        this.onResize(this.queuedBodySize.width, this.queuedBodySize.height);
-                    }, this, {single:true});
-                }
-            }
-            this.onBodyResize(w, h);
+        this.getRoot = function(res) {
+            return (!Ext.isEmpty(res[this.meta.record])) ? res[this.meta.record] : res[this.meta.root];
+        };
+        if (s.idPath || s.idProperty) {
+            var g = this.createAccessor(s.idPath || s.idProperty);
+            this.getId = function(rec) {
+                var id = g(rec) || rec.id;
+                return (id === undefined || id === '') ? null : id;
+            };
+        } else {
+            this.getId = function(){return null;};
         }
-        this.syncShadow();
-        Ext.Panel.superclass.onResize.call(this);
-    },
-
-    // private
-    onBodyResize: function(w, h){
-        this.fireEvent('bodyresize', this, w, h);
-    },
-
-    // private
-    getToolbarHeight: function(){
-        var h = 0;
-        if(this.rendered){
-            Ext.each(this.toolbars, function(tb){
-                h += tb.getHeight();
-            }, this);
+        var ef = [];
+        for(var i = 0; i < fl; i++){
+            f = fi[i];
+            var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name;
+            ef.push(this.createAccessor(map));
         }
-        return h;
-    },
-
-    // private
-    adjustBodyHeight : function(h){
-        return h;
-    },
-
-    // private
-    adjustBodyWidth : function(w){
-        return w;
-    },
-
-    // private
-    onPosition : function(){
-        this.syncShadow();
+        this.ef = ef;
     },
 
     /**
-     * Returns the width in pixels of the framing elements of this panel (not including the body width).  To
-     * retrieve the body width see {@link #getInnerWidth}.
-     * @return {Number} The frame width
+     * Creates a function to return some particular key of data from a response.
+     * @param {String} key
+     * @return {Function}
+     * @private
+     * @ignore
      */
-    getFrameWidth : function(){
-        var w = this.el.getFrameWidth('lr') + this.bwrap.getFrameWidth('lr');
-
-        if(this.frame){
-            var l = this.bwrap.dom.firstChild;
-            w += (Ext.fly(l).getFrameWidth('l') + Ext.fly(l.firstChild).getFrameWidth('r'));
-            w += this.mc.getFrameWidth('lr');
-        }
-        return w;
-    },
+    createAccessor : function(){
+        var q = Ext.DomQuery;
+        return function(key) {
+            switch(key) {
+                case this.meta.totalProperty:
+                    return function(root, def){
+                        return q.selectNumber(key, root, def);
+                    };
+                    break;
+                case this.meta.successProperty:
+                    return function(root, def) {
+                        var sv = q.selectValue(key, root, true);
+                        var success = sv !== false && sv !== 'false';
+                        return success;
+                    };
+                    break;
+                default:
+                    return function(root, def) {
+                        return q.selectValue(key, root, def);
+                    };
+                    break;
+            }
+        };
+    }(),
 
     /**
-     * Returns the height in pixels of the framing elements of this panel (including any top and bottom bars and
-     * header and footer elements, but not including the body height).  To retrieve the body height see {@link #getInnerHeight}.
-     * @return {Number} The frame height
+     * extracts values and type-casts a row of data from server, extracted by #extractData
+     * @param {Hash} data
+     * @param {Ext.data.Field[]} items
+     * @param {Number} len
+     * @private
+     * @ignore
      */
-    getFrameHeight : function(){
-        var h  = this.el.getFrameWidth('tb') + this.bwrap.getFrameWidth('tb');
-        h += (this.tbar ? this.tbar.getHeight() : 0) +
-             (this.bbar ? this.bbar.getHeight() : 0);
-
-        if(this.frame){
-            h += this.el.dom.firstChild.offsetHeight + this.ft.dom.offsetHeight + this.mc.getFrameWidth('tb');
-        }else{
-            h += (this.header ? this.header.getHeight() : 0) +
-                (this.footer ? this.footer.getHeight() : 0);
+    extractValues : function(data, items, len) {
+        var f, values = {};
+        for(var j = 0; j < len; j++){
+            f = items[j];
+            var v = this.ef[j](data);
+            values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data);
         }
-        return h;
-    },
-
+        return values;
+    }
+});/**
+ * @class Ext.data.XmlStore
+ * @extends Ext.data.Store
+ * Small helper class to make creating {@link Ext.data.Store}s from XML data easier.
+ * A XmlStore will be automatically configured with a {@link Ext.data.XmlReader}.
+ * A store configuration would be something like:

+var store = new Ext.data.XmlStore({
+    // store configs
+    autoDestroy: true,
+    storeId: 'myStore',
+    url: 'sheldon.xml', // automatically configures a HttpProxy
+    // reader configs
+    record: 'Item', // records will have an "Item" tag
+    idPath: 'ASIN',
+    totalRecords: '@TotalResults'
+    fields: [
+        // set up the fields mapping into the xml doc
+        // The first needs mapping, the others are very basic
+        {name: 'Author', mapping: 'ItemAttributes > Author'},
+        'Title', 'Manufacturer', 'ProductGroup'
+    ]
+});
+ * 

+ * This store is configured to consume a returned object of the form:

+<?xml version="1.0" encoding="UTF-8"?>
+<ItemSearchResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2009-05-15">
+    <Items>
+        <Request>
+            <IsValid>True</IsValid>
+            <ItemSearchRequest>
+                <Author>Sidney Sheldon</Author>
+                <SearchIndex>Books</SearchIndex>
+            </ItemSearchRequest>
+        </Request>
+        <TotalResults>203</TotalResults>
+        <TotalPages>21</TotalPages>
+        <Item>
+            <ASIN>0446355453</ASIN>
+            <DetailPageURL>
+                http://www.amazon.com/
+            </DetailPageURL>
+            <ItemAttributes>
+                <Author>Sidney Sheldon</Author>
+                <Manufacturer>Warner Books</Manufacturer>
+                <ProductGroup>Book</ProductGroup>
+                <Title>Master of the Game</Title>
+            </ItemAttributes>
+        </Item>
+    </Items>
+</ItemSearchResponse>
+ * 
+ * An object literal of this form could also be used as the {@link #data} config option.
+ * Note: Although not listed here, this class accepts all of the configuration options of 
+ * {@link Ext.data.XmlReader XmlReader}.
+ * @constructor
+ * @param {Object} config
+ * @xtype xmlstore
+ */
+Ext.data.XmlStore = Ext.extend(Ext.data.Store, {
     /**
-     * Returns the width in pixels of the body element (not including the width of any framing elements).
-     * For the frame width see {@link #getFrameWidth}.
-     * @return {Number} The body width
+     * @cfg {Ext.data.DataReader} reader @hide
      */
-    getInnerWidth : function(){
-        return this.getSize().width - this.getFrameWidth();
-    },
+    constructor: function(config){
+        Ext.data.XmlStore.superclass.constructor.call(this, Ext.apply(config, {
+            reader: new Ext.data.XmlReader(config)
+        }));
+    }
+});
+Ext.reg('xmlstore', Ext.data.XmlStore);/**
+ * @class Ext.data.GroupingStore
+ * @extends Ext.data.Store
+ * A specialized store implementation that provides for grouping records by one of the available fields. This
+ * is usually used in conjunction with an {@link Ext.grid.GroupingView} to provide the data model for
+ * a grouped GridPanel.
+ *
+ * Internally, GroupingStore is simply a normal Store with multi sorting enabled from the start. The grouping field
+ * and direction are always injected as the first sorter pair. GroupingView picks up on the configured groupField and
+ * builds grid rows appropriately.
+ *
+ * @constructor
+ * Creates a new GroupingStore.
+ * @param {Object} config A config object containing the objects needed for the Store to access data,
+ * and read the data into Records.
+ * @xtype groupingstore
+ */
+Ext.data.GroupingStore = Ext.extend(Ext.data.Store, {
 
-    /**
-     * Returns the height in pixels of the body element (not including the height of any framing elements).
-     * For the frame height see {@link #getFrameHeight}.
-     * @return {Number} The body height
-     */
-    getInnerHeight : function(){
-        return this.getSize().height - this.getFrameHeight();
-    },
+    //inherit docs
+    constructor: function(config) {
+        config = config || {};
+
+        //We do some preprocessing here to massage the grouping + sorting options into a single
+        //multi sort array. If grouping and sorting options are both presented to the constructor,
+        //the sorters array consists of the grouping sorter object followed by the sorting sorter object
+        //see Ext.data.Store's sorting functions for details about how multi sorting works
+        this.hasMultiSort  = true;
+        this.multiSortInfo = this.multiSortInfo || {sorters: []};
+
+        var sorters    = this.multiSortInfo.sorters,
+            groupField = config.groupField || this.groupField,
+            sortInfo   = config.sortInfo || this.sortInfo,
+            groupDir   = config.groupDir || this.groupDir;
+
+        //add the grouping sorter object first
+        if(groupField){
+            sorters.push({
+                field    : groupField,
+                direction: groupDir
+            });
+        }
 
-    // private
-    syncShadow : function(){
-        if(this.floating){
-            this.el.sync(true);
+        //add the sorting sorter object if it is present
+        if (sortInfo) {
+            sorters.push(sortInfo);
         }
-    },
 
-    // private
-    getLayoutTarget : function(){
-        return this.body;
-    },
+        Ext.data.GroupingStore.superclass.constructor.call(this, config);
 
-    // private
-    getContentTarget : function(){
-        return this.body;
+        this.addEvents(
+          /**
+           * @event groupchange
+           * Fired whenever a call to store.groupBy successfully changes the grouping on the store
+           * @param {Ext.data.GroupingStore} store The grouping store
+           * @param {String} groupField The field that the store is now grouped by
+           */
+          'groupchange'
+        );
+
+        this.applyGroupField();
     },
 
     /**
-     * Sets the title text for the panel and optionally the {@link #iconCls icon class}.
-     * In order to be able to set the title, a header element must have been created
-     * for the Panel. This is triggered either by configuring the Panel with a non-blank {@link #title},
-     * or configuring it with {@link #header}: true.
-     * @param {String} title The title text to set
-     * @param {String} iconCls (optional) {@link #iconCls iconCls} A user-defined CSS class that provides the icon image for this panel
+     * @cfg {String} groupField
+     * The field name by which to sort the store's data (defaults to '').
      */
-    setTitle : function(title, iconCls){
-        this.title = title;
-        if(this.header && this.headerAsText){
-            this.header.child('span').update(title);
-        }
-        if(iconCls){
-            this.setIconClass(iconCls);
-        }
-        this.fireEvent('titlechange', this, title);
-        return this;
-    },
-
     /**
-     * Get the {@link Ext.Updater} for this panel. Enables you to perform Ajax updates of this panel's body.
-     * @return {Ext.Updater} The Updater
+     * @cfg {Boolean} remoteGroup
+     * True if the grouping should apply on the server side, false if it is local only (defaults to false).  If the
+     * grouping is local, it can be applied immediately to the data.  If it is remote, then it will simply act as a
+     * helper, automatically sending the grouping field name as the 'groupBy' param with each XHR call.
      */
-    getUpdater : function(){
-        return this.body.getUpdater();
-    },
+    remoteGroup : false,
+    /**
+     * @cfg {Boolean} groupOnSort
+     * True to sort the data on the grouping field when a grouping operation occurs, false to sort based on the
+     * existing sort info (defaults to false).
+     */
+    groupOnSort:false,
 
-     /**
-     * Loads this content panel immediately with content returned from an XHR call.
-     * @param {Object/String/Function} config A config object containing any of the following options:
-
-panel.load({
-    url: 'your-url.php',
-    params: {param1: 'foo', param2: 'bar'}, // or a URL encoded string
-    callback: yourFunction,
-    scope: yourObject, // optional scope for the callback
-    discardUrl: false,
-    nocache: false,
-    text: 'Loading...',
-    timeout: 30,
-    scripts: false
-});
-
-     * The only required property is url. The optional properties nocache, text and scripts
-     * are shorthand for disableCaching, indicatorText and loadScripts and are used to set their
-     * associated property on this panel Updater instance.
-     * @return {Ext.Panel} this
+    groupDir : 'ASC',
+
+    /**
+     * Clears any existing grouping and refreshes the data using the default sort.
      */
-    load : function(){
-        var um = this.body.getUpdater();
-        um.update.apply(um, arguments);
-        return this;
-    },
+    clearGrouping : function(){
+        this.groupField = false;
 
-    // private
-    beforeDestroy : function(){
-        Ext.Panel.superclass.beforeDestroy.call(this);
-        if(this.header){
-            this.header.removeAllListeners();
-        }
-        if(this.tools){
-            for(var k in this.tools){
-                Ext.destroy(this.tools[k]);
-            }
-        }
-        if(this.toolbars.length > 0){
-            Ext.each(this.toolbars, function(tb){
-                tb.un('afterlayout', this.syncHeight, this);
-                tb.un('remove', this.syncHeight, this);
-            }, this);
-        }
-        if(Ext.isArray(this.buttons)){
-            while(this.buttons.length) {
-                Ext.destroy(this.buttons[0]);
+        if(this.remoteGroup){
+            if(this.baseParams){
+                delete this.baseParams.groupBy;
+                delete this.baseParams.groupDir;
             }
-        }
-        if(this.rendered){
-            Ext.destroy(
-                this.ft,
-                this.header,
-                this.footer,
-                this.toolbars,
-                this.tbar,
-                this.bbar,
-                this.body,
-                this.mc,
-                this.bwrap
-            );
-            if (this.fbar) {
-                Ext.destroy(
-                    this.fbar,
-                    this.fbar.el
-                );
+            var lo = this.lastOptions;
+            if(lo && lo.params){
+                delete lo.params.groupBy;
+                delete lo.params.groupDir;
             }
+
+            this.reload();
         }else{
-            Ext.destroy(
-                this.topToolbar,
-                this.bottomToolbar
-            );
+            this.sort();
+            this.fireEvent('datachanged', this);
         }
     },
 
-    // private
-    createClasses : function(){
-        this.headerCls = this.baseCls + '-header';
-        this.headerTextCls = this.baseCls + '-header-text';
-        this.bwrapCls = this.baseCls + '-bwrap';
-        this.tbarCls = this.baseCls + '-tbar';
-        this.bodyCls = this.baseCls + '-body';
-        this.bbarCls = this.baseCls + '-bbar';
-        this.footerCls = this.baseCls + '-footer';
+    /**
+     * Groups the data by the specified field.
+     * @param {String} field The field name by which to sort the store's data
+     * @param {Boolean} forceRegroup (optional) True to force the group to be refreshed even if the field passed
+     * in is the same as the current grouping field, false to skip grouping on the same field (defaults to false)
+     */
+    groupBy : function(field, forceRegroup, direction) {
+        direction = direction ? (String(direction).toUpperCase() == 'DESC' ? 'DESC' : 'ASC') : this.groupDir;
+
+        if (this.groupField == field && this.groupDir == direction && !forceRegroup) {
+            return; // already grouped by this field
+        }
+
+        //check the contents of the first sorter. If the field matches the CURRENT groupField (before it is set to the new one),
+        //remove the sorter as it is actually the grouper. The new grouper is added back in by this.sort
+        sorters = this.multiSortInfo.sorters;
+        if (sorters.length > 0 && sorters[0].field == this.groupField) {
+            sorters.shift();
+        }
+
+        this.groupField = field;
+        this.groupDir = direction;
+        this.applyGroupField();
+
+        var fireGroupEvent = function() {
+            this.fireEvent('groupchange', this, this.getGroupState());
+        };
+
+        if (this.groupOnSort) {
+            this.sort(field, direction);
+            fireGroupEvent.call(this);
+            return;
+        }
+
+        if (this.remoteGroup) {
+            this.on('load', fireGroupEvent, this, {single: true});
+            this.reload();
+        } else {
+            this.sort(sorters);
+            fireGroupEvent.call(this);
+        }
     },
 
-    // private
-    createGhost : function(cls, useShim, appendTo){
-        var el = document.createElement('div');
-        el.className = 'x-panel-ghost ' + (cls ? cls : '');
-        if(this.header){
-            el.appendChild(this.el.dom.firstChild.cloneNode(true));
+    //GroupingStore always uses multisorting so we intercept calls to sort here to make sure that our grouping sorter object
+    //is always injected first.
+    sort : function(fieldName, dir) {
+        if (this.remoteSort) {
+            return Ext.data.GroupingStore.superclass.sort.call(this, fieldName, dir);
         }
-        Ext.fly(el.appendChild(document.createElement('ul'))).setHeight(this.bwrap.getHeight());
-        el.style.width = this.el.dom.offsetWidth + 'px';;
-        if(!appendTo){
-            this.container.dom.appendChild(el);
-        }else{
-            Ext.getDom(appendTo).appendChild(el);
+
+        var sorters = [];
+
+        //cater for any existing valid arguments to this.sort, massage them into an array of sorter objects
+        if (Ext.isArray(arguments[0])) {
+            sorters = arguments[0];
+        } else if (fieldName == undefined) {
+            //we preserve the existing sortInfo here because this.sort is called after
+            //clearGrouping and there may be existing sorting
+            sorters = [this.sortInfo];
+        } else {
+            //TODO: this is lifted straight from Ext.data.Store's singleSort function. It should instead be
+            //refactored into a common method if possible
+            var field = this.fields.get(fieldName);
+            if (!field) return false;
+
+            var name       = field.name,
+                sortInfo   = this.sortInfo || null,
+                sortToggle = this.sortToggle ? this.sortToggle[name] : null;
+
+            if (!dir) {
+                if (sortInfo && sortInfo.field == name) { // toggle sort dir
+                    dir = (this.sortToggle[name] || 'ASC').toggle('ASC', 'DESC');
+                } else {
+                    dir = field.sortDir;
+                }
+            }
+
+            this.sortToggle[name] = dir;
+            this.sortInfo = {field: name, direction: dir};
+
+            sorters = [this.sortInfo];
         }
-        if(useShim !== false && this.el.useShim !== false){
-            var layer = new Ext.Layer({shadow:false, useDisplay:true, constrain:false}, el);
-            layer.show();
-            return layer;
-        }else{
-            return new Ext.Element(el);
+
+        //add the grouping sorter object as the first multisort sorter
+        if (this.groupField) {
+            sorters.unshift({direction: this.groupDir, field: this.groupField});
         }
+
+        return this.multiSort.call(this, sorters, dir);
     },
 
-    // private
-    doAutoLoad : function(){
-        var u = this.body.getUpdater();
-        if(this.renderer){
-            u.setRenderer(this.renderer);
+    /**
+     * @private
+     * Saves the current grouping field and direction to this.baseParams and this.lastOptions.params
+     * if we're using remote grouping. Does not actually perform any grouping - just stores values
+     */
+    applyGroupField: function(){
+        if (this.remoteGroup) {
+            if(!this.baseParams){
+                this.baseParams = {};
+            }
+
+            Ext.apply(this.baseParams, {
+                groupBy : this.groupField,
+                groupDir: this.groupDir
+            });
+
+            var lo = this.lastOptions;
+            if (lo && lo.params) {
+                lo.params.groupDir = this.groupDir;
+
+                //this is deleted because of a bug reported at http://www.extjs.com/forum/showthread.php?t=82907
+                delete lo.params.groupBy;
+            }
         }
-        u.update(Ext.isObject(this.autoLoad) ? this.autoLoad : {url: this.autoLoad});
     },
 
     /**
-     * Retrieve a tool by id.
-     * @param {String} id
-     * @return {Object} tool
+     * @private
+     * TODO: This function is apparently never invoked anywhere in the framework. It has no documentation
+     * and should be considered for deletion
      */
-    getTool : function(id) {
-        return this.tools[id];
-    }
+    applyGrouping : function(alwaysFireChange){
+        if(this.groupField !== false){
+            this.groupBy(this.groupField, true, this.groupDir);
+            return true;
+        }else{
+            if(alwaysFireChange === true){
+                this.fireEvent('datachanged', this);
+            }
+            return false;
+        }
+    },
 
-/**
- * @cfg {String} autoEl @hide
- */
+    /**
+     * @private
+     * Returns the grouping field that should be used. If groupOnSort is used this will be sortInfo's field,
+     * otherwise it will be this.groupField
+     * @return {String} The group field
+     */
+    getGroupState : function(){
+        return this.groupOnSort && this.groupField !== false ?
+               (this.sortInfo ? this.sortInfo.field : undefined) : this.groupField;
+    }
 });
-Ext.reg('panel', Ext.Panel);
+Ext.reg('groupingstore', Ext.data.GroupingStore);
 /**
- * @class Ext.Editor
- * @extends Ext.Component
- * A base editor field that handles displaying/hiding on demand and has some built-in sizing and event handling logic.
- * @constructor
- * Create a new Editor
- * @param {Object} config The config object
- * @xtype editor
+ * @class Ext.data.DirectProxy
+ * @extends Ext.data.DataProxy
  */
-Ext.Editor = function(field, config){
-    if(field.field){
-        this.field = Ext.create(field.field, 'textfield');
-        config = Ext.apply({}, field); // copy so we don't disturb original config
-        delete config.field;
-    }else{
-        this.field = field;
+Ext.data.DirectProxy = function(config){
+    Ext.apply(this, config);
+    if(typeof this.paramOrder == 'string'){
+        this.paramOrder = this.paramOrder.split(/[\s,|]/);
     }
-    Ext.Editor.superclass.constructor.call(this, config);
+    Ext.data.DirectProxy.superclass.constructor.call(this, config);
 };
 
-Ext.extend(Ext.Editor, Ext.Component, {
-    /**
-    * @cfg {Ext.form.Field} field
-    * The Field object (or descendant) or config object for field
-    */
-    /**
-     * @cfg {Boolean} allowBlur
-     * True to {@link #completeEdit complete the editing process} if in edit mode when the
-     * field is blurred. Defaults to false.
-     */
-    /**
-     * @cfg {Boolean/String} autoSize
-     * True for the editor to automatically adopt the size of the underlying field, "width" to adopt the width only,
-     * or "height" to adopt the height only, "none" to always use the field dimensions. (defaults to false)
-     */
-    /**
-     * @cfg {Boolean} revertInvalid
-     * True to automatically revert the field value and cancel the edit when the user completes an edit and the field
-     * validation fails (defaults to true)
-     */
-    /**
-     * @cfg {Boolean} ignoreNoChange
-     * True to skip the edit completion process (no save, no events fired) if the user completes an edit and
-     * the value has not changed (defaults to false).  Applies only to string values - edits for other data types
-     * will never be ignored.
-     */
-    /**
-     * @cfg {Boolean} hideEl
-     * False to keep the bound element visible while the editor is displayed (defaults to true)
-     */
-    /**
-     * @cfg {Mixed} value
-     * The data value of the underlying field (defaults to "")
-     */
-    value : "",
-    /**
-     * @cfg {String} alignment
-     * The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "c-c?").
-     */
-    alignment: "c-c?",
-    /**
-     * @cfg {Array} offsets
-     * The offsets to use when aligning (see {@link Ext.Element#alignTo} for more details. Defaults to [0, 0].
-     */
-    offsets: [0, 0],
-    /**
-     * @cfg {Boolean/String} shadow "sides" for sides/bottom only, "frame" for 4-way shadow, and "drop"
-     * for bottom-right shadow (defaults to "frame")
-     */
-    shadow : "frame",
-    /**
-     * @cfg {Boolean} constrain True to constrain the editor to the viewport
-     */
-    constrain : false,
+Ext.extend(Ext.data.DirectProxy, Ext.data.DataProxy, {
     /**
-     * @cfg {Boolean} swallowKeys Handle the keydown/keypress events so they don't propagate (defaults to true)
+     * @cfg {Array/String} paramOrder Defaults to undefined. A list of params to be executed
+     * server side.  Specify the params in the order in which they must be executed on the server-side
+     * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace,
+     * comma, or pipe. For example,
+     * any of the following would be acceptable:
+paramOrder: ['param1','param2','param3']
+paramOrder: 'param1 param2 param3'
+paramOrder: 'param1,param2,param3'
+paramOrder: 'param1|param2|param'
+     
      */
-    swallowKeys : true,
+    paramOrder: undefined,
+
     /**
-     * @cfg {Boolean} completeOnEnter True to complete the edit when the enter key is pressed. Defaults to true.
+     * @cfg {Boolean} paramsAsHash
+     * Send parameters as a collection of named arguments (defaults to true). Providing a
+     * {@link #paramOrder} nullifies this configuration.
      */
-    completeOnEnter : true,
+    paramsAsHash: true,
+
     /**
-     * @cfg {Boolean} cancelOnEsc True to cancel the edit when the escape key is pressed. Defaults to true.
+     * @cfg {Function} directFn
+     * Function to call when executing a request.  directFn is a simple alternative to defining the api configuration-parameter
+     * for Store's which will not implement a full CRUD api.
      */
-    cancelOnEsc : true,
+    directFn : undefined,
+
     /**
-     * @cfg {Boolean} updateEl True to update the innerHTML of the bound element when the update completes (defaults to false)
+     * DirectProxy implementation of {@link Ext.data.DataProxy#doRequest}
+     * @param {String} action The crud action type (create, read, update, destroy)
+     * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null
+     * @param {Object} params An object containing properties which are to be used as HTTP parameters
+     * for the request to the remote server.
+     * @param {Ext.data.DataReader} reader The Reader object which converts the data
+     * object into a block of Ext.data.Records.
+     * @param {Function} callback
+     * A function to be called after the request.
+     * The callback is passed the following arguments:

+     * r : Ext.data.Record[] The block of Ext.data.Records.
+     * options: Options object from the action request
+     * success: Boolean success indicator

+     * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window.
+     * @param {Object} arg An optional argument which is passed to the callback as its second parameter.
+     * @protected
      */
-    updateEl : false,
-
-    initComponent : function(){
-        Ext.Editor.superclass.initComponent.call(this);
-        this.addEvents(
-            /**
-             * @event beforestartedit
-             * Fires when editing is initiated, but before the value changes.  Editing can be canceled by returning
-             * false from the handler of this event.
-             * @param {Editor} this
-             * @param {Ext.Element} boundEl The underlying element bound to this editor
-             * @param {Mixed} value The field value being set
-             */
-            "beforestartedit",
-            /**
-             * @event startedit
-             * Fires when this editor is displayed
-             * @param {Ext.Element} boundEl The underlying element bound to this editor
-             * @param {Mixed} value The starting field value
-             */
-            "startedit",
-            /**
-             * @event beforecomplete
-             * Fires after a change has been made to the field, but before the change is reflected in the underlying
-             * field.  Saving the change to the field can be canceled by returning false from the handler of this event.
-             * Note that if the value has not changed and ignoreNoChange = true, the editing will still end but this
-             * event will not fire since no edit actually occurred.
-             * @param {Editor} this
-             * @param {Mixed} value The current field value
-             * @param {Mixed} startValue The original field value
-             */
-            "beforecomplete",
-            /**
-             * @event complete
-             * Fires after editing is complete and any changed value has been written to the underlying field.
-             * @param {Editor} this
-             * @param {Mixed} value The current field value
-             * @param {Mixed} startValue The original field value
-             */
-            "complete",
-            /**
-             * @event canceledit
-             * Fires after editing has been canceled and the editor's value has been reset.
-             * @param {Editor} this
-             * @param {Mixed} value The user-entered field value that was discarded
-             * @param {Mixed} startValue The original field value that was set back into the editor after cancel
-             */
-            "canceledit",
-            /**
-             * @event specialkey
-             * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed.  You can check
-             * {@link Ext.EventObject#getKey} to determine which key was pressed.
-             * @param {Ext.form.Field} this
-             * @param {Ext.EventObject} e The event object
-             */
-            "specialkey"
-        );
-    },
+    doRequest : function(action, rs, params, reader, callback, scope, options) {
+        var args = [],
+            directFn = this.api[action] || this.directFn;
 
-    // private
-    onRender : function(ct, position){
-        this.el = new Ext.Layer({
-            shadow: this.shadow,
-            cls: "x-editor",
-            parentEl : ct,
-            shim : this.shim,
-            shadowOffset: this.shadowOffset || 4,
-            id: this.id,
-            constrain: this.constrain
-        });
-        if(this.zIndex){
-            this.el.setZIndex(this.zIndex);
-        }
-        this.el.setStyle("overflow", Ext.isGecko ? "auto" : "hidden");
-        if(this.field.msgTarget != 'title'){
-            this.field.msgTarget = 'qtip';
-        }
-        this.field.inEditor = true;
-        this.mon(this.field, {
-            scope: this,
-            blur: this.onBlur,
-            specialkey: this.onSpecialKey
-        });
-        if(this.field.grow){
-            this.mon(this.field, "autosize", this.el.sync,  this.el, {delay:1});
-        }
-        this.field.render(this.el).show();
-        this.field.getEl().dom.name = '';
-        if(this.swallowKeys){
-            this.field.el.swallowEvent([
-                'keypress', // *** Opera
-                'keydown'   // *** all other browsers
-            ]);
+        switch (action) {
+            case Ext.data.Api.actions.create:
+                args.push(params.jsonData);		// <-- create(Hash)
+                break;
+            case Ext.data.Api.actions.read:
+                // If the method has no parameters, ignore the paramOrder/paramsAsHash.
+                if(directFn.directCfg.method.len > 0){
+                    if(this.paramOrder){
+                        for(var i = 0, len = this.paramOrder.length; i < len; i++){
+                            args.push(params[this.paramOrder[i]]);
+                        }
+                    }else if(this.paramsAsHash){
+                        args.push(params);
+                    }
+                }
+                break;
+            case Ext.data.Api.actions.update:
+                args.push(params.jsonData);        // <-- update(Hash/Hash[])
+                break;
+            case Ext.data.Api.actions.destroy:
+                args.push(params.jsonData);        // <-- destroy(Int/Int[])
+                break;
         }
+
+        var trans = {
+            params : params || {},
+            request: {
+                callback : callback,
+                scope : scope,
+                arg : options
+            },
+            reader: reader
+        };
+
+        args.push(this.createCallback(action, rs, trans), this);
+        directFn.apply(window, args);
     },
 
     // private
-    onSpecialKey : function(field, e){
-        var key = e.getKey(),
-            complete = this.completeOnEnter && key == e.ENTER,
-            cancel = this.cancelOnEsc && key == e.ESC;
-        if(complete || cancel){
-            e.stopEvent();
-            if(complete){
-                this.completeEdit();
-            }else{
-                this.cancelEdit();
+    createCallback : function(action, rs, trans) {
+        var me = this;
+        return function(result, res) {
+            if (!res.status) {
+                // @deprecated fire loadexception
+                if (action === Ext.data.Api.actions.read) {
+                    me.fireEvent("loadexception", me, trans, res, null);
+                }
+                me.fireEvent('exception', me, 'remote', action, trans, res, null);
+                trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
+                return;
             }
-            if(field.triggerBlur){
-                field.triggerBlur();
+            if (action === Ext.data.Api.actions.read) {
+                me.onRead(action, trans, result, res);
+            } else {
+                me.onWrite(action, trans, result, res, rs);
             }
-        }
-        this.fireEvent('specialkey', field, e);
+        };
     },
 
     /**
-     * Starts the editing process and shows the editor.
-     * @param {Mixed} el The element to edit
-     * @param {String} value (optional) A value to initialize the editor with. If a value is not provided, it defaults
-      * to the innerHTML of el.
+     * Callback for read actions
+     * @param {String} action [Ext.data.Api.actions.create|read|update|destroy]
+     * @param {Object} trans The request transaction object
+     * @param {Object} result Data object picked out of the server-response.
+     * @param {Object} res The server response
+     * @protected
      */
-    startEdit : function(el, value){
-        if(this.editing){
-            this.completeEdit();
-        }
-        this.boundEl = Ext.get(el);
-        var v = value !== undefined ? value : this.boundEl.dom.innerHTML;
-        if(!this.rendered){
-            this.render(this.parentEl || document.body);
-        }
-        if(this.fireEvent("beforestartedit", this, this.boundEl, v) !== false){
-            this.startValue = v;
-            this.field.reset();
-            this.field.setValue(v);
-            this.realign(true);
-            this.editing = true;
-            this.show();
+    onRead : function(action, trans, result, res) {
+        var records;
+        try {
+            records = trans.reader.readRecords(result);
         }
-    },
-
-    // private
-    doAutoSize : function(){
-        if(this.autoSize){
-            var sz = this.boundEl.getSize(),
-                fs = this.field.getSize();
+        catch (ex) {
+            // @deprecated: Fire old loadexception for backwards-compat.
+            this.fireEvent("loadexception", this, trans, res, ex);
 
-            switch(this.autoSize){
-                case "width":
-                    this.setSize(sz.width, fs.height);
-                    break;
-                case "height":
-                    this.setSize(fs.width, sz.height);
-                    break;
-                case "none":
-                    this.setSize(fs.width, fs.height);
-                    break;
-                default:
-                    this.setSize(sz.width, sz.height);
-            }
+            this.fireEvent('exception', this, 'response', action, trans, res, ex);
+            trans.request.callback.call(trans.request.scope, null, trans.request.arg, false);
+            return;
         }
+        this.fireEvent("load", this, res, trans.request.arg);
+        trans.request.callback.call(trans.request.scope, records, trans.request.arg, true);
     },
-
     /**
-     * Sets the height and width of this editor.
-     * @param {Number} width The new width
-     * @param {Number} height The new height
+     * Callback for write actions
+     * @param {String} action [{@link Ext.data.Api#actions create|read|update|destroy}]
+     * @param {Object} trans The request transaction object
+     * @param {Object} result Data object picked out of the server-response.
+     * @param {Object} res The server response
+     * @param {Ext.data.Record/[Ext.data.Record]} rs The Store resultset associated with the action.
+     * @protected
      */
-    setSize : function(w, h){
-        delete this.field.lastSize;
-        this.field.setSize(w, h);
-        if(this.el){
-            if(Ext.isGecko2 || Ext.isOpera){
-                // prevent layer scrollbars
-                this.el.setSize(w, h);
-            }
-            this.el.sync();
+    onWrite : function(action, trans, result, res, rs) {
+        var data = trans.reader.extractData(trans.reader.getRoot(result), false);
+        var success = trans.reader.getSuccess(result);
+        success = (success !== false);
+        if (success){
+            this.fireEvent("write", this, action, data, res, rs, trans.request.arg);
+        }else{
+            this.fireEvent('exception', this, 'remote', action, trans, result, rs);
         }
-    },
+        trans.request.callback.call(trans.request.scope, data, res, success);
+    }
+});
+/**
+ * @class Ext.data.DirectStore
+ * @extends Ext.data.Store
+ * Small helper class to create an {@link Ext.data.Store} configured with an
+ * {@link Ext.data.DirectProxy} and {@link Ext.data.JsonReader} to make interacting
+ * with an {@link Ext.Direct} Server-side {@link Ext.direct.Provider Provider} easier.
+ * To create a different proxy/reader combination create a basic {@link Ext.data.Store}
+ * configured as needed.
+ *
+ * *Note: Although they are not listed, this class inherits all of the config options of:
+ * 
+ * {@link Ext.data.Store Store}
+ * 
+ *
+ * 
+ * {@link Ext.data.JsonReader JsonReader}
+ * 
+ * {@link Ext.data.JsonReader#root root}
+ * {@link Ext.data.JsonReader#idProperty idProperty}
+ * {@link Ext.data.JsonReader#totalProperty totalProperty}
+ * 
+ *
+ * {@link Ext.data.DirectProxy DirectProxy}
+ * 
+ * {@link Ext.data.DirectProxy#directFn directFn}
+ * {@link Ext.data.DirectProxy#paramOrder paramOrder}
+ * {@link Ext.data.DirectProxy#paramsAsHash paramsAsHash}
+ * 
+ * 
+ *
+ * @xtype directstore
+ *
+ * @constructor
+ * @param {Object} config
+ */
+Ext.data.DirectStore = Ext.extend(Ext.data.Store, {
+    constructor : function(config){
+        // each transaction upon a singe record will generate a distinct Direct transaction since Direct queues them into one Ajax request.
+        var c = Ext.apply({}, {
+            batchTransactions: false
+        }, config);
+        Ext.data.DirectStore.superclass.constructor.call(this, Ext.apply(c, {
+            proxy: Ext.isDefined(c.proxy) ? c.proxy : new Ext.data.DirectProxy(Ext.copyTo({}, c, 'paramOrder,paramsAsHash,directFn,api')),
+            reader: (!Ext.isDefined(c.reader) && c.fields) ? new Ext.data.JsonReader(Ext.copyTo({}, c, 'totalProperty,root,idProperty'), c.fields) : c.reader
+        }));
+    }
+});
+Ext.reg('directstore', Ext.data.DirectStore);
+/**
+ * @class Ext.Direct
+ * @extends Ext.util.Observable
+ * Overview
+ *
+ * Ext.Direct aims to streamline communication between the client and server
+ * by providing a single interface that reduces the amount of common code
+ * typically required to validate data and handle returned data packets
+ * (reading data, error conditions, etc).
+ *
+ * The Ext.direct namespace includes several classes for a closer integration
+ * with the server-side. The Ext.data namespace also includes classes for working
+ * with Ext.data.Stores which are backed by data from an Ext.Direct method.
+ *
+ * Specification
+ *
+ * For additional information consult the
+ * Ext.Direct Specification.
+ *
+ * Providers
+ *
+ * Ext.Direct uses a provider architecture, where one or more providers are
+ * used to transport data to and from the server. There are several providers
+ * that exist in the core at the moment:

+ *
+ * {@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations
+ * {@link Ext.direct.PollingProvider PollingProvider} for repeated requests
+ * {@link Ext.direct.RemotingProvider RemotingProvider} exposes server side
+ * on the client.
+ * 
+ *
+ * A provider does not need to be invoked directly, providers are added via
+ * {@link Ext.Direct}.{@link Ext.Direct#add add}.
+ *
+ * Router
+ *
+ * Ext.Direct utilizes a "router" on the server to direct requests from the client
+ * to the appropriate server-side method. Because the Ext.Direct API is completely
+ * platform-agnostic, you could completely swap out a Java based server solution
+ * and replace it with one that uses C# without changing the client side JavaScript
+ * at all.
+ *
+ * Server side events
+ *
+ * Custom events from the server may be handled by the client by adding
+ * listeners, for example:
+ * 
+{"type":"event","name":"message","data":"Successfully polled at: 11:19:30 am"}
 
+// add a handler for a 'message' event sent by the server
+Ext.Direct.on('message', function(e){
+    out.append(String.format('<p><i>{0}</i></p>', e.data));
+            out.el.scrollTo('t', 100000, true);
+});
+ * 
+ * @singleton
+ */
+Ext.Direct = Ext.extend(Ext.util.Observable, {
     /**
-     * Realigns the editor to the bound field based on the current alignment config value.
-     * @param {Boolean} autoSize (optional) True to size the field to the dimensions of the bound element.
+     * Each event type implements a getData() method. The default event types are:
+     * 
+     * event : Ext.Direct.Event
+     * exception : Ext.Direct.ExceptionEvent
+     * rpc : Ext.Direct.RemotingEvent
+     * 
+     * @property eventTypes
+     * @type Object
      */
-    realign : function(autoSize){
-        if(autoSize === true){
-            this.doAutoSize();
-        }
-        this.el.alignTo(this.boundEl, this.alignment, this.offsets);
+
+    /**
+     * Four types of possible exceptions which can occur:
+     * 
+     * Ext.Direct.exceptions.TRANSPORT : 'xhr'
+     * Ext.Direct.exceptions.PARSE : 'parse'
+     * Ext.Direct.exceptions.LOGIN : 'login'
+     * Ext.Direct.exceptions.SERVER : 'exception'
+     * 
+     * @property exceptions
+     * @type Object
+     */
+    exceptions: {
+        TRANSPORT: 'xhr',
+        PARSE: 'parse',
+        LOGIN: 'login',
+        SERVER: 'exception'
+    },
+
+    // private
+    constructor: function(){
+        this.addEvents(
+            /**
+             * @event event
+             * Fires after an event.
+             * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.
+             * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}.
+             */
+            'event',
+            /**
+             * @event exception
+             * Fires after an event exception.
+             * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred.
+             */
+            'exception'
+        );
+        this.transactions = {};
+        this.providers = {};
     },
 
     /**
-     * Ends the editing process, persists the changed value to the underlying field, and hides the editor.
-     * @param {Boolean} remainVisible Override the default behavior and keep the editor visible after edit (defaults to false)
+     * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods.
+     * If the provider is not already connected, it will auto-connect.
+     * 
+var pollProv = new Ext.direct.PollingProvider({
+    url: 'php/poll2.php'
+});
+
+Ext.Direct.addProvider(
+    {
+        "type":"remoting",       // create a {@link Ext.direct.RemotingProvider}
+        "url":"php\/router.php", // url to connect to the Ext.Direct server-side router.
+        "actions":{              // each property within the actions object represents a Class
+            "TestAction":[       // array of methods within each server side Class
+            {
+                "name":"doEcho", // name of method
+                "len":1
+            },{
+                "name":"multiply",
+                "len":1
+            },{
+                "name":"doForm",
+                "formHandler":true, // handle form on server with Ext.Direct.Transaction
+                "len":1
+            }]
+        },
+        "namespace":"myApplication",// namespace to create the Remoting Provider in
+    },{
+        type: 'polling', // create a {@link Ext.direct.PollingProvider}
+        url:  'php/poll.php'
+    },
+    pollProv // reference to previously created instance
+);
+     * 
+     * @param {Object/Array} provider Accepts either an Array of Provider descriptions (an instance
+     * or config object for a Provider) or any number of Provider descriptions as arguments.  Each
+     * Provider description instructs Ext.Direct how to create client-side stub methods.
      */
-    completeEdit : function(remainVisible){
-        if(!this.editing){
-            return;
-        }
-        var v = this.getValue();
-        if(!this.field.isValid()){
-            if(this.revertInvalid !== false){
-                this.cancelEdit(remainVisible);
+    addProvider : function(provider){
+        var a = arguments;
+        if(a.length > 1){
+            for(var i = 0, len = a.length; i < len; i++){
+                this.addProvider(a[i]);
             }
             return;
         }
-        if(String(v) === String(this.startValue) && this.ignoreNoChange){
-            this.hideEdit(remainVisible);
-            return;
-        }
-        if(this.fireEvent("beforecomplete", this, v, this.startValue) !== false){
-            v = this.getValue();
-            if(this.updateEl && this.boundEl){
-                this.boundEl.update(v);
-            }
-            this.hideEdit(remainVisible);
-            this.fireEvent("complete", this, v, this.startValue);
+
+        // if provider has not already been instantiated
+        if(!provider.events){
+            provider = new Ext.Direct.PROVIDERS[provider.type](provider);
         }
-    },
+        provider.id = provider.id || Ext.id();
+        this.providers[provider.id] = provider;
+
+        provider.on('data', this.onProviderData, this);
+        provider.on('exception', this.onProviderException, this);
 
-    // private
-    onShow : function(){
-        this.el.show();
-        if(this.hideEl !== false){
-            this.boundEl.hide();
+
+        if(!provider.isConnected()){
+            provider.connect();
         }
-        this.field.show().focus(false, true);
-        this.fireEvent("startedit", this.boundEl, this.startValue);
+
+        return provider;
     },
 
     /**
-     * Cancels the editing process and hides the editor without persisting any changes.  The field value will be
-     * reverted to the original starting value.
-     * @param {Boolean} remainVisible Override the default behavior and keep the editor visible after
-     * cancel (defaults to false)
+     * Retrieve a {@link Ext.direct.Provider provider} by the
+     * {@link Ext.direct.Provider#id id} specified when the provider is
+     * {@link #addProvider added}.
+     * @param {String} id Unique identifier assigned to the provider when calling {@link #addProvider}
      */
-    cancelEdit : function(remainVisible){
-        if(this.editing){
-            var v = this.getValue();
-            this.setValue(this.startValue);
-            this.hideEdit(remainVisible);
-            this.fireEvent("canceledit", this, v, this.startValue);
-        }
+    getProvider : function(id){
+        return this.providers[id];
     },
 
-    // private
-    hideEdit: function(remainVisible){
-        if(remainVisible !== true){
-            this.editing = false;
-            this.hide();
-        }
+    removeProvider : function(id){
+        var provider = id.id ? id : this.providers[id];
+        provider.un('data', this.onProviderData, this);
+        provider.un('exception', this.onProviderException, this);
+        delete this.providers[provider.id];
+        return provider;
     },
 
-    // private
-    onBlur : function(){
-        // selectSameEditor flag allows the same editor to be started without onBlur firing on itself
-        if(this.allowBlur !== true && this.editing && this.selectSameEditor !== true){
-            this.completeEdit();
-        }
+    addTransaction: function(t){
+        this.transactions[t.tid] = t;
+        return t;
     },
 
-    // private
-    onHide : function(){
-        if(this.editing){
-            this.completeEdit();
+    removeTransaction: function(t){
+        delete this.transactions[t.tid || t];
+        return t;
+    },
+
+    getTransaction: function(tid){
+        return this.transactions[tid.tid || tid];
+    },
+
+    onProviderData : function(provider, e){
+        if(Ext.isArray(e)){
+            for(var i = 0, len = e.length; i < len; i++){
+                this.onProviderData(provider, e[i]);
+            }
             return;
         }
-        this.field.blur();
-        if(this.field.collapse){
-            this.field.collapse();
-        }
-        this.el.hide();
-        if(this.hideEl !== false){
-            this.boundEl.show();
+        if(e.name && e.name != 'event' && e.name != 'exception'){
+            this.fireEvent(e.name, e);
+        }else if(e.type == 'exception'){
+            this.fireEvent('exception', e);
         }
+        this.fireEvent('event', e, provider);
     },
 
-    /**
-     * Sets the data value of the editor
-     * @param {Mixed} value Any valid value supported by the underlying field
-     */
-    setValue : function(v){
-        this.field.setValue(v);
+    createEvent : function(response, extraProps){
+        return new Ext.Direct.eventTypes[response.type](Ext.apply(response, extraProps));
+    }
+});
+// overwrite impl. with static instance
+Ext.Direct = new Ext.Direct();
+
+Ext.Direct.TID = 1;
+Ext.Direct.PROVIDERS = {};/**
+ * @class Ext.Direct.Transaction
+ * @extends Object
+ * Supporting Class for Ext.Direct (not intended to be used directly).
+ * @constructor
+ * @param {Object} config
+ */
+Ext.Direct.Transaction = function(config){
+    Ext.apply(this, config);
+    this.tid = ++Ext.Direct.TID;
+    this.retryCount = 0;
+};
+Ext.Direct.Transaction.prototype = {
+    send: function(){
+        this.provider.queueTransaction(this);
     },
 
-    /**
-     * Gets the data value of the editor
-     * @return {Mixed} The data value
-     */
-    getValue : function(){
-        return this.field.getValue();
+    retry: function(){
+        this.retryCount++;
+        this.send();
     },
 
-    beforeDestroy : function(){
-        Ext.destroyMembers(this, 'field');
+    getProvider: function(){
+        return this.provider;
+    }
+};Ext.Direct.Event = function(config){
+    Ext.apply(this, config);
+};
 
-        delete this.parentEl;
-        delete this.boundEl;
+Ext.Direct.Event.prototype = {
+    status: true,
+    getData: function(){
+        return this.data;
     }
-});
-Ext.reg('editor', Ext.Editor);
-/**
- * @class Ext.ColorPalette
- * @extends Ext.Component
- * Simple color palette class for choosing colors.  The palette can be rendered to any container.

- * Here's an example of typical usage:
- * 
-var cp = new Ext.ColorPalette({value:'993300'});  // initial selected color
-cp.render('my-div');
+};
 
-cp.on('select', function(palette, selColor){
-    // do something with selColor
+Ext.Direct.RemotingEvent = Ext.extend(Ext.Direct.Event, {
+    type: 'rpc',
+    getTransaction: function(){
+        return this.transaction || Ext.Direct.getTransaction(this.tid);
+    }
 });
-
- * @constructor
- * Create a new ColorPalette
- * @param {Object} config The config object
- * @xtype colorpalette
- */
-Ext.ColorPalette = Ext.extend(Ext.Component, {
-	/**
-	 * @cfg {String} tpl An existing XTemplate instance to be used in place of the default template for rendering the component.
-	 */
-    /**
-     * @cfg {String} itemCls
-     * The CSS class to apply to the containing element (defaults to 'x-color-palette')
-     */
-    itemCls : 'x-color-palette',
-    /**
-     * @cfg {String} value
-     * The initial color to highlight (should be a valid 6-digit color hex code without the # symbol).  Note that
-     * the hex codes are case-sensitive.
-     */
-    value : null,
-    /**
-     * @cfg {String} clickEvent
-     * The DOM event that will cause a color to be selected. This can be any valid event name (dblclick, contextmenu). 
-     * Defaults to 'click'.
-     */
-    clickEvent :'click',
-    // private
-    ctype : 'Ext.ColorPalette',
 
-    /**
-     * @cfg {Boolean} allowReselect If set to true then reselecting a color that is already selected fires the {@link #select} event
-     */
-    allowReselect : false,
+Ext.Direct.ExceptionEvent = Ext.extend(Ext.Direct.RemotingEvent, {
+    status: false,
+    type: 'exception'
+});
 
+Ext.Direct.eventTypes = {
+    'rpc':  Ext.Direct.RemotingEvent,
+    'event':  Ext.Direct.Event,
+    'exception':  Ext.Direct.ExceptionEvent
+};
+/**
+ * @class Ext.direct.Provider
+ * @extends Ext.util.Observable
+ * Ext.direct.Provider is an abstract class meant to be extended.
+ * 
+ * For example ExtJs implements the following subclasses:
+ * 
+Provider
+|
++---{@link Ext.direct.JsonProvider JsonProvider} 
+    |
+    +---{@link Ext.direct.PollingProvider PollingProvider}   
+    |
+    +---{@link Ext.direct.RemotingProvider RemotingProvider}   
+ * 
+ * @abstract
+ */
+Ext.direct.Provider = Ext.extend(Ext.util.Observable, {    
     /**
-     * An array of 6-digit color hex code strings (without the # symbol).  This array can contain any number
-     * of colors, and each hex code should be unique.  The width of the palette is controlled via CSS by adjusting
-     * the width property of the 'x-color-palette' class (or assigning a custom class), so you can balance the number
-     * of colors with the width setting until the box is symmetrical.
-     * You can override individual colors if needed:
+     * @cfg {String} id
+     * The unique id of the provider (defaults to an {@link Ext#id auto-assigned id}).
+     * You should assign an id if you need to be able to access the provider later and you do
+     * not have an object reference available, for example:
      * 
-var cp = new Ext.ColorPalette();
-cp.colors[0] = 'FF0000';  // change the first box to red
-
-
-Or you can provide a custom array of your own for complete control:
-
-var cp = new Ext.ColorPalette();
-cp.colors = ['000000', '993300', '333300'];
-
-     * @type Array
+Ext.Direct.addProvider(
+    {
+        type: 'polling',
+        url:  'php/poll.php',
+        id:   'poll-provider'
+    }
+);
+     
+var p = {@link Ext.Direct Ext.Direct}.{@link Ext.Direct#getProvider getProvider}('poll-provider');
+p.disconnect();
+     *

*/ - colors : [ - '000000', '993300', '333300', '003300', '003366', '000080', '333399', '333333', - '800000', 'FF6600', '808000', '008000', '008080', '0000FF', '666699', '808080', - 'FF0000', 'FF9900', '99CC00', '339966', '33CCCC', '3366FF', '800080', '969696', - 'FF00FF', 'FFCC00', 'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0', - 'FF99CC', 'FFCC99', 'FFFF99', 'CCFFCC', 'CCFFFF', '99CCFF', 'CC99FF', 'FFFFFF' - ], + + /** + * @cfg {Number} priority + * Priority of the request. Lower is higher priority, 0 means "duplex" (always on). + * All Providers default to 1 except for PollingProvider which defaults to 3. + */ + priority: 1, /** - * @cfg {Function} handler - * Optional. A function that will handle the select event of this palette. - * The handler is passed the following parameters:

palette : ColorPalette
The {@link #palette Ext.ColorPalette}.
color : String
The 6-digit color hex code (without the # symbol).

Required

undefined

type

polling : {@link Ext.direct.PollingProvider PollingProvider}
remoting : {@link Ext.direct.RemotingProvider RemotingProvider}

this

{@link #handler}

Provides for repetitive polling of the server at distinct {@link #interval intervals}. + * The initial request for data originates from the client, and then is responded to by the + * server.

All configurations for the PollingProvider should be generated by the server-side + * API portion of the Ext.Direct stack.

An instance of PollingProvider may be created directly via the new keyword or by simply + * specifying type = 'polling'. For example:


+var pollA = new Ext.direct.PollingProvider({
+    type:'polling',
+    url: 'php/pollA.php',
 });
-Ext.reg('colorpalette', Ext.ColorPalette);
-/**
- * @class Ext.DatePicker
- * @extends Ext.Component
- * A popup date picker. This class is used by the {@link Ext.form.DateField DateField} class
- * to allow browsing and selection of valid dates.
- * All the string values documented below may be overridden by including an Ext locale file in
- * your page.
- * @constructor
- * Create a new DatePicker
- * @param {Object} config The config object
- * @xtype datepicker
+Ext.Direct.addProvider(pollA);
+pollA.disconnect();
+
+Ext.Direct.addProvider(
+    {
+        type:'polling',
+        url: 'php/pollB.php',
+        id: 'pollB-provider'
+    }
+);
+var pollB = Ext.Direct.getProvider('pollB-provider');
+ *

'Today'

' OK '

'Cancel'

picker : DatePicker
This DatePicker.
date : Date
The selected date.

this

{@link #handler}

'{0} (Spacebar)'

{0}

'This date is before the minimum date'

'This date is after the maximum date'

'm/d/y'

'Disabled'

'Next Month (Control+Right)'

'Previous Month (Control+Left)'

'Choose a month (Control+Up/Down to move years)'

true

3

3000

['03/08/2003', '09/16/2003'] would disable those exact dates
['03/08', '09/16'] would disable those days for every year
['^03/08'] would only match the beginning (useful if you are using short years)
['03/../2006'] would disable every day in March 2006
['^03'] would disable every day in every March

The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to + * server side methods on the client (a remote procedure call (RPC) type of + * connection where the client can initiate a procedure on the server).

This allows for code to be organized in a fashion that is maintainable, + * while providing a clear path between client and server, something that is + * not always apparent when using URLs.

To accomplish this the server-side needs to describe what classes and methods + * are available on the client-side. This configuration will typically be + * outputted by the server-side Ext.Direct stack when the API description is built.


+"actions":{ // each property within the 'actions' object represents a server side Class 
+    "TestAction":[ // array of methods within each server side Class to be   
+    {              // stubbed out on client
+        "name":"doEcho", 
+        "len":1            
+    },{
+        "name":"multiply",// name of method
+        "len":2           // The number of parameters that will be used to create an
+                          // array of data to send to the server side function.
+                          // Ensure the server sends back a Number, not a String. 
+    },{
+        "name":"doForm",
+        "formHandler":true, // direct the client to use specialized form handling method 
+        "len":1
+    }]
+}
+     *

Note that a Store is not required, a server method can be called at any time. + * In the following example a client side handler is used to call the + * server side method "multiply" in the server-side "TestAction" Class:


+TestAction.multiply(
+    2, 4, // pass two arguments to server, so specify len=2
+    // callback function after the server is called
+    // result: the result returned by the server
+    //      e: Ext.Direct.RemotingEvent object
+    function(result, e){
+        var t = e.getTransaction();
+        var action = t.action; // server side Class called
+        var method = t.method; // server side method called
+        if(e.status){
+            var answer = Ext.encode(result); // 8
+    
+        }else{
+            var msg = e.message; // failure message
+        }
+    }
+);
+     *

result

window

Required. The url to connect to the {@link Ext.Direct} server-side router. + */ + + /** + * @cfg {String} enableUrlEncode + * Specify which param will hold the arguments for the method. + * Defaults to 'data'. + */ + + /** + * @cfg {Number/Boolean} enableBuffer + *
true or false to enable or disable combining of method + * calls. If a number is specified this is the amount of time in milliseconds + * to wait before sending a batched request (defaults to 10).
+ *
Calls which are received within the specified timeframe will be + * concatenated together and sent in a single request, optimizing the + * application by reducing the amount of round trips that have to be made + * to the server.
*/ - setMaxDate : function(dt){ - this.maxDate = dt; - this.update(this.value, true); - }, - + enableBuffer: 10, + /** - * Sets the value of the date field - * @param {Date} value The date to set + * @cfg {Number} maxRetries + * Number of times to re-attempt delivery on failure of a call. Defaults to 1. */ - setValue : function(value){ - this.value = value.clearTime(true); - this.update(this.value); - }, - + maxRetries: 1, + /** - * Gets the current selected value of the date field - * @return {Date} The selected date + * @cfg {Number} timeout + * The timeout to use for each request. Defaults to undefined. */ - getValue : function(){ - return this.value; - }, + timeout: undefined, - // private - focus : function(){ - this.update(this.activeDate); + constructor : function(config){ + Ext.direct.RemotingProvider.superclass.constructor.call(this, config); + this.addEvents( + /** + * @event beforecall + * Fires immediately before the client-side sends off the RPC call. + * By returning false from an event handler you can prevent the call from + * executing. + * @param {Ext.direct.RemotingProvider} provider + * @param {Ext.Direct.Transaction} transaction + */ + 'beforecall', + /** + * @event call + * Fires immediately after the request to the server-side is sent. This does + * NOT fire after the response has come back from the call. + * @param {Ext.direct.RemotingProvider} provider + * @param {Ext.Direct.Transaction} transaction + */ + 'call' + ); + this.namespace = (Ext.isString(this.namespace)) ? Ext.ns(this.namespace) : this.namespace || window; + this.transactions = {}; + this.callBuffer = []; }, - + // private - onEnable: function(initial){ - Ext.DatePicker.superclass.onEnable.call(this); - this.doDisabled(false); - this.update(initial ? this.value : this.activeDate); - if(Ext.isIE){ - this.el.repaint(); + initAPI : function(){ + var o = this.actions; + for(var c in o){ + var cls = this.namespace[c] || (this.namespace[c] = {}), + ms = o[c]; + for(var i = 0, len = ms.length; i < len; i++){ + var m = ms[i]; + cls[m.name] = this.createMethod(c, m); + } } - }, - - // private - onDisable : function(){ - Ext.DatePicker.superclass.onDisable.call(this); - this.doDisabled(true); - if(Ext.isIE && !Ext.isIE8){ - /* Really strange problem in IE6/7, when disabled, have to explicitly - * repaint each of the nodes to get them to display correctly, simply - * calling repaint on the main element doesn't appear to be enough. - */ - Ext.each([].concat(this.textNodes, this.el.query('th span')), function(el){ - Ext.fly(el).repaint(); - }); + + // inherited + isConnected: function(){ + return !!this.connected; + }, + + connect: function(){ + if(this.url){ + this.initAPI(); + this.connected = true; + this.fireEvent('connect', this); + }else if(!this.url){ + throw 'Error initializing RemotingProvider, no url configured.'; } }, - - // private - doDisabled : function(disabled){ - this.keyNav.setDisabled(disabled); - this.prevRepeater.setDisabled(disabled); - this.nextRepeater.setDisabled(disabled); - if(this.showToday){ - this.todayKeyListener.setDisabled(disabled); - this.todayBtn.setDisabled(disabled); + + disconnect: function(){ + if(this.connected){ + this.connected = false; + this.fireEvent('disconnect', this); } }, - // private - onRender : function(container, position){ - var m = [ - '', - '', - '', - this.showToday ? '' : '', - '

'], - dn = this.dayNames, - i; - for(i = 0; i < 7; i++){ - var d = this.startDay+i; - if(d > 6){ - d = d-7; + onData: function(opt, success, xhr){ + if(success){ + var events = this.getEvents(xhr); + for(var i = 0, len = events.length; i < len; i++){ + var e = events[i], + t = this.getTransaction(e); + this.fireEvent('data', this, e); + if(t){ + this.doCallback(t, e, true); + Ext.Direct.removeTransaction(t); + } } - m.push(''); - } - m[m.length] = ''; - for(i = 0; i < 42; i++) { - if(i % 7 === 0 && i !== 0){ - m[m.length] = ''; + }else{ + var ts = [].concat(opt.ts); + for(var i = 0, len = ts.length; i < len; i++){ + var t = this.getTransaction(ts[i]); + if(t && t.retryCount < this.maxRetries){ + t.retry(); + }else{ + var e = new Ext.Direct.ExceptionEvent({ + data: e, + transaction: t, + code: Ext.Direct.exceptions.TRANSPORT, + message: 'Unable to connect to the server.', + xhr: xhr + }); + this.fireEvent('data', this, e); + if(t){ + this.doCallback(t, e, false); + Ext.Direct.removeTransaction(t); + } + } } - m[m.length] = ''; } - m.push('
', dn[d].substr(0,1), '
'); - - var el = document.createElement('div'); - el.className = 'x-date-picker'; - el.innerHTML = m.join(''); - - container.dom.insertBefore(el, position); - - this.el = Ext.get(el); - this.eventEl = Ext.get(el.firstChild); + }, - this.prevRepeater = new Ext.util.ClickRepeater(this.el.child('td.x-date-left a'), { - handler: this.showPrevMonth, - scope: this, - preventDefault:true, - stopDefault:true - }); + getCallData: function(t){ + return { + action: t.action, + method: t.method, + data: t.data, + type: 'rpc', + tid: t.tid + }; + }, - this.nextRepeater = new Ext.util.ClickRepeater(this.el.child('td.x-date-right a'), { - handler: this.showNextMonth, + doSend : function(data){ + var o = { + url: this.url, + callback: this.onData, scope: this, - preventDefault:true, - stopDefault:true - }); - - this.monthPicker = this.el.down('div.x-date-mp'); - this.monthPicker.enableDisplayMode('block'); - - this.keyNav = new Ext.KeyNav(this.eventEl, { - 'left' : function(e){ - if(e.ctrlKey){ - this.showPrevMonth(); - }else{ - this.update(this.activeDate.add('d', -1)); - } - }, + ts: data, + timeout: this.timeout + }, callData; - 'right' : function(e){ - if(e.ctrlKey){ - this.showNextMonth(); - }else{ - this.update(this.activeDate.add('d', 1)); - } - }, + if(Ext.isArray(data)){ + callData = []; + for(var i = 0, len = data.length; i < len; i++){ + callData.push(this.getCallData(data[i])); + } + }else{ + callData = this.getCallData(data); + } - 'up' : function(e){ - if(e.ctrlKey){ - this.showNextYear(); - }else{ - this.update(this.activeDate.add('d', -7)); - } - }, + if(this.enableUrlEncode){ + var params = {}; + params[Ext.isString(this.enableUrlEncode) ? this.enableUrlEncode : 'data'] = Ext.encode(callData); + o.params = params; + }else{ + o.jsonData = callData; + } + Ext.Ajax.request(o); + }, - 'down' : function(e){ - if(e.ctrlKey){ - this.showPrevYear(); - }else{ - this.update(this.activeDate.add('d', 7)); - } - }, + combineAndSend : function(){ + var len = this.callBuffer.length; + if(len > 0){ + this.doSend(len == 1 ? this.callBuffer[0] : this.callBuffer); + this.callBuffer = []; + } + }, - 'pageUp' : function(e){ - this.showNextMonth(); - }, + queueTransaction: function(t){ + if(t.form){ + this.processForm(t); + return; + } + this.callBuffer.push(t); + if(this.enableBuffer){ + if(!this.callTask){ + this.callTask = new Ext.util.DelayedTask(this.combineAndSend, this); + } + this.callTask.delay(Ext.isNumber(this.enableBuffer) ? this.enableBuffer : 10); + }else{ + this.combineAndSend(); + } + }, - 'pageDown' : function(e){ - this.showPrevMonth(); - }, + doCall : function(c, m, args){ + var data = null, hs = args[m.len], scope = args[m.len+1]; - 'enter' : function(e){ - e.stopPropagation(); - return true; - }, + if(m.len !== 0){ + data = args.slice(0, m.len); + } - scope : this + var t = new Ext.Direct.Transaction({ + provider: this, + args: args, + action: c, + method: m.name, + data: data, + cb: scope && Ext.isFunction(hs) ? hs.createDelegate(scope) : hs }); - this.el.unselectable(); - - this.cells = this.el.select('table.x-date-inner tbody td'); - this.textNodes = this.el.query('table.x-date-inner tbody span'); + if(this.fireEvent('beforecall', this, t) !== false){ + Ext.Direct.addTransaction(t); + this.queueTransaction(t); + this.fireEvent('call', this, t); + } + }, - this.mbtn = new Ext.Button({ - text: ' ', - tooltip: this.monthYearText, - renderTo: this.el.child('td.x-date-middle', true) + doForm : function(c, m, form, callback, scope){ + var t = new Ext.Direct.Transaction({ + provider: this, + action: c, + method: m.name, + args:[form, callback, scope], + cb: scope && Ext.isFunction(callback) ? callback.createDelegate(scope) : callback, + isForm: true }); - this.mbtn.el.child('em').addClass('x-btn-arrow'); - if(this.showToday){ - this.todayKeyListener = this.eventEl.addKeyListener(Ext.EventObject.SPACE, this.selectToday, this); - var today = (new Date()).dateFormat(this.format); - this.todayBtn = new Ext.Button({ - renderTo: this.el.child('td.x-date-bottom', true), - text: String.format(this.todayText, today), - tooltip: String.format(this.todayTip, today), - handler: this.selectToday, - scope: this + if(this.fireEvent('beforecall', this, t) !== false){ + Ext.Direct.addTransaction(t); + var isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data', + params = { + extTID: t.tid, + extAction: c, + extMethod: m.name, + extType: 'rpc', + extUpload: String(isUpload) + }; + + // change made from typeof callback check to callback.params + // to support addl param passing in DirectSubmit EAC 6/2 + Ext.apply(t, { + form: Ext.getDom(form), + isUpload: isUpload, + params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params }); + this.fireEvent('call', this, t); + this.processForm(t); } - this.mon(this.eventEl, 'mousewheel', this.handleMouseWheel, this); - this.mon(this.eventEl, 'click', this.handleDateClick, this, {delegate: 'a.x-date-date'}); - this.mon(this.mbtn, 'click', this.showMonthPicker, this); - this.onEnable(true); + }, + + processForm: function(t){ + Ext.Ajax.request({ + url: this.url, + params: t.params, + callback: this.onData, + scope: this, + form: t.form, + isUpload: t.isUpload, + ts: t + }); }, - // private - createMonthPicker : function(){ - if(!this.monthPicker.dom.firstChild){ - var buf = ['']; - for(var i = 0; i < 6; i++){ - buf.push( - '', - '', - i === 0 ? - '' : - '' - ); - } - buf.push( - '', - '
', Date.getShortMonthName(i), ' ', Date.getShortMonthName(i + 6), '
' - ); - this.monthPicker.update(buf.join('')); - - this.mon(this.monthPicker, 'click', this.onMonthClick, this); - this.mon(this.monthPicker, 'dblclick', this.onMonthDblClick, this); - - this.mpMonths = this.monthPicker.select('td.x-date-mp-month'); - this.mpYears = this.monthPicker.select('td.x-date-mp-year'); - - this.mpMonths.each(function(m, a, i){ - i += 1; - if((i%2) === 0){ - m.dom.xmonth = 5 + Math.round(i * 0.5); - }else{ - m.dom.xmonth = Math.round((i-1) * 0.5); - } - }); + createMethod : function(c, m){ + var f; + if(!m.formHandler){ + f = function(){ + this.doCall(c, m, Array.prototype.slice.call(arguments, 0)); + }.createDelegate(this); + }else{ + f = function(form, callback, scope){ + this.doForm(c, m, form, callback, scope); + }.createDelegate(this); } + f.directCfg = { + action: c, + method: m + }; + return f; }, - // private - showMonthPicker : function(){ - if(!this.disabled){ - this.createMonthPicker(); - var size = this.el.getSize(); - this.monthPicker.setSize(size); - this.monthPicker.child('table').setSize(size); - - this.mpSelMonth = (this.activeDate || this.value).getMonth(); - this.updateMPMonth(this.mpSelMonth); - this.mpSelYear = (this.activeDate || this.value).getFullYear(); - this.updateMPYear(this.mpSelYear); - - this.monthPicker.slideIn('t', {duration:0.2}); - } + getTransaction: function(opt){ + return opt && opt.tid ? Ext.Direct.getTransaction(opt.tid) : null; }, - // private - updateMPYear : function(y){ - this.mpyear = y; - var ys = this.mpYears.elements; - for(var i = 1; i <= 10; i++){ - var td = ys[i-1], y2; - if((i%2) === 0){ - y2 = y + Math.round(i * 0.5); - td.firstChild.innerHTML = y2; - td.xyear = y2; - }else{ - y2 = y - (5-Math.round(i * 0.5)); - td.firstChild.innerHTML = y2; - td.xyear = y2; + doCallback: function(t, e){ + var fn = e.status ? 'success' : 'failure'; + if(t && t.cb){ + var hs = t.cb, + result = Ext.isDefined(e.result) ? e.result : e.data; + if(Ext.isFunction(hs)){ + hs(result, e); + } else{ + Ext.callback(hs[fn], hs.scope, [result, e]); + Ext.callback(hs.callback, hs.scope, [result, e]); } - this.mpYears.item(i-1)[y2 == this.mpSelYear ? 'addClass' : 'removeClass']('x-date-mp-sel'); } - }, + } +}); +Ext.Direct.PROVIDERS['remoting'] = Ext.direct.RemotingProvider;/** + * @class Ext.Resizable + * @extends Ext.util.Observable + *
Applies drag handles to an element to make it resizable. The drag handles are inserted into the element + * and positioned absolute. Some elements, such as a textarea or image, don't support this. To overcome that, you can wrap + * the textarea in a div and set 'resizeChild' to true (or to the id of the element), or set wrap:true in your config and + * the element will be wrapped for you automatically.
+ *
Here is the list of valid resize handles:
+ *
+Value Description +------ ------------------- + 'n' north + 's' south + 'e' east + 'w' west + 'nw' northwest + 'sw' southwest + 'se' southeast + 'ne' northeast + 'all' all +
+ *
Here's an example showing the creation of a typical Resizable:
+ *
+var resizer = new Ext.Resizable('element-id', { + handles: 'all', + minWidth: 200, + minHeight: 100, + maxWidth: 500, + maxHeight: 400, + pinned: true +}); +resizer.on('resize', myHandler); +
+ *
To hide a particular handle, set its display to none in CSS, or through script:
+ * resizer.east.setDisplayed(false);
+ * @constructor + * Create a new resizable component + * @param {Mixed} el The id or element to resize + * @param {Object} config configuration options + */ +Ext.Resizable = Ext.extend(Ext.util.Observable, { - // private - updateMPMonth : function(sm){ - this.mpMonths.each(function(m, a, i){ - m[m.dom.xmonth == sm ? 'addClass' : 'removeClass']('x-date-mp-sel'); - }); - }, + constructor: function(el, config){ + this.el = Ext.get(el); + if(config && config.wrap){ + config.resizeChild = this.el; + this.el = this.el.wrap(typeof config.wrap == 'object' ? config.wrap : {cls:'xresizable-wrap'}); + this.el.id = this.el.dom.id = config.resizeChild.id + '-rzwrap'; + this.el.setStyle('overflow', 'hidden'); + this.el.setPositioning(config.resizeChild.getPositioning()); + config.resizeChild.clearPositioning(); + if(!config.width || !config.height){ + var csize = config.resizeChild.getSize(); + this.el.setSize(csize.width, csize.height); + } + if(config.pinned && !config.adjustments){ + config.adjustments = 'auto'; + } + } - // private - selectMPMonth : function(m){ + /** + * The proxy Element that is resized in place of the real Element during the resize operation. + * This may be queried using {@link Ext.Element#getBox} to provide the new area to resize to. + * Read only. + * @type Ext.Element. + * @property proxy + */ + this.proxy = this.el.createProxy({tag: 'div', cls: 'x-resizable-proxy', id: this.el.id + '-rzproxy'}, Ext.getBody()); + this.proxy.unselectable(); + this.proxy.enableDisplayMode('block'); - }, + Ext.apply(this, config); - // private - onMonthClick : function(e, t){ - e.stopEvent(); - var el = new Ext.Element(t), pn; - if(el.is('button.x-date-mp-cancel')){ - this.hideMonthPicker(); - } - else if(el.is('button.x-date-mp-ok')){ - var d = new Date(this.mpSelYear, this.mpSelMonth, (this.activeDate || this.value).getDate()); - if(d.getMonth() != this.mpSelMonth){ - // 'fix' the JS rolling date conversion if needed - d = new Date(this.mpSelYear, this.mpSelMonth, 1).getLastDateOfMonth(); - } - this.update(d); - this.hideMonthPicker(); + if(this.pinned){ + this.disableTrackOver = true; + this.el.addClass('x-resizable-pinned'); } - else if((pn = el.up('td.x-date-mp-month', 2))){ - this.mpMonths.removeClass('x-date-mp-sel'); - pn.addClass('x-date-mp-sel'); - this.mpSelMonth = pn.dom.xmonth; + // if the element isn't positioned, make it relative + var position = this.el.getStyle('position'); + if(position != 'absolute' && position != 'fixed'){ + this.el.setStyle('position', 'relative'); } - else if((pn = el.up('td.x-date-mp-year', 2))){ - this.mpYears.removeClass('x-date-mp-sel'); - pn.addClass('x-date-mp-sel'); - this.mpSelYear = pn.dom.xyear; + if(!this.handles){ // no handles passed, must be legacy style + this.handles = 's,e,se'; + if(this.multiDirectional){ + this.handles += ',n,w'; + } } - else if(el.is('a.x-date-mp-prev')){ - this.updateMPYear(this.mpyear-10); + if(this.handles == 'all'){ + this.handles = 'n s e w ne nw se sw'; } - else if(el.is('a.x-date-mp-next')){ - this.updateMPYear(this.mpyear+10); + var hs = this.handles.split(/\s*?[,;]\s*?| /); + var ps = Ext.Resizable.positions; + for(var i = 0, len = hs.length; i < len; i++){ + if(hs[i] && ps[hs[i]]){ + var pos = ps[hs[i]]; + this[pos] = new Ext.Resizable.Handle(this, pos, this.disableTrackOver, this.transparent, this.handleCls); + } } - }, + // legacy + this.corner = this.southeast; - // private - onMonthDblClick : function(e, t){ - e.stopEvent(); - var el = new Ext.Element(t), pn; - if((pn = el.up('td.x-date-mp-month', 2))){ - this.update(new Date(this.mpSelYear, pn.dom.xmonth, (this.activeDate || this.value).getDate())); - this.hideMonthPicker(); - } - else if((pn = el.up('td.x-date-mp-year', 2))){ - this.update(new Date(pn.dom.xyear, this.mpSelMonth, (this.activeDate || this.value).getDate())); - this.hideMonthPicker(); + if(this.handles.indexOf('n') != -1 || this.handles.indexOf('w') != -1){ + this.updateBox = true; } - }, - // private - hideMonthPicker : function(disableAnim){ - if(this.monthPicker){ - if(disableAnim === true){ - this.monthPicker.hide(); + this.activeHandle = null; + + if(this.resizeChild){ + if(typeof this.resizeChild == 'boolean'){ + this.resizeChild = Ext.get(this.el.dom.firstChild, true); }else{ - this.monthPicker.slideOut('t', {duration:0.2}); + this.resizeChild = Ext.get(this.resizeChild, true); } } - }, - - // private - showPrevMonth : function(e){ - this.update(this.activeDate.add('mo', -1)); - }, - - // private - showNextMonth : function(e){ - this.update(this.activeDate.add('mo', 1)); - }, - - // private - showPrevYear : function(){ - this.update(this.activeDate.add('y', -1)); - }, - - // private - showNextYear : function(){ - this.update(this.activeDate.add('y', 1)); - }, - // private - handleMouseWheel : function(e){ - e.stopEvent(); - if(!this.disabled){ - var delta = e.getWheelDelta(); - if(delta > 0){ - this.showPrevMonth(); - } else if(delta < 0){ - this.showNextMonth(); + if(this.adjustments == 'auto'){ + var rc = this.resizeChild; + var hw = this.west, he = this.east, hn = this.north, hs = this.south; + if(rc && (hw || hn)){ + rc.position('relative'); + rc.setLeft(hw ? hw.el.getWidth() : 0); + rc.setTop(hn ? hn.el.getHeight() : 0); } + this.adjustments = [ + (he ? -he.el.getWidth() : 0) + (hw ? -hw.el.getWidth() : 0), + (hn ? -hn.el.getHeight() : 0) + (hs ? -hs.el.getHeight() : 0) -1 + ]; } - }, - // private - handleDateClick : function(e, t){ - e.stopEvent(); - if(!this.disabled && t.dateValue && !Ext.fly(t.parentNode).hasClass('x-date-disabled')){ - this.cancelFocus = this.focusOnSelect === false; - this.setValue(new Date(t.dateValue)); - delete this.cancelFocus; - this.fireEvent('select', this, this.value); + if(this.draggable){ + this.dd = this.dynamic ? + this.el.initDD(null) : this.el.initDDProxy(null, {dragElId: this.proxy.id}); + this.dd.setHandleElId(this.resizeChild ? this.resizeChild.id : this.el.id); + if(this.constrainTo){ + this.dd.constrainTo(this.constrainTo); + } } - }, - // private - selectToday : function(){ - if(this.todayBtn && !this.todayBtn.disabled){ - this.setValue(new Date().clearTime()); - this.fireEvent('select', this, this.value); - } - }, + this.addEvents( + /** + * @event beforeresize + * Fired before resize is allowed. Set {@link #enabled} to false to cancel resize. + * @param {Ext.Resizable} this + * @param {Ext.EventObject} e The mousedown event + */ + 'beforeresize', + /** + * @event resize + * Fired after a resize. + * @param {Ext.Resizable} this + * @param {Number} width The new width + * @param {Number} height The new height + * @param {Ext.EventObject} e The mouseup event + */ + 'resize' + ); - // private - update : function(date, forceRefresh){ - if(this.rendered){ - var vd = this.activeDate, vis = this.isVisible(); - this.activeDate = date; - if(!forceRefresh && vd && this.el){ - var t = date.getTime(); - if(vd.getMonth() == date.getMonth() && vd.getFullYear() == date.getFullYear()){ - this.cells.removeClass('x-date-selected'); - this.cells.each(function(c){ - if(c.dom.firstChild.dateValue == t){ - c.addClass('x-date-selected'); - if(vis && !this.cancelFocus){ - Ext.fly(c.dom.firstChild).focus(50); - } - return false; - } - }, this); - return; - } - } - var days = date.getDaysInMonth(), - firstOfMonth = date.getFirstDateOfMonth(), - startingPos = firstOfMonth.getDay()-this.startDay; - - if(startingPos < 0){ - startingPos += 7; - } - days += startingPos; - - var pm = date.add('mo', -1), - prevStart = pm.getDaysInMonth()-startingPos, - cells = this.cells.elements, - textEls = this.textNodes, - // convert everything to numbers so it's fast - day = 86400000, - d = (new Date(pm.getFullYear(), pm.getMonth(), prevStart)).clearTime(), - today = new Date().clearTime().getTime(), - sel = date.clearTime(true).getTime(), - min = this.minDate ? this.minDate.clearTime(true) : Number.NEGATIVE_INFINITY, - max = this.maxDate ? this.maxDate.clearTime(true) : Number.POSITIVE_INFINITY, - ddMatch = this.disabledDatesRE, - ddText = this.disabledDatesText, - ddays = this.disabledDays ? this.disabledDays.join('') : false, - ddaysText = this.disabledDaysText, - format = this.format; - - if(this.showToday){ - var td = new Date().clearTime(), - disable = (td < min || td > max || - (ddMatch && format && ddMatch.test(td.dateFormat(format))) || - (ddays && ddays.indexOf(td.getDay()) != -1)); - - if(!this.disabled){ - this.todayBtn.setDisabled(disable); - this.todayKeyListener[disable ? 'disable' : 'enable'](); - } - } - - var setCellClass = function(cal, cell){ - cell.title = ''; - var t = d.getTime(); - cell.firstChild.dateValue = t; - if(t == today){ - cell.className += ' x-date-today'; - cell.title = cal.todayText; - } - if(t == sel){ - cell.className += ' x-date-selected'; - if(vis){ - Ext.fly(cell.firstChild).focus(50); - } - } - // disabling - if(t < min) { - cell.className = ' x-date-disabled'; - cell.title = cal.minText; - return; - } - if(t > max) { - cell.className = ' x-date-disabled'; - cell.title = cal.maxText; - return; - } - if(ddays){ - if(ddays.indexOf(d.getDay()) != -1){ - cell.title = ddaysText; - cell.className = ' x-date-disabled'; - } - } - if(ddMatch && format){ - var fvalue = d.dateFormat(format); - if(ddMatch.test(fvalue)){ - cell.title = ddText.replace('%0', fvalue); - cell.className = ' x-date-disabled'; - } - } - }; - - var i = 0; - for(; i < startingPos; i++) { - textEls[i].innerHTML = (++prevStart); - d.setDate(d.getDate()+1); - cells[i].className = 'x-date-prevday'; - setCellClass(this, cells[i]); - } - for(; i < days; i++){ - var intDay = i - startingPos + 1; - textEls[i].innerHTML = (intDay); - d.setDate(d.getDate()+1); - cells[i].className = 'x-date-active'; - setCellClass(this, cells[i]); - } - var extraDays = 0; - for(; i < 42; i++) { - textEls[i].innerHTML = (++extraDays); - d.setDate(d.getDate()+1); - cells[i].className = 'x-date-nextday'; - setCellClass(this, cells[i]); - } - - this.mbtn.setText(this.monthNames[date.getMonth()] + ' ' + date.getFullYear()); - - if(!this.internalRender){ - var main = this.el.dom.firstChild, - w = main.offsetWidth; - this.el.setWidth(w + this.el.getBorderWidth('lr')); - Ext.fly(main).setWidth(w); - this.internalRender = true; - // opera does not respect the auto grow header center column - // then, after it gets a width opera refuses to recalculate - // without a second pass - if(Ext.isOpera && !this.secondPass){ - main.rows[0].cells[1].style.width = (w - (main.rows[0].cells[0].offsetWidth+main.rows[0].cells[2].offsetWidth)) + 'px'; - this.secondPass = true; - this.update.defer(10, this, [date]); - } - } + if(this.width !== null && this.height !== null){ + this.resizeTo(this.width, this.height); + }else{ + this.updateChildSize(); } - }, - - // private - beforeDestroy : function() { - if(this.rendered){ - Ext.destroy( - this.keyNav, - this.monthPicker, - this.eventEl, - this.mbtn, - this.nextRepeater, - this.prevRepeater, - this.cells.el, - this.todayBtn - ); - delete this.textNodes; - delete this.cells.elements; + if(Ext.isIE){ + this.el.dom.style.zoom = 1; } - } - - /** - * @cfg {String} autoEl @hide - */ -}); - -Ext.reg('datepicker', Ext.DatePicker); -/** - * @class Ext.LoadMask - * A simple utility class for generically masking elements while loading data. If the {@link #store} - * config option is specified, the masking will be automatically synchronized with the store's loading - * process and the mask element will be cached for reuse. For all other elements, this mask will replace the - * element's Updater load indicator and will be destroyed after the initial load. - *
Example usage:
- *
-// Basic mask: -var myMask = new Ext.LoadMask(Ext.getBody(), {msg:"Please wait..."}); -myMask.show(); -
- * @constructor - * Create a new LoadMask - * @param {Mixed} el The element or DOM node, or its id - * @param {Object} config The config object - */ -Ext.LoadMask = function(el, config){ - this.el = Ext.get(el); - Ext.apply(this, config); - if(this.store){ - this.store.on({ - scope: this, - beforeload: this.onBeforeLoad, - load: this.onLoad, - exception: this.onLoad - }); - this.removeMask = Ext.value(this.removeMask, false); - }else{ - var um = this.el.getUpdater(); - um.showLoadIndicator = false; // disable the default indicator - um.on({ - scope: this, - beforeupdate: this.onBeforeLoad, - update: this.onLoad, - failure: this.onLoad - }); - this.removeMask = Ext.value(this.removeMask, true); - } -}; + Ext.Resizable.superclass.constructor.call(this); + }, -Ext.LoadMask.prototype = { /** - * @cfg {Ext.data.Store} store - * Optional Store to which the mask is bound. The mask is displayed when a load request is issued, and - * hidden on either load sucess, or load fail. + * @cfg {Array/String} adjustments String 'auto' or an array [width, height] with values to be added to the + * resize operation's new size (defaults to [0, 0]) */ + adjustments : [0, 0], /** - * @cfg {Boolean} removeMask - * True to create a single-use mask that is automatically destroyed after loading (useful for page loads), - * False to persist the mask element reference for multiple uses (e.g., for paged data widgets). Defaults to false. + * @cfg {Boolean} animate True to animate the resize (not compatible with dynamic sizing, defaults to false) */ + animate : false, /** - * @cfg {String} msg - * The text to display in a centered loading message box (defaults to 'Loading...') + * @cfg {Mixed} constrainTo Constrain the resize to a particular element */ - msg : 'Loading...', /** - * @cfg {String} msgCls - * The CSS class to apply to the loading message element (defaults to "x-mask-loading") + * @cfg {Boolean} disableTrackOver True to disable mouse tracking. This is only applied at config time. (defaults to false) */ - msgCls : 'x-mask-loading', - + disableTrackOver : false, /** - * Read-only. True if the mask is currently disabled so that it will not be displayed (defaults to false) - * @type Boolean + * @cfg {Boolean} draggable Convenience to initialize drag drop (defaults to false) */ - disabled: false, - + draggable: false, /** - * Disables the mask to prevent it from being displayed + * @cfg {Number} duration Animation duration if animate = true (defaults to 0.35) */ - disable : function(){ - this.disabled = true; - }, - + duration : 0.35, /** - * Enables the mask so that it can be displayed + * @cfg {Boolean} dynamic True to resize the element while dragging instead of using a proxy (defaults to false) */ - enable : function(){ - this.disabled = false; - }, - - // private - onLoad : function(){ - this.el.unmask(this.removeMask); - }, - - // private - onBeforeLoad : function(){ - if(!this.disabled){ - this.el.mask(this.msg, this.msgCls); - } - }, - + dynamic : false, /** - * Show this LoadMask over the configured Element. + * @cfg {String} easing Animation easing if animate = true (defaults to 'easingOutStrong') */ - show: function(){ - this.onBeforeLoad(); - }, - + easing : 'easeOutStrong', /** - * Hide this LoadMask. + * @cfg {Boolean} enabled False to disable resizing (defaults to true) */ - hide: function(){ - this.onLoad(); - }, - - // private - destroy : function(){ - if(this.store){ - this.store.un('beforeload', this.onBeforeLoad, this); - this.store.un('load', this.onLoad, this); - this.store.un('exception', this.onLoad, this); - }else{ - var um = this.el.getUpdater(); - um.un('beforeupdate', this.onBeforeLoad, this); - um.un('update', this.onLoad, this); - um.un('failure', this.onLoad, this); - } - } -};/** - * @class Ext.Slider - * @extends Ext.BoxComponent - * Slider which supports vertical or horizontal orientation, keyboard adjustments, - * configurable snapping, axis clicking and animation. Can be added as an item to - * any container. Example usage: -
-new Ext.Slider({ - renderTo: Ext.getBody(), - width: 200, - value: 50, - increment: 10, - minValue: 0, - maxValue: 100 -}); -
- */ -Ext.Slider = Ext.extend(Ext.BoxComponent, { - /** - * @cfg {Number} value The value to initialize the slider with. Defaults to minValue. - */ - /** - * @cfg {Boolean} vertical Orient the Slider vertically rather than horizontally, defaults to false. - */ - vertical: false, - /** - * @cfg {Number} minValue The minimum value for the Slider. Defaults to 0. - */ - minValue: 0, - /** - * @cfg {Number} maxValue The maximum value for the Slider. Defaults to 100. - */ - maxValue: 100, - /** - * @cfg {Number/Boolean} decimalPrecision. - *
The number of decimal places to which to round the Slider's value. Defaults to 0.
- *
To disable rounding, configure as false.
- */ - decimalPrecision: 0, - /** - * @cfg {Number} keyIncrement How many units to change the Slider when adjusting with keyboard navigation. Defaults to 1. If the increment config is larger, it will be used instead. - */ - keyIncrement: 1, - /** - * @cfg {Number} increment How many units to change the slider when adjusting by drag and drop. Use this option to enable 'snapping'. - */ - increment: 0, - // private - clickRange: [5,15], - /** - * @cfg {Boolean} clickToChange Determines whether or not clicking on the Slider axis will change the slider. Defaults to true - */ - clickToChange : true, - /** - * @cfg {Boolean} animate Turn on or off animation. Defaults to true - */ - animate: true, - - /** - * True while the thumb is in a drag operation - * @type boolean - */ - dragging: false, - - // private override - initComponent : function(){ - if(!Ext.isDefined(this.value)){ - this.value = this.minValue; - } - Ext.Slider.superclass.initComponent.call(this); - this.keyIncrement = Math.max(this.increment, this.keyIncrement); - this.addEvents( - /** - * @event beforechange - * Fires before the slider value is changed. By returning false from an event handler, - * you can cancel the event and prevent the slider from changing. - * @param {Ext.Slider} slider The slider - * @param {Number} newValue The new value which the slider is being changed to. - * @param {Number} oldValue The old value which the slider was previously. - */ - 'beforechange', - /** - * @event change - * Fires when the slider value is changed. - * @param {Ext.Slider} slider The slider - * @param {Number} newValue The new value which the slider has been changed to. - */ - 'change', - /** - * @event changecomplete - * Fires when the slider value is changed by the user and any drag operations have completed. - * @param {Ext.Slider} slider The slider - * @param {Number} newValue The new value which the slider has been changed to. - */ - 'changecomplete', - /** - * @event dragstart - * Fires after a drag operation has started. - * @param {Ext.Slider} slider The slider - * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker - */ - 'dragstart', - /** - * @event drag - * Fires continuously during the drag operation while the mouse is moving. - * @param {Ext.Slider} slider The slider - * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker - */ - 'drag', - /** - * @event dragend - * Fires after the drag operation has completed. - * @param {Ext.Slider} slider The slider - * @param {Ext.EventObject} e The event fired from Ext.dd.DragTracker - */ - 'dragend' - ); - - if(this.vertical){ - Ext.apply(this, Ext.Slider.Vertical); - } - }, - - // private override - onRender : function(){ - this.autoEl = { - cls: 'x-slider ' + (this.vertical ? 'x-slider-vert' : 'x-slider-horz'), - cn:{cls:'x-slider-end',cn:{cls:'x-slider-inner',cn:[{cls:'x-slider-thumb'},{tag:'a', cls:'x-slider-focus', href:"#", tabIndex: '-1', hidefocus:'on'}]}} - }; - Ext.Slider.superclass.onRender.apply(this, arguments); - this.endEl = this.el.first(); - this.innerEl = this.endEl.first(); - this.thumb = this.innerEl.first(); - this.halfThumb = (this.vertical ? this.thumb.getHeight() : this.thumb.getWidth())/2; - this.focusEl = this.thumb.next(); - this.initEvents(); - }, - - // private override - initEvents : function(){ - this.thumb.addClassOnOver('x-slider-thumb-over'); - this.mon(this.el, { - scope: this, - mousedown: this.onMouseDown, - keydown: this.onKeyDown - }); - - this.focusEl.swallowEvent("click", true); - - this.tracker = new Ext.dd.DragTracker({ - onBeforeStart: this.onBeforeDragStart.createDelegate(this), - onStart: this.onDragStart.createDelegate(this), - onDrag: this.onDrag.createDelegate(this), - onEnd: this.onDragEnd.createDelegate(this), - tolerance: 3, - autoStart: 300 - }); - this.tracker.initEl(this.thumb); - }, - - // private override - onMouseDown : function(e){ - if(this.disabled){ - return; - } - if(this.clickToChange && e.target != this.thumb.dom){ - var local = this.innerEl.translatePoints(e.getXY()); - this.onClickChange(local); - } - this.focus(); - }, - - // private - onClickChange : function(local){ - if(local.top > this.clickRange[0] && local.top < this.clickRange[1]){ - this.setValue(Ext.util.Format.round(this.reverseValue(local.left), this.decimalPrecision), undefined, true); - } - }, - - // private - onKeyDown : function(e){ - if(this.disabled){e.preventDefault();return;} - var k = e.getKey(); - switch(k){ - case e.UP: - case e.RIGHT: - e.stopEvent(); - if(e.ctrlKey){ - this.setValue(this.maxValue, undefined, true); - }else{ - this.setValue(this.value+this.keyIncrement, undefined, true); - } - break; - case e.DOWN: - case e.LEFT: - e.stopEvent(); - if(e.ctrlKey){ - this.setValue(this.minValue, undefined, true); - }else{ - this.setValue(this.value-this.keyIncrement, undefined, true); - } - break; - default: - e.preventDefault(); - } - }, - - // private - doSnap : function(value){ - if(!(this.increment && value)){ - return value; - } - var newValue = value, - inc = this.increment, - m = value % inc; - if(m != 0){ - newValue -= m; - if(m * 2 > inc){ - newValue += inc; - }else if(m * 2 < -inc){ - newValue -= inc; - } - } - return newValue.constrain(this.minValue, this.maxValue); - }, - - // private - afterRender : function(){ - Ext.Slider.superclass.afterRender.apply(this, arguments); - if(this.value !== undefined){ - var v = this.normalizeValue(this.value); - if(v !== this.value){ - delete this.value; - this.setValue(v, false); - }else{ - this.moveThumb(this.translateValue(v), false); - } - } - }, - - // private - getRatio : function(){ - var w = this.innerEl.getWidth(), - v = this.maxValue - this.minValue; - return v == 0 ? w : (w/v); - }, - - // private - normalizeValue : function(v){ - v = this.doSnap(v); - v = Ext.util.Format.round(v, this.decimalPrecision); - v = v.constrain(this.minValue, this.maxValue); - return v; - }, - - /** - * Sets the minimum value for the slider instance. If the current value is less than the - * minimum value, the current value will be changed. - * @param {Number} val The new minimum value - */ - setMinValue : function(val){ - this.minValue = val; - this.syncThumb(); - if(this.value < val){ - this.setValue(val); - } - }, - - /** - * Sets the maximum value for the slider instance. If the current value is more than the - * maximum value, the current value will be changed. - * @param {Number} val The new maximum value - */ - setMaxValue : function(val){ - this.maxValue = val; - this.syncThumb(); - if(this.value > val){ - this.setValue(val); - } - }, - - /** - * Programmatically sets the value of the Slider. Ensures that the value is constrained within - * the minValue and maxValue. - * @param {Number} value The value to set the slider to. (This will be constrained within minValue and maxValue) - * @param {Boolean} animate Turn on or off animation, defaults to true - */ - setValue : function(v, animate, changeComplete){ - v = this.normalizeValue(v); - if(v !== this.value && this.fireEvent('beforechange', this, v, this.value) !== false){ - this.value = v; - this.moveThumb(this.translateValue(v), animate !== false); - this.fireEvent('change', this, v); - if(changeComplete){ - this.fireEvent('changecomplete', this, v); - } - } - }, - - // private - translateValue : function(v){ - var ratio = this.getRatio(); - return (v * ratio) - (this.minValue * ratio) - this.halfThumb; - }, - - reverseValue : function(pos){ - var ratio = this.getRatio(); - return (pos + (this.minValue * ratio)) / ratio; - }, - - // private - moveThumb: function(v, animate){ - if(!animate || this.animate === false){ - this.thumb.setLeft(v); - }else{ - this.thumb.shift({left: v, stopFx: true, duration:.35}); - } - }, - - // private - focus : function(){ - this.focusEl.focus(10); - }, - - // private - onBeforeDragStart : function(e){ - return !this.disabled; - }, - - // private - onDragStart: function(e){ - this.thumb.addClass('x-slider-thumb-drag'); - this.dragging = true; - this.dragStartValue = this.value; - this.fireEvent('dragstart', this, e); - }, - - // private - onDrag: function(e){ - var pos = this.innerEl.translatePoints(this.tracker.getXY()); - this.setValue(Ext.util.Format.round(this.reverseValue(pos.left), this.decimalPrecision), false); - this.fireEvent('drag', this, e); - }, - - // private - onDragEnd: function(e){ - this.thumb.removeClass('x-slider-thumb-drag'); - this.dragging = false; - this.fireEvent('dragend', this, e); - if(this.dragStartValue != this.value){ - this.fireEvent('changecomplete', this, this.value); - } - }, - - // private - onResize : function(w, h){ - this.innerEl.setWidth(w - (this.el.getPadding('l') + this.endEl.getPadding('r'))); - this.syncThumb(); - Ext.Slider.superclass.onResize.apply(this, arguments); - }, - - //private - onDisable: function(){ - Ext.Slider.superclass.onDisable.call(this); - this.thumb.addClass(this.disabledClass); - if(Ext.isIE){ - //IE breaks when using overflow visible and opacity other than 1. - //Create a place holder for the thumb and display it. - var xy = this.thumb.getXY(); - this.thumb.hide(); - this.innerEl.addClass(this.disabledClass).dom.disabled = true; - if (!this.thumbHolder){ - this.thumbHolder = this.endEl.createChild({cls: 'x-slider-thumb ' + this.disabledClass}); - } - this.thumbHolder.show().setXY(xy); - } - }, - - //private - onEnable: function(){ - Ext.Slider.superclass.onEnable.call(this); - this.thumb.removeClass(this.disabledClass); - if(Ext.isIE){ - this.innerEl.removeClass(this.disabledClass).dom.disabled = false; - if(this.thumbHolder){ - this.thumbHolder.hide(); - } - this.thumb.show(); - this.syncThumb(); - } - }, - - /** - * Synchronizes the thumb position to the proper proportion of the total component width based - * on the current slider {@link #value}. This will be called automatically when the Slider - * is resized by a layout, but if it is rendered auto width, this method can be called from - * another resize handler to sync the Slider if necessary. - */ - syncThumb : function(){ - if(this.rendered){ - this.moveThumb(this.translateValue(this.value)); - } - }, - - /** - * Returns the current value of the slider - * @return {Number} The current value of the slider - */ - getValue : function(){ - return this.value; - }, - - // private - beforeDestroy : function(){ - Ext.destroyMembers(this, 'endEl', 'innerEl', 'thumb', 'halfThumb', 'focusEl', 'tracker', 'thumbHolder'); - Ext.Slider.superclass.beforeDestroy.call(this); - } -}); -Ext.reg('slider', Ext.Slider); - -// private class to support vertical sliders -Ext.Slider.Vertical = { - onResize : function(w, h){ - this.innerEl.setHeight(h - (this.el.getPadding('t') + this.endEl.getPadding('b'))); - this.syncThumb(); - }, - - getRatio : function(){ - var h = this.innerEl.getHeight(), - v = this.maxValue - this.minValue; - return h/v; - }, - - moveThumb: function(v, animate){ - if(!animate || this.animate === false){ - this.thumb.setBottom(v); - }else{ - this.thumb.shift({bottom: v, stopFx: true, duration:.35}); - } - }, - - onDrag: function(e){ - var pos = this.innerEl.translatePoints(this.tracker.getXY()), - bottom = this.innerEl.getHeight()-pos.top; - this.setValue(this.minValue + Ext.util.Format.round(bottom/this.getRatio(), this.decimalPrecision), false); - this.fireEvent('drag', this, e); - }, - - onClickChange : function(local){ - if(local.left > this.clickRange[0] && local.left < this.clickRange[1]){ - var bottom = this.innerEl.getHeight() - local.top; - this.setValue(this.minValue + Ext.util.Format.round(bottom/this.getRatio(), this.decimalPrecision), undefined, true); - } - } -};/** - * @class Ext.ProgressBar - * @extends Ext.BoxComponent - *
An updateable progress bar component. The progress bar supports two different modes: manual and automatic.
- *
In manual mode, you are responsible for showing, updating (via {@link #updateProgress}) and clearing the - * progress bar as needed from your own code. This method is most appropriate when you want to show progress - * throughout an operation that has predictable points of interest at which you can update the control.
- *
In automatic mode, you simply call {@link #wait} and let the progress bar run indefinitely, only clearing it - * once the operation is complete. You can optionally have the progress bar wait for a specific amount of time - * and then clear itself. Automatic mode is most appropriate for timed operations or asynchronous operations in - * which you have no need for indicating intermediate progress.
- * @cfg {Float} value A floating point value between 0 and 1 (e.g., .5, defaults to 0) - * @cfg {String} text The progress bar text (defaults to '') - * @cfg {Mixed} textEl The element to render the progress text to (defaults to the progress - * bar's internal text element) - * @cfg {String} id The progress bar element's id (defaults to an auto-generated id) - * @xtype progress - */ -Ext.ProgressBar = Ext.extend(Ext.BoxComponent, { - /** - * @cfg {String} baseCls - * The base CSS class to apply to the progress bar's wrapper element (defaults to 'x-progress') - */ - baseCls : 'x-progress', - - /** - * @cfg {Boolean} animate - * True to animate the progress bar during transitions (defaults to false) - */ - animate : false, - - // private - waitTimer : null, - - // private - initComponent : function(){ - Ext.ProgressBar.superclass.initComponent.call(this); - this.addEvents( - /** - * @event update - * Fires after each update interval - * @param {Ext.ProgressBar} this - * @param {Number} The current progress value - * @param {String} The current progress text - */ - "update" - ); - }, - - // private - onRender : function(ct, position){ - var tpl = new Ext.Template( - '
', - '
', - '
', - '
', - '

', - '
', - '
', - '
', - '

', - '
', - '
', - '
' - ); - - this.el = position ? tpl.insertBefore(position, {cls: this.baseCls}, true) - : tpl.append(ct, {cls: this.baseCls}, true); - - if(this.id){ - this.el.dom.id = this.id; - } - var inner = this.el.dom.firstChild; - this.progressBar = Ext.get(inner.firstChild); - - if(this.textEl){ - //use an external text el - this.textEl = Ext.get(this.textEl); - delete this.textTopEl; - }else{ - //setup our internal layered text els - this.textTopEl = Ext.get(this.progressBar.dom.firstChild); - var textBackEl = Ext.get(inner.childNodes[1]); - this.textTopEl.setStyle("z-index", 99).addClass('x-hidden'); - this.textEl = new Ext.CompositeElement([this.textTopEl.dom.firstChild, textBackEl.dom.firstChild]); - this.textEl.setWidth(inner.offsetWidth); - } - this.progressBar.setHeight(inner.offsetHeight); - }, - - // private - afterRender : function(){ - Ext.ProgressBar.superclass.afterRender.call(this); - if(this.value){ - this.updateProgress(this.value, this.text); - }else{ - this.updateText(this.text); - } - }, - - /** - * Updates the progress bar value, and optionally its text. If the text argument is not specified, - * any existing text value will be unchanged. To blank out existing text, pass ''. Note that even - * if the progress bar value exceeds 1, it will never automatically reset -- you are responsible for - * determining when the progress is complete and calling {@link #reset} to clear and/or hide the control. - * @param {Float} value (optional) A floating point value between 0 and 1 (e.g., .5, defaults to 0) - * @param {String} text (optional) The string to display in the progress text element (defaults to '') - * @param {Boolean} animate (optional) Whether to animate the transition of the progress bar. If this value is - * not specified, the default for the class is used (default to false) - * @return {Ext.ProgressBar} this - */ - updateProgress : function(value, text, animate){ - this.value = value || 0; - if(text){ - this.updateText(text); - } - if(this.rendered && !this.isDestroyed){ - var w = Math.floor(value*this.el.dom.firstChild.offsetWidth); - this.progressBar.setWidth(w, animate === true || (animate !== false && this.animate)); - if(this.textTopEl){ - //textTopEl should be the same width as the bar so overflow will clip as the bar moves - this.textTopEl.removeClass('x-hidden').setWidth(w); - } - } - this.fireEvent('update', this, value, text); - return this; - }, - - /** - * Initiates an auto-updating progress bar. A duration can be specified, in which case the progress - * bar will automatically reset after a fixed amount of time and optionally call a callback function - * if specified. If no duration is passed in, then the progress bar will run indefinitely and must - * be manually cleared by calling {@link #reset}. The wait method accepts a config object with - * the following properties: - *
-Property Type Description ----------- ------------ ---------------------------------------------------------------------- -duration Number The length of time in milliseconds that the progress bar should - run before resetting itself (defaults to undefined, in which case it - will run indefinitely until reset is called) -interval Number The length of time in milliseconds between each progress update - (defaults to 1000 ms) -animate Boolean Whether to animate the transition of the progress bar. If this value is - not specified, the default for the class is used. -increment Number The number of progress update segments to display within the progress - bar (defaults to 10). If the bar reaches the end and is still - updating, it will automatically wrap back to the beginning. -text String Optional text to display in the progress bar element (defaults to ''). -fn Function A callback function to execute after the progress bar finishes auto- - updating. The function will be called with no arguments. This function - will be ignored if duration is not specified since in that case the - progress bar can only be stopped programmatically, so any required function - should be called by the same code after it resets the progress bar. -scope Object The scope that is passed to the callback function (only applies when - duration and fn are both passed). -
- * - * Example usage: - *
-var p = new Ext.ProgressBar({ - renderTo: 'my-el' -}); - -//Wait for 5 seconds, then update the status el (progress bar will auto-reset) -p.wait({ - interval: 100, //bar will move fast! - duration: 5000, - increment: 15, - text: 'Updating...', - scope: this, - fn: function(){ - Ext.fly('status').update('Done!'); - } -}); - -//Or update indefinitely until some async action completes, then reset manually -p.wait(); -myAction.on('complete', function(){ - p.reset(); - Ext.fly('status').update('Done!'); -}); -
- * @param {Object} config (optional) Configuration options - * @return {Ext.ProgressBar} this - */ - wait : function(o){ - if(!this.waitTimer){ - var scope = this; - o = o || {}; - this.updateText(o.text); - this.waitTimer = Ext.TaskMgr.start({ - run: function(i){ - var inc = o.increment || 10; - i -= 1; - this.updateProgress(((((i+inc)%inc)+1)*(100/inc))*0.01, null, o.animate); - }, - interval: o.interval || 1000, - duration: o.duration, - onStop: function(){ - if(o.fn){ - o.fn.apply(o.scope || this); - } - this.reset(); - }, - scope: scope - }); - } - return this; - }, - - /** - * Returns true if the progress bar is currently in a {@link #wait} operation - * @return {Boolean} True if waiting, else false - */ - isWaiting : function(){ - return this.waitTimer !== null; - }, - - /** - * Updates the progress bar text. If specified, textEl will be updated, otherwise the progress - * bar itself will display the updated text. - * @param {String} text (optional) The string to display in the progress text element (defaults to '') - * @return {Ext.ProgressBar} this - */ - updateText : function(text){ - this.text = text || ' '; - if(this.rendered){ - this.textEl.update(this.text); - } - return this; - }, - - /** - * Synchronizes the inner bar width to the proper proportion of the total componet width based - * on the current progress {@link #value}. This will be called automatically when the ProgressBar - * is resized by a layout, but if it is rendered auto width, this method can be called from - * another resize handler to sync the ProgressBar if necessary. - */ - syncProgressBar : function(){ - if(this.value){ - this.updateProgress(this.value, this.text); - } - return this; - }, - - /** - * Sets the size of the progress bar. - * @param {Number} width The new width in pixels - * @param {Number} height The new height in pixels - * @return {Ext.ProgressBar} this - */ - setSize : function(w, h){ - Ext.ProgressBar.superclass.setSize.call(this, w, h); - if(this.textTopEl){ - var inner = this.el.dom.firstChild; - this.textEl.setSize(inner.offsetWidth, inner.offsetHeight); - } - this.syncProgressBar(); - return this; - }, - - /** - * Resets the progress bar value to 0 and text to empty string. If hide = true, the progress - * bar will also be hidden (using the {@link #hideMode} property internally). - * @param {Boolean} hide (optional) True to hide the progress bar (defaults to false) - * @return {Ext.ProgressBar} this - */ - reset : function(hide){ - this.updateProgress(0); - if(this.textTopEl){ - this.textTopEl.addClass('x-hidden'); - } - this.clearTimer(); - if(hide === true){ - this.hide(); - } - return this; - }, - - // private - clearTimer : function(){ - if(this.waitTimer){ - this.waitTimer.onStop = null; //prevent recursion - Ext.TaskMgr.stop(this.waitTimer); - this.waitTimer = null; - } - }, - - onDestroy: function(){ - this.clearTimer(); - if(this.rendered){ - if(this.textEl.isComposite){ - this.textEl.clear(); - } - Ext.destroyMembers(this, 'textEl', 'progressBar', 'textTopEl'); - } - Ext.ProgressBar.superclass.onDestroy.call(this); - } -}); -Ext.reg('progress', Ext.ProgressBar);/* - * 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=Ext.EventManager; -var Dom=Ext.lib.Dom; - -/** - * @class 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 Ext.dd.DD}. setDragElId() lets you define - * a separate element that would be moved, as in {@link 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 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 - */ -Ext.dd.DragDrop = function(id, sGroup, config) { - if(id) { - this.init(id, sGroup, config); - } -}; - -Ext.dd.DragDrop.prototype = { - + enabled : true, /** - * Set to false to enable a DragDrop object to fire drag events while dragging - * over its own Element. Defaults to true - DragDrop objects do not by default - * fire drag events to themselves. - * @property ignoreSelf + * @property enabled Writable. False if resizing is disabled. * @type Boolean */ - /** - * 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 + * @cfg {String} handles String consisting of the resize handles to display (defaults to undefined). + * Specify either 'all' or any of 'n s e w ne nw se sw'. */ - id: null, - + handles : false, /** - * Configuration attributes passed into the constructor - * @property config - * @type object + * @cfg {Boolean} multiDirectional Deprecated. Deprecated style of adding multi-direction resize handles. */ - config: null, - + multiDirectional : false, /** - * 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: - * Ext.dd.DDProxy - * @property dragElId - * @type String - * @private + * @cfg {Number} height The height of the element in pixels (defaults to null) */ - dragElId: null, - + height : 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 + * @cfg {Number} width The width of the element in pixels (defaults to null) */ - handleElId: null, - + width : 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 + * @cfg {Number} heightIncrement The increment to snap the height resize in pixels + * (only applies if {@link #dynamic}==true). Defaults to 0. */ - invalidHandleTypes: null, - + heightIncrement : 0, /** - * 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 + * @cfg {Number} widthIncrement The increment to snap the width resize in pixels + * (only applies if {@link #dynamic}==true). Defaults to 0. */ - invalidHandleIds: null, - + widthIncrement : 0, /** - * An Array of CSS class names for elements to be considered in valid as drag handles. - * @property invalidHandleClasses - * @type Array + * @cfg {Number} minHeight The minimum height for the element (defaults to 5) */ - invalidHandleClasses: null, - + minHeight : 5, /** - * The linked element's absolute X position at the time the drag was - * started - * @property startPageX - * @type int - * @private + * @cfg {Number} minWidth The minimum width for the element (defaults to 5) */ - startPageX: 0, - + minWidth : 5, /** - * The linked element's absolute X position at the time the drag was - * started - * @property startPageY - * @type int - * @private + * @cfg {Number} maxHeight The maximum height for the element (defaults to 10000) */ - startPageY: 0, - + maxHeight : 10000, /** - * 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} + * @cfg {Number} maxWidth The maximum width for the element (defaults to 10000) */ - groups: null, - + maxWidth : 10000, /** - * Individual drag/drop instances can be locked. This will prevent - * onmousedown start drag. - * @property locked - * @type boolean - * @private + * @cfg {Number} minX The minimum x for the element (defaults to 0) */ - locked: false, - + minX: 0, /** - * Lock this instance - * @method lock + * @cfg {Number} minY The minimum x for the element (defaults to 0) */ - lock: function() { this.locked = true; }, - + minY: 0, /** - * When set to true, other DD objects in cooperating DDGroups do not receive - * notification events when this DD object is dragged over them. Defaults to false. - * @property moveOnly - * @type boolean + * @cfg {Boolean} pinned True to ensure that the resize handles are always visible, false to display them only when the + * user mouses over the resizable borders. This is only applied at config time. (defaults to false) */ - moveOnly: false, - + pinned : false, /** - * Unlock this instace - * @method unlock + * @cfg {Boolean} preserveRatio True to preserve the original ratio between height + * and width during resize (defaults to false) */ - unlock: function() { this.locked = false; }, - + preserveRatio : false, /** - * By default, all instances can be a drop target. This can be disabled by - * setting isTarget to false. - * @property isTarget - * @type boolean + * @cfg {Boolean/String/Element} resizeChild True to resize the first child, or id/element to resize (defaults to false) */ - isTarget: true, - + resizeChild : false, /** - * 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] + * @cfg {Boolean} transparent True for transparent handles. This is only applied at config time. (defaults to false) */ - padding: null, - + transparent: false, /** - * Cached reference to the linked element - * @property _domRef - * @private + * @cfg {Ext.lib.Region} resizeRegion Constrain the resize to a particular region */ - _domRef: null, - /** - * Internal typeof flag - * @property __ygDragDrop - * @private + * @cfg {Boolean} wrap True to wrap an element with a div if needed (required for textareas and images, defaults to false) + * in favor of the handles config option (defaults to false) */ - __ygDragDrop: true, - /** - * Set to true when horizontal contraints are applied - * @property constrainX - * @type boolean - * @private + * @cfg {String} handleCls A css class to add to each handle. Defaults to ''. */ - 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 + * Perform a manual resize and fires the 'resize' event. + * @param {Number} width + * @param {Number} height */ - minX: 0, + resizeTo : function(width, height){ + this.el.setSize(width, height); + this.updateChildSize(); + this.fireEvent('resize', this, width, height, null); + }, - /** - * The right constraint - * @property maxX - * @type int - * @private - */ - maxX: 0, + // private + startSizing : function(e, handle){ + this.fireEvent('beforeresize', this, e); + if(this.enabled){ // 2nd enabled check in case disabled before beforeresize handler - /** - * The up constraint - * @property minY - * @type int - * @type int - * @private - */ - minY: 0, + if(!this.overlay){ + this.overlay = this.el.createProxy({tag: 'div', cls: 'x-resizable-overlay', html: ' '}, Ext.getBody()); + this.overlay.unselectable(); + this.overlay.enableDisplayMode('block'); + this.overlay.on({ + scope: this, + mousemove: this.onMouseMove, + mouseup: this.onMouseUp + }); + } + this.overlay.setStyle('cursor', handle.el.getStyle('cursor')); - /** - * The down constraint - * @property maxY - * @type int - * @private - */ - maxY: 0, + this.resizing = true; + this.startBox = this.el.getBox(); + this.startPoint = e.getXY(); + this.offsets = [(this.startBox.x + this.startBox.width) - this.startPoint[0], + (this.startBox.y + this.startBox.height) - this.startPoint[1]]; + + this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); + this.overlay.show(); + + if(this.constrainTo) { + var ct = Ext.get(this.constrainTo); + this.resizeRegion = ct.getRegion().adjust( + ct.getFrameWidth('t'), + ct.getFrameWidth('l'), + -ct.getFrameWidth('b'), + -ct.getFrameWidth('r') + ); + } + + this.proxy.setStyle('visibility', 'hidden'); // workaround display none + this.proxy.show(); + this.proxy.setBox(this.startBox); + if(!this.dynamic){ + this.proxy.setStyle('visibility', 'visible'); + } + } + }, + + // private + onMouseDown : function(handle, e){ + if(this.enabled){ + e.stopEvent(); + this.activeHandle = handle; + this.startSizing(e, handle); + } + }, + + // private + onMouseUp : function(e){ + this.activeHandle = null; + var size = this.resizeElement(); + this.resizing = false; + this.handleOut(); + this.overlay.hide(); + this.proxy.hide(); + this.fireEvent('resize', this, size.width, size.height, e); + }, + + // private + updateChildSize : function(){ + if(this.resizeChild){ + var el = this.el; + var child = this.resizeChild; + var adj = this.adjustments; + if(el.dom.offsetWidth){ + var b = el.getSize(true); + child.setSize(b.width+adj[0], b.height+adj[1]); + } + // Second call here for IE + // The first call enables instant resizing and + // the second call corrects scroll bars if they + // exist + if(Ext.isIE){ + setTimeout(function(){ + if(el.dom.offsetWidth){ + var b = el.getSize(true); + child.setSize(b.width+adj[0], b.height+adj[1]); + } + }, 10); + } + } + }, + + // private + snap : function(value, inc, min){ + if(!inc || !value){ + return value; + } + var newValue = value; + var m = value % inc; + if(m > 0){ + if(m > (inc/2)){ + newValue = value + (inc-m); + }else{ + newValue = value - m; + } + } + return Math.max(min, newValue); + }, /** - * 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 + *
Performs resizing of the associated Element. This method is called internally by this + * class, and should not be called by user code.
+ *
If a Resizable is being used to resize an Element which encapsulates a more complex UI + * component such as a Panel, this method may be overridden by specifying an implementation + * as a config option to provide appropriate behaviour at the end of the resize operation on + * mouseup, for example resizing the Panel, and relaying the Panel's content.
+ *
The new area to be resized to is available by examining the state of the {@link #proxy} + * Element. Example: +
+new Ext.Panel({ + title: 'Resize me', + x: 100, + y: 100, + renderTo: Ext.getBody(), + floating: true, + frame: true, + width: 400, + height: 200, + listeners: { + render: function(p) { + new Ext.Resizable(p.getEl(), { + handles: 'all', + pinned: true, + transparent: true, + resizeElement: function() { + var box = this.proxy.getBox(); + p.updateBox(box); + if (p.layout) { + p.doLayout(); + } + return box; + } + }); + } + } +}).show(); +
*/ - maintainOffset: false, + resizeElement : function(){ + var box = this.proxy.getBox(); + if(this.updateBox){ + this.el.setBox(box, false, this.animate, this.duration, null, this.easing); + }else{ + this.el.setSize(box.width, box.height, this.animate, this.duration, null, this.easing); + } + this.updateChildSize(); + if(!this.dynamic){ + this.proxy.hide(); + } + if(this.draggable && this.constrainTo){ + this.dd.resetConstraints(); + this.dd.constrainTo(this.constrainTo); + } + return box; + }, + + // private + constrain : function(v, diff, m, mx){ + if(v - diff < m){ + diff = v - m; + }else if(v - diff > mx){ + diff = v - mx; + } + return diff; + }, + + // private + onMouseMove : function(e){ + if(this.enabled && this.activeHandle){ + try{// try catch so if something goes wrong the user doesn't get hung + + if(this.resizeRegion && !this.resizeRegion.contains(e.getPoint())) { + return; + } + + //var curXY = this.startPoint; + var curSize = this.curSize || this.startBox, + x = this.startBox.x, y = this.startBox.y, + ox = x, + oy = y, + w = curSize.width, + h = curSize.height, + ow = w, + oh = h, + mw = this.minWidth, + mh = this.minHeight, + mxw = this.maxWidth, + mxh = this.maxHeight, + wi = this.widthIncrement, + hi = this.heightIncrement, + eventXY = e.getXY(), + diffX = -(this.startPoint[0] - Math.max(this.minX, eventXY[0])), + diffY = -(this.startPoint[1] - Math.max(this.minY, eventXY[1])), + pos = this.activeHandle.position, + tw, + th; + + switch(pos){ + case 'east': + w += diffX; + w = Math.min(Math.max(mw, w), mxw); + break; + case 'south': + h += diffY; + h = Math.min(Math.max(mh, h), mxh); + break; + case 'southeast': + w += diffX; + h += diffY; + w = Math.min(Math.max(mw, w), mxw); + h = Math.min(Math.max(mh, h), mxh); + break; + case 'north': + diffY = this.constrain(h, diffY, mh, mxh); + y += diffY; + h -= diffY; + break; + case 'west': + diffX = this.constrain(w, diffX, mw, mxw); + x += diffX; + w -= diffX; + break; + case 'northeast': + w += diffX; + w = Math.min(Math.max(mw, w), mxw); + diffY = this.constrain(h, diffY, mh, mxh); + y += diffY; + h -= diffY; + break; + case 'northwest': + diffX = this.constrain(w, diffX, mw, mxw); + diffY = this.constrain(h, diffY, mh, mxh); + y += diffY; + h -= diffY; + x += diffX; + w -= diffX; + break; + case 'southwest': + diffX = this.constrain(w, diffX, mw, mxw); + h += diffY; + h = Math.min(Math.max(mh, h), mxh); + x += diffX; + w -= diffX; + break; + } + + var sw = this.snap(w, wi, mw); + var sh = this.snap(h, hi, mh); + if(sw != w || sh != h){ + switch(pos){ + case 'northeast': + y -= sh - h; + break; + case 'north': + y -= sh - h; + break; + case 'southwest': + x -= sw - w; + break; + case 'west': + x -= sw - w; + break; + case 'northwest': + x -= sw - w; + y -= sh - h; + break; + } + w = sw; + h = sh; + } + + if(this.preserveRatio){ + switch(pos){ + case 'southeast': + case 'east': + h = oh * (w/ow); + h = Math.min(Math.max(mh, h), mxh); + w = ow * (h/oh); + break; + case 'south': + w = ow * (h/oh); + w = Math.min(Math.max(mw, w), mxw); + h = oh * (w/ow); + break; + case 'northeast': + w = ow * (h/oh); + w = Math.min(Math.max(mw, w), mxw); + h = oh * (w/ow); + break; + case 'north': + tw = w; + w = ow * (h/oh); + w = Math.min(Math.max(mw, w), mxw); + h = oh * (w/ow); + x += (tw - w) / 2; + break; + case 'southwest': + h = oh * (w/ow); + h = Math.min(Math.max(mh, h), mxh); + tw = w; + w = ow * (h/oh); + x += tw - w; + break; + case 'west': + th = h; + h = oh * (w/ow); + h = Math.min(Math.max(mh, h), mxh); + y += (th - h) / 2; + tw = w; + w = ow * (h/oh); + x += tw - w; + break; + case 'northwest': + tw = w; + th = h; + h = oh * (w/ow); + h = Math.min(Math.max(mh, h), mxh); + w = ow * (h/oh); + y += th - h; + x += tw - w; + break; + + } + } + this.proxy.setBounds(x, y, w, h); + if(this.dynamic){ + this.resizeElement(); + } + }catch(ex){} + } + }, + + // private + handleOver : function(){ + if(this.enabled){ + this.el.addClass('x-resizable-over'); + } + }, + + // private + handleOut : function(){ + if(!this.resizing){ + this.el.removeClass('x-resizable-over'); + } + }, /** - * 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[] + * Returns the element this component is bound to. + * @return {Ext.Element} */ - xTicks: null, + getEl : function(){ + return this.el; + }, /** - * 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[] + * Returns the resizeChild element (or null). + * @return {Ext.Element} */ - yTicks: null, + getResizeChild : function(){ + return this.resizeChild; + }, /** - * 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 + * Destroys this resizable. If the element was wrapped and + * removeEl is not true then the element remains. + * @param {Boolean} removeEl (optional) true to remove the element from the DOM */ - primaryButtonOnly: true, + destroy : function(removeEl){ + Ext.destroy(this.dd, this.overlay, this.proxy); + this.overlay = null; + this.proxy = null; + + var ps = Ext.Resizable.positions; + for(var k in ps){ + if(typeof ps[k] != 'function' && this[ps[k]]){ + this[ps[k]].destroy(); + } + } + if(removeEl){ + this.el.update(''); + Ext.destroy(this.el); + this.el = null; + } + this.purgeListeners(); + }, + + syncHandleHeight : function(){ + var h = this.el.getHeight(true); + if(this.west){ + this.west.el.setHeight(h); + } + if(this.east){ + this.east.el.setHeight(h); + } + } +}); + +// private +// hash to map config positions to true positions +Ext.Resizable.positions = { + n: 'north', s: 'south', e: 'east', w: 'west', se: 'southeast', sw: 'southwest', nw: 'northwest', ne: 'northeast' +}; + +Ext.Resizable.Handle = Ext.extend(Object, { + constructor : function(rz, pos, disableTrackOver, transparent, cls){ + if(!this.tpl){ + // only initialize the template if resizable is used + var tpl = Ext.DomHelper.createTemplate( + {tag: 'div', cls: 'x-resizable-handle x-resizable-handle-{0}'} + ); + tpl.compile(); + Ext.Resizable.Handle.prototype.tpl = tpl; + } + this.position = pos; + this.rz = rz; + this.el = this.tpl.append(rz.el.dom, [this.position], true); + this.el.unselectable(); + if(transparent){ + this.el.setOpacity(0); + } + if(!Ext.isEmpty(cls)){ + this.el.addClass(cls); + } + this.el.on('mousedown', this.onMouseDown, this); + if(!disableTrackOver){ + this.el.on({ + scope: this, + mouseover: this.onMouseOver, + mouseout: this.onMouseOut + }); + } + }, + // private + afterResize : function(rz){ + // do nothing + }, + // private + onMouseDown : function(e){ + this.rz.onMouseDown(this, e); + }, + // private + onMouseOver : function(e){ + this.rz.handleOver(this, e); + }, + // private + onMouseOut : function(e){ + this.rz.handleOut(this, e); + }, + // private + destroy : function(){ + Ext.destroy(this.el); + this.el = null; + } +}); +/** + * @class Ext.Window + * @extends Ext.Panel + *
A specialized panel intended for use as an application window. Windows are floated, {@link #resizable}, and + * {@link #draggable} by default. Windows can be {@link #maximizable maximized} to fill the viewport, + * restored to their prior size, and can be {@link #minimize}d.
+ *
Windows can also be linked to a {@link Ext.WindowGroup} or managed by the {@link Ext.WindowMgr} to provide + * grouping, activation, to front, to back and other application-specific behavior.
+ *
By default, Windows will be rendered to document.body. To {@link #constrain} a Window to another element + * specify {@link Ext.Component#renderTo renderTo}.
+ *
Note: By default, the {@link #closable close} header tool destroys the Window resulting in + * destruction of any child Components. This makes the Window object, and all its descendants unusable. To enable + * re-use of a Window, use {@link #closeAction closeAction: 'hide'}.
+ * @constructor + * @param {Object} config The config object + * @xtype window + */ +Ext.Window = Ext.extend(Ext.Panel, { /** - * The availabe property is false until the linked dom element is accessible. - * @property available - * @type boolean + * @cfg {Number} x + * The X position of the left edge of the window on initial showing. Defaults to centering the Window within + * the width of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to). */ - 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 + * @cfg {Number} y + * The Y position of the top edge of the window on initial showing. Defaults to centering the Window within + * the height of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to). */ - hasOuterHandles: false, - /** - * Code that executes immediately before the startDrag event - * @method b4StartDrag - * @private + * @cfg {Boolean} modal + * True to make the window modal and mask everything behind it when displayed, false to display it without + * restricting access to other UI elements (defaults to false). */ - 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 + * @cfg {String/Element} animateTarget + * Id or element from which the window should animate while opening (defaults to null with no animation). */ - startDrag: function(x, y) { /* override this */ }, - /** - * Code that executes immediately before the onDrag event - * @method b4Drag - * @private + * @cfg {String} resizeHandles + * A valid {@link Ext.Resizable} handles config string (defaults to 'all'). Only applies when resizable = true. */ - b4Drag: function(e) { }, - /** - * Abstract method called during the onMouseMove event while dragging an - * object. - * @method onDrag - * @param {Event} e the mousemove event + * @cfg {Ext.WindowGroup} manager + * A reference to the WindowGroup that should manage this window (defaults to {@link Ext.WindowMgr}). */ - 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. + * @cfg {String/Number/Component} defaultButton + *
Specifies a Component to receive focus when this Window is focussed.
+ *
This may be one of:
+ *
The index of a footer Button.
+ *
The id of a Component.
+ *
A Component.
+ *
+ */ + /** + * @cfg {Function} onEsc + * Allows override of the built-in processing for the escape key. Default action + * is to close the Window (performing whatever action is specified in {@link #closeAction}. + * To prevent the Window closing when the escape key is pressed, specify this as + * Ext.emptyFn (See {@link Ext#emptyFn}). + */ + /** + * @cfg {Boolean} collapsed + * True to render the window collapsed, false to render it expanded (defaults to false). Note that if + * {@link #expandOnShow} is true (the default) it will override the collapsed config and the window + * will always be expanded when shown. */ - onDragEnter: function(e, id) { /* override this */ }, - /** - * Code that executes immediately before the onDragOver event - * @method b4DragOver - * @private + * @cfg {Boolean} maximized + * True to initially display the window in a maximized state. (Defaults to false). */ - 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. + * @cfg {String} baseCls + * The base CSS class to apply to this panel's element (defaults to 'x-window'). + */ + baseCls : 'x-window', + /** + * @cfg {Boolean} resizable + * True to allow user resizing at each edge and corner of the window, false to disable resizing (defaults to true). */ - onDragOver: function(e, id) { /* override this */ }, - + resizable : true, /** - * Code that executes immediately before the onDragOut event - * @method b4DragOut - * @private + * @cfg {Boolean} draggable + * True to allow the window to be dragged by the header bar, false to disable dragging (defaults to true). Note + * that by default the window will be centered in the viewport, so if dragging is disabled the window may need + * to be positioned programmatically after render (e.g., myWindow.setPosition(100, 100);). */ - b4DragOut: function(e) { }, - + draggable : true, /** - * 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. + * @cfg {Boolean} closable + *
True to display the 'close' tool button and allow the user to close the window, false to + * hide the button and disallow closing the window (defaults to true).
+ *
By default, when close is requested by either clicking the close button in the header + * or pressing ESC when the Window has focus, the {@link #close} method will be called. This + * will {@link Ext.Component#destroy destroy} the Window and its content meaning that + * it may not be reused.
+ *
To make closing a Window hide the Window so that it may be reused, set + * {@link #closeAction} to 'hide'. */ - onDragOut: function(e, id) { /* override this */ }, - + closable : true, /** - * Code that executes immediately before the onDragDrop event - * @method b4DragDrop - * @private + * @cfg {String} closeAction + *
The action to take when the close header tool is clicked: + *
+ *
'{@link #close}' : Default
+ * {@link #close remove} the window from the DOM and {@link Ext.Component#destroy destroy} + * it and all descendant Components. The window will not be available to be + * redisplayed via the {@link #show} method. + *
+ *
'{@link #hide}' :
+ * {@link #hide} the window by setting visibility to hidden and applying negative offsets. + * The window will be available to be redisplayed via the {@link #show} method. + *
+ *
+ *
Note: This setting does not affect the {@link #close} method + * which will always {@link Ext.Component#destroy destroy} the window. To + * programatically hide a window, call {@link #hide}.
*/ - b4DragDrop: function(e) { }, - + closeAction : 'close', /** - * 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. + * @cfg {Boolean} constrain + * True to constrain the window within its containing element, false to allow it to fall outside of its + * containing element. By default the window will be rendered to document.body. To render and constrain the + * window within another element specify {@link #renderTo}. + * (defaults to false). Optionally the header only can be constrained using {@link #constrainHeader}. */ - onDragDrop: function(e, id) { /* override this */ }, - + constrain : false, /** - * Abstract method called when this item is dropped on an area with no - * drop target - * @method onInvalidDrop - * @param {Event} e the mouseup event + * @cfg {Boolean} constrainHeader + * True to constrain the window header within its containing element (allowing the window body to fall outside + * of its containing element) or false to allow the header to fall outside its containing element (defaults to + * false). Optionally the entire window can be constrained using {@link #constrain}. */ - onInvalidDrop: function(e) { /* override this */ }, - + constrainHeader : false, /** - * Code that executes immediately before the endDrag event - * @method b4EndDrag - * @private + * @cfg {Boolean} plain + * True to render the window body with a transparent background so that it will blend into the framing + * elements, false to add a lighter background color to visually highlight the body element and separate it + * more distinctly from the surrounding frame (defaults to false). */ - b4EndDrag: function(e) { }, - + plain : false, /** - * Fired when we are done dragging the object - * @method endDrag - * @param {Event} e the mouseup event + * @cfg {Boolean} minimizable + * True to display the 'minimize' tool button and allow the user to minimize the window, false to hide the button + * and disallow minimizing the window (defaults to false). Note that this button provides no implementation -- + * the behavior of minimizing a window is implementation-specific, so the minimize event must be handled and a + * custom minimize behavior implemented for this option to be useful. */ - endDrag: function(e) { /* override this */ }, - + minimizable : false, /** - * Code executed immediately before the onMouseDown event - * @method b4MouseDown - * @param {Event} e the mousedown event - * @private + * @cfg {Boolean} maximizable + * True to display the 'maximize' tool button and allow the user to maximize the window, false to hide the button + * and disallow maximizing the window (defaults to false). Note that when a window is maximized, the tool button + * will automatically change to a 'restore' button with the appropriate behavior already built-in that will + * restore the window to its previous size. */ - b4MouseDown: function(e) { }, - + maximizable : false, /** - * Event handler that fires when a drag/drop obj gets a mousedown - * @method onMouseDown - * @param {Event} e the mousedown event + * @cfg {Number} minHeight + * The minimum height in pixels allowed for this window (defaults to 100). Only applies when resizable = true. */ - onMouseDown: function(e) { /* override this */ }, - + minHeight : 100, /** - * Event handler that fires when a drag/drop obj gets a mouseup - * @method onMouseUp - * @param {Event} e the mouseup event + * @cfg {Number} minWidth + * The minimum width in pixels allowed for this window (defaults to 200). Only applies when resizable = true. */ - onMouseUp: function(e) { /* override this */ }, - + minWidth : 200, /** - * Override the onAvailable method to do what is needed after the initial - * position was determined. - * @method onAvailable + * @cfg {Boolean} expandOnShow + * True to always expand the window when it is displayed, false to keep it in its current state (which may be + * {@link #collapsed}) when displayed (defaults to true). */ - onAvailable: function () { - }, + expandOnShow : true, + + // inherited docs, same default + collapsible : false, /** - * Provides default constraint padding to "constrainTo" elements (defaults to {left: 0, right:0, top:0, bottom:0}). - * @type Object + * @cfg {Boolean} initHidden + * True to hide the window until show() is explicitly called (defaults to true). + * @deprecated */ - defaultPadding : {left:0, right:0, top:0, bottom:0}, + initHidden : undefined, /** - * Initializes the drag drop object's constraints to restrict movement to a certain element. - * - * Usage: -
- var dd = new Ext.dd.DDProxy("dragDiv1", "proxytest", - { dragElId: "existingProxyDiv" }); - dd.startDrag = function(){ - this.constrainTo("parent-id"); - }; -
- * Or you can initalize it using the {@link Ext.Element} object: -
- 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) + * @cfg {Boolean} hidden + * Render this component hidden (default is true). If true, the + * {@link #hide} method will be called internally. */ - constrainTo : function(constrainTo, pad, inContent){ - if(Ext.isNumber(pad)){ - pad = {left: pad, right:pad, top:pad, bottom:pad}; - } - pad = pad || this.defaultPadding; - var b = Ext.get(this.getEl()).getBox(), - ce = Ext.get(constrainTo), - s = ce.getScroll(), - c, - cd = ce.dom; - if(cd == document.body){ - c = { x: s.left, y: s.top, width: Ext.lib.Dom.getViewWidth(), height: Ext.lib.Dom.getViewHeight()}; - }else{ - var xy = ce.getXY(); - c = {x : xy[0], y: xy[1], width: cd.clientWidth, height: cd.clientHeight}; - } - + hidden : true, - var topSpace = b.y - c.y, - leftSpace = b.x - c.x; + // The following configs are set to provide the basic functionality of a window. + // Changing them would require additional code to handle correctly and should + // usually only be done in subclasses that can provide custom behavior. Changing them + // may have unexpected or undesirable results. + /** @cfg {String} elements @hide */ + elements : 'header,body', + /** @cfg {Boolean} frame @hide */ + frame : true, + /** @cfg {Boolean} floating @hide */ + floating : true, - 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 + // private + initComponent : function(){ + this.initTools(); + Ext.Window.superclass.initComponent.call(this); + this.addEvents( + /** + * @event activate + * Fires after the window has been visually activated via {@link #setActive}. + * @param {Ext.Window} this + */ + /** + * @event deactivate + * Fires after the window has been visually deactivated via {@link #setActive}. + * @param {Ext.Window} this + */ + /** + * @event resize + * Fires after the window has been resized. + * @param {Ext.Window} this + * @param {Number} width The window's new width + * @param {Number} height The window's new height + */ + 'resize', + /** + * @event maximize + * Fires after the window has been maximized. + * @param {Ext.Window} this + */ + 'maximize', + /** + * @event minimize + * Fires after the window has been minimized. + * @param {Ext.Window} this + */ + 'minimize', + /** + * @event restore + * Fires after the window has been restored to its original size after being maximized. + * @param {Ext.Window} this + */ + 'restore' ); - }, - - /** - * Returns a reference to the linked element - * @method getEl - * @return {HTMLElement} the html element - */ - getEl: function() { - if (!this._domRef) { - this._domRef = Ext.getDom(this.id); + // for backwards compat, this should be removed at some point + if(Ext.isDefined(this.initHidden)){ + this.hidden = this.initHidden; + } + if(this.hidden === false){ + this.hidden = true; + this.show(); } - - 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 Ext.dd.DDProxy - * @method getDragEl - * @return {HTMLElement} the html element - */ - getDragEl: function() { - return Ext.getDom(this.dragElId); + // private + getState : function(){ + return Ext.apply(Ext.Window.superclass.getState.call(this) || {}, this.getBox(true)); }, - /** - * Sets up the DragDrop object. Must be called in the constructor of any - * 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); - }, + // private + onRender : function(ct, position){ + Ext.Window.superclass.onRender.call(this, ct, position); - /** - * 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) { + if(this.plain){ + this.el.addClass('x-window-plain'); + } - // configuration attributes - this.config = config || {}; + // this element allows the Window to be focused for keyboard events + this.focusEl = this.el.createChild({ + tag: 'a', href:'#', cls:'x-dlg-focus', + tabIndex:'-1', html: ' '}); + this.focusEl.swallowEvent('click', true); - // create a local reference to the drag and drop manager - this.DDM = Ext.dd.DDM; - // initialize the groups array - this.groups = {}; + this.proxy = this.el.createProxy('x-window-proxy'); + this.proxy.enableDisplayMode('block'); - // assume that we have an element reference instead of an id if the - // parameter is not a string - if (typeof id !== "string") { - id = Ext.id(id); + if(this.modal){ + this.mask = this.container.createChild({cls:'ext-el-mask'}, this.el.dom); + this.mask.enableDisplayMode('block'); + this.mask.hide(); + this.mon(this.mask, 'click', this.focus, this); } + if(this.maximizable){ + this.mon(this.header, 'dblclick', this.toggleMaximize, this); + } + }, - // set the id - this.id = id; + // private + initEvents : function(){ + Ext.Window.superclass.initEvents.call(this); + if(this.animateTarget){ + this.setAnimateTarget(this.animateTarget); + } - // add to an interaction group - this.addToGroup((sGroup) ? sGroup : "default"); + if(this.resizable){ + this.resizer = new Ext.Resizable(this.el, { + minWidth: this.minWidth, + minHeight:this.minHeight, + handles: this.resizeHandles || 'all', + pinned: true, + resizeElement : this.resizerAction, + handleCls: 'x-window-handle' + }); + this.resizer.window = this; + this.mon(this.resizer, 'beforeresize', this.beforeResize, this); + } - // 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; + if(this.draggable){ + this.header.addClass('x-window-draggable'); + } + this.mon(this.el, 'mousedown', this.toFront, this); + this.manager = this.manager || Ext.WindowMgr; + this.manager.register(this); + if(this.maximized){ + this.maximized = false; + this.maximize(); + } + if(this.closable){ + var km = this.getKeyMap(); + km.on(27, this.onEsc, this); + km.disable(); + } + }, - // the linked element is the element that gets dragged by default - this.setDragElId(id); + initDraggable : function(){ + /** + *
If this Window is configured {@link #draggable}, this property will contain + * an instance of {@link Ext.dd.DD} which handles dragging the Window's DOM Element.
+ *
This has implementations of startDrag, onDrag and endDrag + * which perform the dragging action. If extra logic is needed at these points, use + * {@link Function#createInterceptor createInterceptor} or {@link Function#createSequence createSequence} to + * augment the existing implementations.
+ * @type Ext.dd.DD + * @property dd + */ + this.dd = new Ext.Window.DD(this); + }, - // by default, clicked anchors will not start drag operations. - this.invalidHandleTypes = { A: "A" }; - this.invalidHandleIds = {}; - this.invalidHandleClasses = []; + // private + onEsc : function(k, e){ + e.stopEvent(); + this[this.closeAction](); + }, - this.applyConfig(); + // private + beforeDestroy : function(){ + if(this.rendered){ + this.hide(); + this.clearAnchor(); + Ext.destroy( + this.focusEl, + this.resizer, + this.dd, + this.proxy, + this.mask + ); + } + Ext.Window.superclass.beforeDestroy.call(this); + }, - this.handleOnAvailable(); + // private + onDestroy : function(){ + if(this.manager){ + this.manager.unregister(this); + } + Ext.Window.superclass.onDestroy.call(this); + }, + + // private + initTools : function(){ + if(this.minimizable){ + this.addTool({ + id: 'minimize', + handler: this.minimize.createDelegate(this, []) + }); + } + if(this.maximizable){ + this.addTool({ + id: 'maximize', + handler: this.maximize.createDelegate(this, []) + }); + this.addTool({ + id: 'restore', + handler: this.restore.createDelegate(this, []), + hidden:true + }); + } + if(this.closable){ + this.addTool({ + id: 'close', + handler: this[this.closeAction].createDelegate(this, []) + }); + } }, - /** - * 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() { + // private + resizerAction : function(){ + var box = this.proxy.getBox(); + this.proxy.hide(); + this.window.handleResize(box); + return box; + }, - // 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); + // private + beforeResize : function(){ + this.resizer.minHeight = Math.max(this.minHeight, this.getFrameHeight() + 40); // 40 is a magic minimum content size? + this.resizer.minWidth = Math.max(this.minWidth, this.getFrameWidth() + 40); + this.resizeBox = this.el.getBox(); + }, + // private + updateHandles : function(){ + if(Ext.isIE && this.resizer){ + this.resizer.syncHandleHeight(); + this.el.repaint(); + } }, - /** - * Executed when the linked element is available - * @method handleOnAvailable - * @private - */ - handleOnAvailable: function() { - this.available = true; - this.resetConstraints(); - this.onAvailable(); + // private + handleResize : function(box){ + var rz = this.resizeBox; + if(rz.x != box.x || rz.y != box.y){ + this.updateBox(box); + }else{ + this.setSize(box); + if (Ext.isIE6 && Ext.isStrict) { + this.doLayout(); + } + } + this.focus(); + this.updateHandles(); + this.saveState(); }, - /** - * 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 + /** + * Focuses the window. If a defaultButton is set, it will receive focus, otherwise the + * window itself will receive focus. */ - 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]; + focus : function(){ + var f = this.focusEl, + db = this.defaultButton, + t = typeof db, + el, + ct; + if(Ext.isDefined(db)){ + if(Ext.isNumber(db) && this.fbar){ + f = this.fbar.items.get(db); + }else if(Ext.isString(db)){ + f = Ext.getCmp(db); + }else{ + f = db; + } + el = f.getEl(); + ct = Ext.getDom(this.container); + if (el && ct) { + if (!Ext.lib.Region.getRegion(ct).contains(Ext.lib.Region.getRegion(el.dom))){ + return; + } + } } + f = f || this.focusEl; + f.focus.defer(10, f); }, /** - * Stores the initial placement of the linked element. - * @method setInitPosition - * @param {int} diffX the X offset, default 0 - * @param {int} diffY the Y offset, default 0 + * Sets the target element from which the window should animate while opening. + * @param {String/Element} el The target element or id */ - setInitPosition: function(diffX, diffY) { - var el = this.getEl(); + setAnimateTarget : function(el){ + el = Ext.get(el); + this.animateTarget = el; + }, - if (!this.DDM.verifyEl(el)) { - return; + // private + beforeShow : function(){ + delete this.el.lastXY; + delete this.el.lastLT; + if(this.x === undefined || this.y === undefined){ + var xy = this.el.getAlignToXY(this.container, 'c-c'); + var pos = this.el.translatePoints(xy[0], xy[1]); + this.x = this.x === undefined? pos.left : this.x; + this.y = this.y === undefined? pos.top : this.y; } + this.el.setLeftTop(this.x, this.y); - 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]; - + if(this.expandOnShow){ + this.expand(false); + } - this.setStartPosition(p); + if(this.modal){ + Ext.getBody().addClass('x-body-masked'); + this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); + this.mask.show(); + } }, /** - * 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 + * Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden. + * @param {String/Element} animateTarget (optional) The target element or id from which the window should + * animate while opening (defaults to null with no animation) + * @param {Function} callback (optional) A callback function to call after the window is displayed + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Window. + * @return {Ext.Window} this */ - setStartPosition: function(pos) { - var p = pos || Dom.getXY( this.getEl() ); - this.deltaSetXY = null; + show : function(animateTarget, cb, scope){ + if(!this.rendered){ + this.render(Ext.getBody()); + } + if(this.hidden === false){ + this.toFront(); + return this; + } + if(this.fireEvent('beforeshow', this) === false){ + return this; + } + if(cb){ + this.on('show', cb, scope, {single:true}); + } + this.hidden = false; + if(Ext.isDefined(animateTarget)){ + this.setAnimateTarget(animateTarget); + } + this.beforeShow(); + if(this.animateTarget){ + this.animShow(); + }else{ + this.afterShow(); + } + return this; + }, - this.startPageX = p[0]; - this.startPageY = p[1]; + // private + afterShow : function(isAnim){ + if (this.isDestroyed){ + return false; + } + this.proxy.hide(); + this.el.setStyle('display', 'block'); + this.el.show(); + if(this.maximized){ + this.fitContainer(); + } + if(Ext.isMac && Ext.isGecko2){ // work around stupid FF 2.0/Mac scroll bar bug + this.cascade(this.setAutoScroll); + } + + if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){ + Ext.EventManager.onWindowResize(this.onWindowResize, this); + } + this.doConstrain(); + this.doLayout(); + if(this.keyMap){ + this.keyMap.enable(); + } + this.toFront(); + this.updateHandles(); + if(isAnim && (Ext.isIE || Ext.isWebKit)){ + var sz = this.getSize(); + this.onResize(sz.width, sz.height); + } + this.onShow(); + this.fireEvent('show', this); }, - /** - * 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); + // private + animShow : function(){ + this.proxy.show(); + this.proxy.setBox(this.animateTarget.getBox()); + this.proxy.setOpacity(0); + var b = this.getBox(); + this.el.setStyle('display', 'none'); + this.proxy.shift(Ext.apply(b, { + callback: this.afterShow.createDelegate(this, [true], false), + scope: this, + easing: 'easeNone', + duration: 0.25, + opacity: 0.5 + })); }, /** - * Remove's this instance from the supplied interaction group - * @method removeFromGroup - * @param {string} sGroup The group to drop + * Hides the window, setting it to invisible and applying negative offsets. + * @param {String/Element} animateTarget (optional) The target element or id to which the window should + * animate while hiding (defaults to null with no animation) + * @param {Function} callback (optional) A callback function to call after the window is hidden + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Window. + * @return {Ext.Window} this */ - removeFromGroup: function(sGroup) { - if (this.groups[sGroup]) { - delete this.groups[sGroup]; + hide : function(animateTarget, cb, scope){ + if(this.hidden || this.fireEvent('beforehide', this) === false){ + return this; } + if(cb){ + this.on('hide', cb, scope, {single:true}); + } + this.hidden = true; + if(animateTarget !== undefined){ + this.setAnimateTarget(animateTarget); + } + if(this.modal){ + this.mask.hide(); + Ext.getBody().removeClass('x-body-masked'); + } + if(this.animateTarget){ + this.animHide(); + }else{ + this.el.hide(); + this.afterHide(); + } + return this; + }, - this.DDM.removeDDFromGroup(this, sGroup); + // private + afterHide : function(){ + this.proxy.hide(); + if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){ + Ext.EventManager.removeResizeListener(this.onWindowResize, this); + } + if(this.keyMap){ + this.keyMap.disable(); + } + this.onHide(); + this.fireEvent('hide', this); }, - /** - * 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; + // private + animHide : function(){ + this.proxy.setOpacity(0.5); + this.proxy.show(); + var tb = this.getBox(false); + this.proxy.setBox(tb); + this.el.hide(); + this.proxy.shift(Ext.apply(this.animateTarget.getBox(), { + callback: this.afterHide, + scope: this, + duration: 0.25, + easing: 'easeNone', + opacity: 0 + })); }, /** - * 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. + * Method that is called immediately before the show event is fired. + * Defaults to Ext.emptyFn. */ - setHandleElId: function(id) { - if (typeof id !== "string") { - id = Ext.id(id); - } - this.handleElId = id; - this.DDM.regHandle(this.id, id); - }, + onShow : Ext.emptyFn, /** - * 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 + * Method that is called immediately before the hide event is fired. + * Defaults to Ext.emptyFn. */ - setOuterHandleElId: function(id) { - if (typeof id !== "string") { - id = Ext.id(id); + onHide : Ext.emptyFn, + + // private + onWindowResize : function(){ + if(this.maximized){ + this.fitContainer(); } - Event.on(id, "mousedown", - this.handleMouseDown, this); - this.setHandleElId(id); + if(this.modal){ + this.mask.setSize('100%', '100%'); + var force = this.mask.dom.offsetHeight; + this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); + } + this.doConstrain(); + }, - this.hasOuterHandles = true; + // private + doConstrain : function(){ + if(this.constrain || this.constrainHeader){ + var offsets; + if(this.constrain){ + offsets = { + right:this.el.shadowOffset, + left:this.el.shadowOffset, + bottom:this.el.shadowOffset + }; + }else { + var s = this.getSize(); + offsets = { + right:-(s.width - 100), + bottom:-(s.height - 25) + }; + } + + var xy = this.el.getConstrainToXY(this.container, true, offsets); + if(xy){ + this.setPosition(xy[0], xy[1]); + } + } }, - /** - * 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); + // private - used for dragging + ghost : function(cls){ + var ghost = this.createGhost(cls); + var box = this.getBox(true); + ghost.setLeftTop(box.x, box.y); + ghost.setWidth(box.width); + this.el.hide(); + this.activeGhost = ghost; + return ghost; }, - destroy : function(){ - this.unreg(); + // private + unghost : function(show, matchPosition){ + if(!this.activeGhost) { + return; + } + if(show !== false){ + this.el.show(); + this.focus.defer(10, this); + if(Ext.isMac && Ext.isGecko2){ // work around stupid FF 2.0/Mac scroll bar bug + this.cascade(this.setAutoScroll); + } + } + if(matchPosition !== false){ + this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true)); + } + this.activeGhost.hide(); + this.activeGhost.remove(); + delete this.activeGhost; }, /** - * 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 + * Placeholder method for minimizing the window. By default, this method simply fires the {@link #minimize} event + * since the behavior of minimizing a window is application-specific. To implement custom minimize behavior, + * either the minimize event can be handled or this method can be overridden. + * @return {Ext.Window} this */ - isLocked: function() { - return (this.DDM.isLocked() || this.locked); + minimize : function(){ + this.fireEvent('minimize', this); + return this; }, /** - * Fired when this object is clicked - * @method handleMouseDown - * @param {Event} e - * @param {Ext.dd.DragDrop} oDD the clicked dd object (this dd obj) - * @private + *
Closes the Window, removes it from the DOM, {@link Ext.Component#destroy destroy}s + * the Window object and all its descendant Components. The {@link Ext.Panel#beforeclose beforeclose} + * event is fired before the close happens and will cancel the close action if it returns false.
+ *
Note: This method is not affected by the {@link #closeAction} setting which + * only affects the action triggered when clicking the {@link #closable 'close' tool in the header}. + * To hide the Window without destroying it, call {@link #hide}.
*/ - handleMouseDown: function(e, oDD){ - if (this.primaryButtonOnly && e.button != 0) { - return; + close : function(){ + if(this.fireEvent('beforeclose', this) !== false){ + if(this.hidden){ + this.doClose(); + }else{ + this.hide(null, this.doClose, this); + } } + }, - if (this.isLocked()) { - return; - } + // private + doClose : function(){ + this.fireEvent('close', this); + this.destroy(); + }, - this.DDM.refreshCache(this.groups); + /** + * Fits the window within its current container and automatically replaces + * the {@link #maximizable 'maximize' tool button} with the 'restore' tool button. + * Also see {@link #toggleMaximize}. + * @return {Ext.Window} this + */ + maximize : function(){ + if(!this.maximized){ + this.expand(false); + this.restoreSize = this.getSize(); + this.restorePos = this.getPosition(true); + if (this.maximizable){ + this.tools.maximize.hide(); + this.tools.restore.show(); + } + this.maximized = true; + this.el.disableShadow(); - var pt = new Ext.lib.Point(Ext.lib.Event.getPageX(e), Ext.lib.Event.getPageY(e)); - if (!this.hasOuterHandles && !this.DDM.isOverTarget(pt, this) ) { - } else { - if (this.clickValidator(e)) { + if(this.dd){ + this.dd.lock(); + } + if(this.collapsible){ + this.tools.toggle.hide(); + } + this.el.addClass('x-window-maximized'); + this.container.addClass('x-window-maximized-ct'); - // set the initial element position - this.setStartPosition(); + this.setPosition(0, 0); + this.fitContainer(); + this.fireEvent('maximize', this); + } + return this; + }, + + /** + * Restores a {@link #maximizable maximized} window back to its original + * size and position prior to being maximized and also replaces + * the 'restore' tool button with the 'maximize' tool button. + * Also see {@link #toggleMaximize}. + * @return {Ext.Window} this + */ + restore : function(){ + if(this.maximized){ + var t = this.tools; + this.el.removeClass('x-window-maximized'); + if(t.restore){ + t.restore.hide(); + } + if(t.maximize){ + t.maximize.show(); + } + this.setPosition(this.restorePos[0], this.restorePos[1]); + this.setSize(this.restoreSize.width, this.restoreSize.height); + delete this.restorePos; + delete this.restoreSize; + this.maximized = false; + this.el.enableShadow(true); + if(this.dd){ + this.dd.unlock(); + } + if(this.collapsible && t.toggle){ + t.toggle.show(); + } + this.container.removeClass('x-window-maximized-ct'); - this.b4MouseDown(e); - this.onMouseDown(e); + this.doConstrain(); + this.fireEvent('restore', this); + } + return this; + }, - this.DDM.handleMouseDown(e, this); + /** + * A shortcut method for toggling between {@link #maximize} and {@link #restore} based on the current maximized + * state of the window. + * @return {Ext.Window} this + */ + toggleMaximize : function(){ + return this[this.maximized ? 'restore' : 'maximize'](); + }, - this.DDM.stopEvent(e); - } else { + // private + fitContainer : function(){ + var vs = this.container.getViewSize(false); + this.setSize(vs.width, vs.height); + }, + // private + // z-index is managed by the WindowManager and may be overwritten at any time + setZIndex : function(index){ + if(this.modal){ + this.mask.setStyle('z-index', index); + } + this.el.setZIndex(++index); + index += 5; - } + if(this.resizer){ + this.resizer.proxy.setStyle('z-index', ++index); } - }, - clickValidator: function(e) { - var target = e.getTarget(); - return ( this.isValidHandleChild(target) && - (this.id == this.handleElId || - this.DDM.handleWasClicked(target, this.id)) ); + this.lastZIndex = index; }, /** - * 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 + * Aligns the window to the specified element + * @param {Mixed} element The element to align to. + * @param {String} position (optional, defaults to "tl-bl?") The position to align to (see {@link Ext.Element#alignTo} for more details). + * @param {Array} offsets (optional) Offset the positioning by [x, y] + * @return {Ext.Window} this */ - addInvalidHandleType: function(tagName) { - var type = tagName.toUpperCase(); - this.invalidHandleTypes[type] = type; + alignTo : function(element, position, offsets){ + var xy = this.el.getAlignToXY(element, position, offsets); + this.setPagePosition(xy[0], xy[1]); + return this; }, /** - * 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 + * Anchors this window to another element and realigns it when the window is resized or scrolled. + * @param {Mixed} element The element to align to. + * @param {String} position The position to align to (see {@link Ext.Element#alignTo} for more details) + * @param {Array} offsets (optional) Offset the positioning by [x, y] + * @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). + * @return {Ext.Window} this */ - addInvalidHandleId: function(id) { - if (typeof id !== "string") { - id = Ext.id(id); + anchorTo : function(el, alignment, offsets, monitorScroll){ + this.clearAnchor(); + this.anchorTarget = { + el: el, + alignment: alignment, + offsets: offsets + }; + + Ext.EventManager.onWindowResize(this.doAnchor, this); + var tm = typeof monitorScroll; + if(tm != 'undefined'){ + Ext.EventManager.on(window, 'scroll', this.doAnchor, this, + {buffer: tm == 'number' ? monitorScroll : 50}); } - this.invalidHandleIds[id] = id; + return this.doAnchor(); }, /** - * 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 + * Performs the anchor, using the saved anchorTarget property. + * @return {Ext.Window} this + * @private */ - addInvalidHandleClass: function(cssClass) { - this.invalidHandleClasses.push(cssClass); + doAnchor : function(){ + var o = this.anchorTarget; + this.alignTo(o.el, o.alignment, o.offsets); + return this; }, /** - * Unsets an excluded tag name set by addInvalidHandleType - * @method removeInvalidHandleType - * @param {string} tagName the type of element to unexclude + * Removes any existing anchor from this window. See {@link #anchorTo}. + * @return {Ext.Window} this */ - removeInvalidHandleType: function(tagName) { - var type = tagName.toUpperCase(); - // this.invalidHandleTypes[type] = null; - delete this.invalidHandleTypes[type]; + clearAnchor : function(){ + if(this.anchorTarget){ + Ext.EventManager.removeResizeListener(this.doAnchor, this); + Ext.EventManager.un(window, 'scroll', this.doAnchor, this); + delete this.anchorTarget; + } + return this; }, /** - * Unsets an invalid handle id - * @method removeInvalidHandleId - * @param {string} id the id of the element to re-enable + * Brings this window to the front of any other visible windows + * @param {Boolean} e (optional) Specify false to prevent the window from being focused. + * @return {Ext.Window} this */ - removeInvalidHandleId: function(id) { - if (typeof id !== "string") { - id = Ext.id(id); + toFront : function(e){ + if(this.manager.bringToFront(this)){ + if(!e || !e.getTarget().focus){ + this.focus(); + } } - delete this.invalidHandleIds[id]; + return this; }, /** - * Unsets an invalid css class - * @method removeInvalidHandleClass - * @param {string} cssClass the class of the element(s) you wish to - * re-enable + * Makes this the active window by showing its shadow, or deactivates it by hiding its shadow. This method also + * fires the {@link #activate} or {@link #deactivate} event depending on which action occurred. This method is + * called internally by {@link Ext.WindowMgr}. + * @param {Boolean} active True to activate the window, false to deactivate it (defaults to false) */ - 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; - } - } +// private - custom Window DD implementation +Ext.Window.DD = function(win){ + this.win = win; + Ext.Window.DD.superclass.constructor.call(this, win.el.id, 'WindowDD-'+win.id); + this.setHandleElId(win.header.id); + this.scroll = false; +}; - for (i = this.initPageX; i <= this.maxX; i = i + iTickSize) { - if (!tickMap[i]) { - this.xTicks[this.xTicks.length] = i; - tickMap[i] = true; - } +Ext.extend(Ext.Window.DD, Ext.dd.DD, { + moveOnly:true, + headerOffsets:[100, 25], + startDrag : function(){ + var w = this.win; + this.proxy = w.ghost(); + if(w.constrain !== false){ + var so = w.el.shadowOffset; + this.constrainTo(w.container, {right: so, left: so, bottom: so}); + }else if(w.constrainHeader !== false){ + var s = this.proxy.getSize(); + this.constrainTo(w.container, {right: -(s.width-this.headerOffsets[0]), bottom: -(s.height-this.headerOffsets[1])}); } + }, + b4Drag : Ext.emptyFn, - this.xTicks.sort(this.DDM.numericSort) ; + onDrag : function(e){ + this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY()); }, - /** - * 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; + endDrag : function(e){ + this.win.unghost(); + this.win.saveState(); + } +}); +/** + * @class Ext.WindowGroup + * An object that manages a group of {@link Ext.Window} instances and provides z-order management + * and window activation behavior. + * @constructor + */ +Ext.WindowGroup = function(){ + var list = {}; + var accessList = []; + var front = null; - var tickMap = {}; + // private + var sortWindows = function(d1, d2){ + return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1 : 1; + }; - for (var i = this.initPageY; i >= this.minY; i = i - iTickSize) { - if (!tickMap[i]) { - this.yTicks[this.yTicks.length] = i; - tickMap[i] = true; + // private + var orderWindows = function(){ + var a = accessList, len = a.length; + if(len > 0){ + a.sort(sortWindows); + var seed = a[0].manager.zseed; + for(var i = 0; i < len; i++){ + var win = a[i]; + if(win && !win.hidden){ + win.setZIndex(seed + (i*10)); + } } } + activateLast(); + }; - for (i = this.initPageY; i <= this.maxY; i = i + iTickSize) { - if (!tickMap[i]) { - this.yTicks[this.yTicks.length] = i; - tickMap[i] = true; + // private + var setActiveWin = function(win){ + if(win != front){ + if(front){ + front.setActive(false); + } + front = win; + if(win){ + win.setActive(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; - - }, + // private + var activateLast = function(){ + for(var i = accessList.length-1; i >=0; --i) { + if(!accessList[i].hidden){ + setActiveWin(accessList[i]); + return; + } + } + // none to activate + setActiveWin(null); + }; - /** - * resetConstraints must be called if you manually reposition a dd element. - * @method resetConstraints - * @param {boolean} maintainOffset - */ - resetConstraints: function() { + return { + /** + * The starting z-index for windows in this WindowGroup (defaults to 9000) + * @type Number The z-index value + */ + zseed : 9000, + /** + *
Registers a {@link Ext.Window Window} with this WindowManager. This should not + * need to be called under normal circumstances. Windows are automatically registered + * with a {@link Ext.Window#manager manager} at construction time.
+ *
Where this may be useful is moving Windows between two WindowManagers. For example, + * to bring the Ext.MessageBox dialog under the same manager as the Desktop's + * WindowManager in the desktop sample app:
+var msgWin = Ext.MessageBox.getDialog(); +MyDesktop.getDesktop().getManager().register(msgWin); + + * @param {Window} win The Window to register. + */ + register : function(win){ + if(win.manager){ + win.manager.unregister(win); + } + win.manager = this; - // 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; + list[win.id] = win; + accessList.push(win); + win.on('hide', activateLast); + }, - this.setInitPosition(dx, dy); + /** + *
Unregisters a {@link Ext.Window Window} from this WindowManager. This should not + * need to be called. Windows are automatically unregistered upon destruction. + * See {@link #register}.
+ * @param {Window} win The Window to unregister. + */ + unregister : function(win){ + delete win.manager; + delete list[win.id]; + win.un('hide', activateLast); + accessList.remove(win); + }, - // This is the first time we have detected the element's position - } else { - this.setInitPosition(); - } + /** + * Gets a registered window by id. + * @param {String/Object} id The id of the window or a {@link Ext.Window} instance + * @return {Ext.Window} + */ + get : function(id){ + return typeof id == "object" ? id : list[id]; + }, - if (this.constrainX) { - this.setXConstraint( this.leftConstraint, - this.rightConstraint, - this.xTickSize ); - } + /** + * Brings the specified window to the front of any other active windows in this WindowGroup. + * @param {String/Object} win The id of the window or a {@link Ext.Window} instance + * @return {Boolean} True if the dialog was brought to the front, else false + * if it was already in front + */ + bringToFront : function(win){ + win = this.get(win); + if(win != front){ + win._lastAccess = new Date().getTime(); + orderWindows(); + return true; + } + return false; + }, - if (this.constrainY) { - this.setYConstraint( this.topConstraint, - this.bottomConstraint, - this.yTickSize ); - } - }, + /** + * Sends the specified window to the back of other active windows in this WindowGroup. + * @param {String/Object} win The id of the window or a {@link Ext.Window} instance + * @return {Ext.Window} The window + */ + sendToBack : function(win){ + win = this.get(win); + win._lastAccess = -(new Date().getTime()); + orderWindows(); + return win; + }, - /** - * 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) { + /** + * Hides all windows in this WindowGroup. + */ + hideAll : function(){ + for(var id in list){ + if(list[id] && typeof list[id] != "function" && list[id].isVisible()){ + list[id].hide(); + } + } + }, - 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]; + /** + * Gets the currently-active window in this WindowGroup. + * @return {Ext.Window} The active window + */ + getActive : function(){ + return front; + }, + + /** + * Returns zero or more windows in this WindowGroup using the custom search function passed to this method. + * The function should accept a single {@link Ext.Window} reference as its only argument and should + * return true if the window matches the search criteria, otherwise it should return false. + * @param {Function} fn The search function + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the Window being tested. + * that gets passed to the function if not specified) + * @return {Array} An array of zero or more matching windows + */ + getBy : function(fn, scope){ + var r = []; + for(var i = accessList.length-1; i >=0; --i) { + var win = accessList[i]; + if(fn.call(scope||win, win) !== false){ + r.push(win); } } + return r; + }, - // The value is larger than the last tick, so we return the last - // tick. - return tickArray[tickArray.length - 1]; + /** + * Executes the specified function once for every window in this WindowGroup, passing each + * window as the only parameter. 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 (this reference) in which the function is executed. Defaults to the current Window in the iteration. + */ + each : function(fn, scope){ + for(var id in list){ + if(list[id] && typeof list[id] != "function"){ + if(fn.call(scope || list[id], list[id]) === false){ + return; + } + } + } } - }, - - /** - * 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. + * @class Ext.WindowMgr + * @extends Ext.WindowGroup + * The default global window group that is available automatically. To have more than one group of windows + * with separate z-order stacks, create additional instances of {@link Ext.WindowGroup} as needed. + * @singleton */ +Ext.WindowMgr = new Ext.WindowGroup();/** + * @class Ext.MessageBox + *
Utility class for generating different styles of message boxes. The alias Ext.Msg can also be used.
+ *
Note that the MessageBox is asynchronous. Unlike a regular JavaScript alert (which will halt + * browser execution), showing a MessageBox will not cause the code to stop. For this reason, if you have code + * that should only run after some user feedback from the MessageBox, you must use a callback function + * (see the function parameter for {@link #show} for more details).
+ *
Example usage:
+ *
+// Basic alert: +Ext.Msg.alert('Status', 'Changes saved successfully.'); -// Only load the library once. Rewriting the manager class would orphan -// existing drag and drop instances. -if (!Ext.dd.DragDropMgr) { +// Prompt for user data and process the result using a callback: +Ext.Msg.prompt('Name', 'Please enter your name:', function(btn, text){ + if (btn == 'ok'){ + // process text value and close... + } +}); -/** - * @class 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. +// Show a dialog using config options: +Ext.Msg.show({ + title:'Save Changes?', + msg: 'You are closing a tab that has unsaved changes. Would you like to save your changes?', + buttons: Ext.Msg.YESNOCANCEL, + fn: processResult, + animEl: 'elId', + icon: Ext.MessageBox.QUESTION +}); +
* @singleton */ -Ext.dd.DragDropMgr = function() { +Ext.MessageBox = function(){ + var dlg, opt, mask, waitTimer, + bodyEl, msgEl, textboxEl, textareaEl, progressBar, pp, iconEl, spacerEl, + buttons, activeTextEl, bwidth, bufferIcon = '', iconCls = '', + buttonNames = ['ok', 'yes', 'no', 'cancel']; - var Event = Ext.EventManager; + // private + var handleButton = function(button){ + buttons[button].blur(); + if(dlg.isVisible()){ + dlg.hide(); + handleHide(); + Ext.callback(opt.fn, opt.scope||window, [button, activeTextEl.dom.value, opt], 1); + } + }; - return { + // private + var handleHide = function(){ + if(opt && opt.cls){ + dlg.el.removeClass(opt.cls); + } + progressBar.reset(); + }; + + // private + var handleEsc = function(d, k, e){ + if(opt && opt.closable !== false){ + dlg.hide(); + handleHide(); + } + if(e){ + e.stopEvent(); + } + }; + + // private + var updateButtons = function(b){ + var width = 0, + cfg; + if(!b){ + Ext.each(buttonNames, function(name){ + buttons[name].hide(); + }); + return width; + } + dlg.footer.dom.style.display = ''; + Ext.iterate(buttons, function(name, btn){ + cfg = b[name]; + if(cfg){ + btn.show(); + btn.setText(Ext.isString(cfg) ? cfg : Ext.MessageBox.buttonText[name]); + width += btn.getEl().getWidth() + 15; + }else{ + btn.hide(); + } + }); + return width; + }; + 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 + * Returns a reference to the underlying {@link Ext.Window} element + * @return {Ext.Window} The window */ - ids: {}, + getDialog : function(titleText){ + if(!dlg){ + var btns = []; + + buttons = {}; + Ext.each(buttonNames, function(name){ + btns.push(buttons[name] = new Ext.Button({ + text: this.buttonText[name], + handler: handleButton.createCallback(name), + hideMode: 'offsets' + })); + }, this); + dlg = new Ext.Window({ + autoCreate : true, + title:titleText, + resizable:false, + constrain:true, + constrainHeader:true, + minimizable : false, + maximizable : false, + stateful: false, + modal: true, + shim:true, + buttonAlign:"center", + width:400, + height:100, + minHeight: 80, + plain:true, + footer:true, + closable:true, + close : function(){ + if(opt && opt.buttons && opt.buttons.no && !opt.buttons.cancel){ + handleButton("no"); + }else{ + handleButton("cancel"); + } + }, + fbar: new Ext.Toolbar({ + items: btns, + enableOverflow: false + }) + }); + dlg.render(document.body); + dlg.getEl().addClass('x-window-dlg'); + mask = dlg.mask; + bodyEl = dlg.body.createChild({ + html:'

' + }); + iconEl = Ext.get(bodyEl.dom.firstChild); + var contentEl = bodyEl.dom.childNodes[1]; + msgEl = Ext.get(contentEl.firstChild); + textboxEl = Ext.get(contentEl.childNodes[2].firstChild); + textboxEl.enableDisplayMode(); + textboxEl.addKeyListener([10,13], function(){ + if(dlg.isVisible() && opt && opt.buttons){ + if(opt.buttons.ok){ + handleButton("ok"); + }else if(opt.buttons.yes){ + handleButton("yes"); + } + } + }); + textareaEl = Ext.get(contentEl.childNodes[2].childNodes[1]); + textareaEl.enableDisplayMode(); + progressBar = new Ext.ProgressBar({ + renderTo:bodyEl + }); + bodyEl.createChild({cls:'x-clear'}); + } + return dlg; + }, /** - * 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 + * Updates the message box body text + * @param {String} text (optional) Replaces the message box element's innerHTML with the specified string (defaults to + * the XHTML-compliant non-breaking space character ' ') + * @return {Ext.MessageBox} this */ - handleIds: {}, + updateText : function(text){ + if(!dlg.isVisible() && !opt.width){ + dlg.setSize(this.maxWidth, 100); // resize first so content is never clipped from previous shows + } + msgEl.update(text || ' '); - /** - * the DragDrop object that is currently being dragged - * @property dragCurrent - * @type DragDrop - * @private - * @static - **/ - dragCurrent: null, + var iw = iconCls != '' ? (iconEl.getWidth() + iconEl.getMargins('lr')) : 0, + mw = msgEl.getWidth() + msgEl.getMargins('lr'), + fw = dlg.getFrameWidth('lr'), + bw = dlg.body.getFrameWidth('lr'), + w; + + if (Ext.isIE && iw > 0){ + //3 pixels get subtracted in the icon CSS for an IE margin issue, + //so we have to add it back here for the overall width to be consistent + iw += 3; + } + w = Math.max(Math.min(opt.width || iw+mw+fw+bw, opt.maxWidth || this.maxWidth), + Math.max(opt.minWidth || this.minWidth, bwidth || 0)); + + if(opt.prompt === true){ + activeTextEl.setWidth(w-iw-fw-bw); + } + if(opt.progress === true || opt.wait === true){ + progressBar.setSize(w-iw-fw-bw); + } + if(Ext.isIE && w == bwidth){ + w += 4; //Add offset when the content width is smaller than the buttons. + } + dlg.setSize(w, 'auto').center(); + return this; + }, /** - * the DragDrop object(s) that are being hovered over - * @property dragOvers - * @type Array - * @private - * @static + * Updates a progress-style message box's text and progress bar. Only relevant on message boxes + * initiated via {@link Ext.MessageBox#progress} or {@link Ext.MessageBox#wait}, + * or by calling {@link Ext.MessageBox#show} with progress: true. + * @param {Number} value Any number between 0 and 1 (e.g., .5, defaults to 0) + * @param {String} progressText The progress text to display inside the progress bar (defaults to '') + * @param {String} msg The message box's body text is replaced with the specified string (defaults to undefined + * so that any existing body text will not get overwritten by default unless a new value is passed in) + * @return {Ext.MessageBox} this */ - dragOvers: {}, + updateProgress : function(value, progressText, msg){ + progressBar.updateProgress(value, progressText); + if(msg){ + this.updateText(msg); + } + return this; + }, /** - * the X distance between the cursor and the object being dragged - * @property deltaX - * @type int - * @private - * @static + * Returns true if the message box is currently displayed + * @return {Boolean} True if the message box is visible, else false */ - deltaX: 0, + isVisible : function(){ + return dlg && dlg.isVisible(); + }, /** - * the Y distance between the cursor and the object being dragged - * @property deltaY - * @type int - * @private - * @static + * Hides the message box if it is displayed + * @return {Ext.MessageBox} this */ - deltaY: 0, + hide : function(){ + var proxy = dlg ? dlg.activeGhost : null; + if(this.isVisible() || proxy){ + dlg.hide(); + handleHide(); + if (proxy){ + // unghost is a private function, but i saw no better solution + // to fix the locking problem when dragging while it closes + dlg.unghost(false, false); + } + } + return this; + }, /** - * 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 + * Displays a new message box, or reinitializes an existing message box, based on the config options + * passed in. All display functions (e.g. prompt, alert, etc.) on MessageBox call this function internally, + * although those calls are basic shortcuts and do not support all of the config options allowed here. + * @param {Object} config The following config options are supported:
+ *
animEl : String/Element
An id or Element from which the message box should animate as it + * opens and closes (defaults to undefined)
+ *
buttons : Object/Boolean
A button config object (e.g., Ext.MessageBox.OKCANCEL or {ok:'Foo', + * cancel:'Bar'}), or false to not show any buttons (defaults to false)
+ *
closable : Boolean
False to hide the top-right close button (defaults to true). Note that + * progress and wait dialogs will ignore this property and always hide the close button as they can only + * be closed programmatically.
+ *
cls : String
A custom CSS class to apply to the message box's container element
+ *
defaultTextHeight : Number
The default height in pixels of the message box's multiline textarea + * if displayed (defaults to 75)
+ *
fn : Function
A callback function which is called when the dialog is dismissed either + * by clicking on the configured buttons, or on the dialog close button, or by pressing + * the return button to enter input. + *
Progress and wait dialogs will ignore this option since they do not respond to user + * actions and can only be closed programmatically, so any required function should be called + * by the same code after it closes the dialog. Parameters passed:
+ *
buttonId : String
The ID of the button pressed, one of:
+ *
ok
+ *
yes
+ *
no
+ *
cancel
+ *
+ *
text : String
Value of the input field if either prompt + * or multiline is true
+ *
opt : Object
The config object passed to show.
+ *
+ *
scope : Object
The scope of the callback function
+ *
icon : String
A CSS class that provides a background image to be used as the body icon for the + * dialog (e.g. Ext.MessageBox.WARNING or 'custom-class') (defaults to '')
+ *
iconCls : String
The standard {@link Ext.Window#iconCls} to + * add an optional header icon (defaults to '')
+ *
maxWidth : Number
The maximum width in pixels of the message box (defaults to 600)
+ *
minWidth : Number
The minimum width in pixels of the message box (defaults to 100)
+ *
modal : Boolean
False to allow user interaction with the page while the message box is + * displayed (defaults to true)
+ *
msg : String
A string that will replace the existing message box body text (defaults to the + * XHTML-compliant non-breaking space character ' ')
+ *
multiline : Boolean
+ * True to prompt the user to enter multi-line text (defaults to false)
+ *
progress : Boolean
True to display a progress bar (defaults to false)
+ *
progressText : String
The text to display inside the progress bar if progress = true (defaults to '')
+ *
prompt : Boolean
True to prompt the user to enter single-line text (defaults to false)
+ *
proxyDrag : Boolean
True to display a lightweight proxy while dragging (defaults to false)
+ *
title : String
The title text
+ *
value : String
The string value to set into the active textbox element if displayed
+ *
wait : Boolean
True to display a progress bar (defaults to false)
+ *
waitConfig : Object
A {@link Ext.ProgressBar#waitConfig} object (applies only if wait = true)
+ *
width : Number
The width of the dialog in pixels
+ *
+ * Example usage: + *
+Ext.Msg.show({ + title: 'Address', + msg: 'Please enter your address:', + width: 300, + buttons: Ext.MessageBox.OKCANCEL, + multiline: true, + fn: saveAddress, + animEl: 'addAddressBtn', + icon: Ext.MessageBox.INFO +}); +
+ * @return {Ext.MessageBox} this */ - preventDefault: true, + show : function(options){ + if(this.isVisible()){ + this.hide(); + } + opt = options; + var d = this.getDialog(opt.title || " "); + + d.setTitle(opt.title || " "); + var allowClose = (opt.closable !== false && opt.progress !== true && opt.wait !== true); + d.tools.close.setDisplayed(allowClose); + activeTextEl = textboxEl; + opt.prompt = opt.prompt || (opt.multiline ? true : false); + if(opt.prompt){ + if(opt.multiline){ + textboxEl.hide(); + textareaEl.show(); + textareaEl.setHeight(Ext.isNumber(opt.multiline) ? opt.multiline : this.defaultTextHeight); + activeTextEl = textareaEl; + }else{ + textboxEl.show(); + textareaEl.hide(); + } + }else{ + textboxEl.hide(); + textareaEl.hide(); + } + activeTextEl.dom.value = opt.value || ""; + if(opt.prompt){ + d.focusEl = activeTextEl; + }else{ + var bs = opt.buttons; + var db = null; + if(bs && bs.ok){ + db = buttons["ok"]; + }else if(bs && bs.yes){ + db = buttons["yes"]; + } + if (db){ + d.focusEl = db; + } + } + if(opt.iconCls){ + d.setIconClass(opt.iconCls); + } + this.setIcon(Ext.isDefined(opt.icon) ? opt.icon : bufferIcon); + bwidth = updateButtons(opt.buttons); + progressBar.setVisible(opt.progress === true || opt.wait === true); + this.updateProgress(0, opt.progressText); + this.updateText(opt.msg); + if(opt.cls){ + d.el.addClass(opt.cls); + } + d.proxyDrag = opt.proxyDrag === true; + d.modal = opt.modal !== false; + d.mask = opt.modal !== false ? mask : false; + if(!d.isVisible()){ + // force it to the end of the z-index stack so it gets a cursor in FF + document.body.appendChild(dlg.el.dom); + d.setAnimateTarget(opt.animEl); + //workaround for window internally enabling keymap in afterShow + d.on('show', function(){ + if(allowClose === true){ + d.keyMap.enable(); + }else{ + d.keyMap.disable(); + } + }, this, {single:true}); + d.show(opt.animEl); + } + if(opt.wait === true){ + progressBar.wait(opt.waitConfig); + } + return this; + }, /** - * 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 + * Adds the specified icon to the dialog. By default, the class 'ext-mb-icon' is applied for default + * styling, and the class passed in is expected to supply the background image url. Pass in empty string ('') + * to clear any existing icon. This method must be called before the MessageBox is shown. + * The following built-in icon classes are supported, but you can also pass in a custom class name: + *
+Ext.MessageBox.INFO +Ext.MessageBox.WARNING +Ext.MessageBox.QUESTION +Ext.MessageBox.ERROR + *
+ * @param {String} icon A CSS classname specifying the icon's background image url, or empty string to clear the icon + * @return {Ext.MessageBox} this */ - stopPropagation: true, + setIcon : function(icon){ + if(!dlg){ + bufferIcon = icon; + return; + } + bufferIcon = undefined; + if(icon && icon != ''){ + iconEl.removeClass('x-hidden'); + iconEl.replaceClass(iconCls, icon); + bodyEl.addClass('x-dlg-icon'); + iconCls = icon; + }else{ + iconEl.replaceClass(iconCls, 'x-hidden'); + bodyEl.removeClass('x-dlg-icon'); + iconCls = ''; + } + return this; + }, /** - * Internal flag that is set to true when drag and drop has been - * intialized - * @property initialized - * @private - * @static + * Displays a message box with a progress bar. This message box has no buttons and is not closeable by + * the user. You are responsible for updating the progress bar as needed via {@link Ext.MessageBox#updateProgress} + * and closing the message box when the process is complete. + * @param {String} title The title bar text + * @param {String} msg The message box body text + * @param {String} progressText (optional) The text to display inside the progress bar (defaults to '') + * @return {Ext.MessageBox} this */ - initialized: false, + progress : function(title, msg, progressText){ + this.show({ + title : title, + msg : msg, + buttons: false, + progress:true, + closable:false, + minWidth: this.minProgressWidth, + progressText: progressText + }); + return this; + }, /** - * All drag and drop can be disabled. - * @property locked - * @private - * @static + * Displays a message box with an infinitely auto-updating progress bar. This can be used to block user + * interaction while waiting for a long-running process to complete that does not have defined intervals. + * You are responsible for closing the message box when the process is complete. + * @param {String} msg The message box body text + * @param {String} title (optional) The title bar text + * @param {Object} config (optional) A {@link Ext.ProgressBar#waitConfig} object + * @return {Ext.MessageBox} this */ - locked: false, + wait : function(msg, title, config){ + this.show({ + title : title, + msg : msg, + buttons: false, + closable:false, + wait:true, + modal:true, + minWidth: this.minProgressWidth, + waitConfig: config + }); + return this; + }, /** - * Called the first time an element is registered. - * @method init - * @private - * @static + * Displays a standard read-only message box with an OK button (comparable to the basic JavaScript alert prompt). + * If a callback function is passed it will be called after the user clicks the button, and the + * id of the button that was clicked will be passed as the only parameter to the callback + * (could also be the top-right close button). + * @param {String} title The title bar text + * @param {String} msg The message box body text + * @param {Function} fn (optional) The callback function invoked after the message box is closed + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. + * @return {Ext.MessageBox} this */ - init: function() { - this.initialized = true; + alert : function(title, msg, fn, scope){ + this.show({ + title : title, + msg : msg, + buttons: this.OK, + fn: fn, + scope : scope, + minWidth: this.minWidth + }); + return this; }, /** - * In point mode, drag and drop interaction is defined by the - * location of the cursor during the drag/drop - * @property POINT - * @type int - * @static + * Displays a confirmation message box with Yes and No buttons (comparable to JavaScript's confirm). + * If a callback function is passed it will be called after the user clicks either button, + * and the id of the button that was clicked will be passed as the only parameter to the callback + * (could also be the top-right close button). + * @param {String} title The title bar text + * @param {String} msg The message box body text + * @param {Function} fn (optional) The callback function invoked after the message box is closed + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. + * @return {Ext.MessageBox} this */ - POINT: 0, + confirm : function(title, msg, fn, scope){ + this.show({ + title : title, + msg : msg, + buttons: this.YESNO, + fn: fn, + scope : scope, + icon: this.QUESTION, + minWidth: this.minWidth + }); + return this; + }, /** - * 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 + * Displays a message box with OK and Cancel buttons prompting the user to enter some text (comparable to JavaScript's prompt). + * The prompt can be a single-line or multi-line textbox. If a callback function is passed it will be called after the user + * clicks either button, and the id of the button that was clicked (could also be the top-right + * close button) and the text that was entered will be passed as the two parameters to the callback. + * @param {String} title The title bar text + * @param {String} msg The message box body text + * @param {Function} fn (optional) The callback function invoked after the message box is closed + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. + * @param {Boolean/Number} multiline (optional) True to create a multiline textbox using the defaultTextHeight + * property, or the height in pixels to create the textbox (defaults to false / single-line) + * @param {String} value (optional) Default value of the text input element (defaults to '') + * @return {Ext.MessageBox} this */ - INTERSECT: 1, + prompt : function(title, msg, fn, scope, multiline, value){ + this.show({ + title : title, + msg : msg, + buttons: this.OKCANCEL, + fn: fn, + minWidth: this.minPromptWidth, + scope : scope, + prompt:true, + multiline: multiline, + value: value + }); + return this; + }, /** - * The current drag and drop mode. Default: POINT - * @property mode - * @type int - * @static + * Button config that displays a single OK button + * @type Object */ - mode: 0, - + OK : {ok:true}, /** - * Runs method on all drag and drop objects - * @method _execOnAll - * @private - * @static + * Button config that displays a single Cancel button + * @type Object */ - _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); - } - } - }, + CANCEL : {cancel:true}, + /** + * Button config that displays OK and Cancel buttons + * @type Object + */ + OKCANCEL : {ok:true, cancel:true}, + /** + * Button config that displays Yes and No buttons + * @type Object + */ + YESNO : {yes:true, no:true}, + /** + * Button config that displays Yes, No and Cancel buttons + * @type Object + */ + YESNOCANCEL : {yes:true, no:true, cancel:true}, + /** + * The CSS class that provides the INFO icon image + * @type String + */ + INFO : 'ext-mb-info', + /** + * The CSS class that provides the WARNING icon image + * @type String + */ + WARNING : 'ext-mb-warning', + /** + * The CSS class that provides the QUESTION icon image + * @type String + */ + QUESTION : 'ext-mb-question', + /** + * The CSS class that provides the ERROR icon image + * @type String + */ + ERROR : 'ext-mb-error', /** - * Drag and drop initialization. Sets up the global event handlers - * @method _onLoad - * @private - * @static + * The default height in pixels of the message box's multiline textarea if displayed (defaults to 75) + * @type Number */ - _onLoad: function() { + defaultTextHeight : 75, + /** + * The maximum width in pixels of the message box (defaults to 600) + * @type Number + */ + maxWidth : 600, + /** + * The minimum width in pixels of the message box (defaults to 100) + * @type Number + */ + minWidth : 100, + /** + * The minimum width in pixels of the message box if it is a progress-style dialog. This is useful + * for setting a different minimum width than text-only dialogs may need (defaults to 250). + * @type Number + */ + minProgressWidth : 250, + /** + * The minimum width in pixels of the message box if it is a prompt dialog. This is useful + * for setting a different minimum width than text-only dialogs may need (defaults to 250). + * @type Number + */ + minPromptWidth: 250, + /** + * An object containing the default button text strings that can be overriden for localized language support. + * Supported properties are: ok, cancel, yes and no. Generally you should include a locale-specific + * resource file for handling language support across the framework. + * Customize the default text like so: Ext.MessageBox.buttonText.yes = "oui"; //french + * @type Object + */ + buttonText : { + ok : "OK", + cancel : "Cancel", + yes : "Yes", + no : "No" + } + }; +}(); - this.init(); +/** + * Shorthand for {@link Ext.MessageBox} + */ +Ext.Msg = Ext.MessageBox;/** + * @class Ext.dd.PanelProxy + * A custom drag proxy implementation specific to {@link Ext.Panel}s. This class is primarily used internally + * for the Panel's drag drop implementation, and should never need to be created directly. + * @constructor + * @param panel The {@link Ext.Panel} to proxy for + * @param config Configuration options + */ +Ext.dd.PanelProxy = function(panel, config){ + this.panel = panel; + this.id = this.panel.id +'-ddproxy'; + Ext.apply(this, config); +}; + +Ext.dd.PanelProxy.prototype = { + /** + * @cfg {Boolean} insertProxy True to insert a placeholder proxy element while dragging the panel, + * false to drag with no proxy (defaults to true). + */ + insertProxy : true, + // private overrides + setStatus : Ext.emptyFn, + reset : Ext.emptyFn, + update : Ext.emptyFn, + stop : Ext.emptyFn, + sync: Ext.emptyFn, - 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); + /** + * Gets the proxy's element + * @return {Element} The proxy's element + */ + getEl : function(){ + return this.ghost; + }, - }, + /** + * Gets the proxy's ghost element + * @return {Element} The proxy's ghost element + */ + getGhost : function(){ + return this.ghost; + }, + + /** + * Gets the proxy's element + * @return {Element} The proxy's element + */ + getProxy : function(){ + return this.proxy; + }, + + /** + * Hides the proxy + */ + hide : function(){ + if(this.ghost){ + if(this.proxy){ + this.proxy.remove(); + delete this.proxy; + } + this.panel.el.dom.style.display = ''; + this.ghost.remove(); + delete this.ghost; + } + }, + + /** + * Shows the proxy + */ + show : function(){ + if(!this.ghost){ + this.ghost = this.panel.createGhost(undefined, undefined, Ext.getBody()); + this.ghost.setXY(this.panel.el.getXY()); + if(this.insertProxy){ + this.proxy = this.panel.el.insertSibling({cls:'x-panel-dd-spacer'}); + this.proxy.setSize(this.panel.getSize()); + } + this.panel.el.dom.style.display = 'none'; + } + }, + + // private + repair : function(xy, callback, scope){ + this.hide(); + if(typeof callback == "function"){ + callback.call(scope || this); + } + }, + + /** + * Moves the proxy to a different position in the DOM. This is typically called while dragging the Panel + * to keep the proxy sync'd to the Panel's location. + * @param {HTMLElement} parentNode The proxy's parent DOM node + * @param {HTMLElement} before (optional) The sibling node before which the proxy should be inserted (defaults + * to the parent's last child if not specified) + */ + moveProxy : function(parentNode, before){ + if(this.proxy){ + parentNode.insertBefore(this.proxy.dom, before); + } + } +}; + +// private - DD implementation for Panels +Ext.Panel.DD = function(panel, cfg){ + this.panel = panel; + this.dragData = {panel: panel}; + this.proxy = new Ext.dd.PanelProxy(panel, cfg); + Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg); + var h = panel.header; + if(h){ + this.setHandleElId(h.id); + } + (h ? h : this.panel.body).setStyle('cursor', 'move'); + this.scroll = false; +}; + +Ext.extend(Ext.Panel.DD, Ext.dd.DragSource, { + showFrame: Ext.emptyFn, + startDrag: Ext.emptyFn, + b4StartDrag: function(x, y) { + this.proxy.show(); + }, + b4MouseDown: function(e) { + var x = e.getPageX(); + var y = e.getPageY(); + this.autoOffset(x, y); + }, + onInitDrag : function(x, y){ + this.onStartDrag(x, y); + return true; + }, + createFrame : Ext.emptyFn, + getDragEl : function(e){ + return this.proxy.ghost.dom; + }, + endDrag : function(e){ + this.proxy.hide(); + this.panel.saveState(); + }, + + autoOffset : function(x, y) { + x -= this.startPageX; + y -= this.startPageY; + this.setDelta(x, y); + } +});/** + * @class Ext.state.Provider + * Abstract base class for state provider implementations. This class provides methods + * for encoding and decoding typed variables including dates and defines the + * Provider interface. + */ +Ext.state.Provider = function(){ + /** + * @event statechange + * Fires when a state change occurs. + * @param {Provider} this This state provider + * @param {String} key The state key which was changed + * @param {String} value The encoded value for the state + */ + this.addEvents("statechange"); + this.state = {}; + Ext.state.Provider.superclass.constructor.call(this); +}; +Ext.extend(Ext.state.Provider, Ext.util.Observable, { + /** + * Returns the current value for a key + * @param {String} name The key name + * @param {Mixed} defaultValue A default value to return if the key's value is not found + * @return {Mixed} The state data + */ + get : function(name, defaultValue){ + return typeof this.state[name] == "undefined" ? + defaultValue : this.state[name]; + }, + + /** + * Clears a value from the state + * @param {String} name The key name + */ + clear : function(name){ + delete this.state[name]; + this.fireEvent("statechange", this, name, null); + }, + + /** + * Sets the value for a key + * @param {String} name The key name + * @param {Mixed} value The value to set + */ + set : function(name, value){ + this.state[name] = value; + this.fireEvent("statechange", this, name, value); + }, + + /** + * Decodes a string previously encoded with {@link #encodeValue}. + * @param {String} value The value to decode + * @return {Mixed} The decoded value + */ + decodeValue : function(cookie){ + var re = /^(a|n|d|b|s|o)\:(.*)$/; + var matches = re.exec(unescape(cookie)); + if(!matches || !matches[1]) return; // non state cookie + var type = matches[1]; + var v = matches[2]; + switch(type){ + case "n": + return parseFloat(v); + case "d": + return new Date(Date.parse(v)); + case "b": + return (v == "1"); + case "a": + var all = []; + if(v != ''){ + Ext.each(v.split('^'), function(val){ + all.push(this.decodeValue(val)); + }, this); + } + return all; + case "o": + var all = {}; + if(v != ''){ + Ext.each(v.split('^'), function(val){ + var kv = val.split('='); + all[kv[0]] = this.decodeValue(kv[1]); + }, this); + } + return all; + default: + return v; + } + }, + + /** + * Encodes a value including type information. Decode with {@link #decodeValue}. + * @param {Mixed} value The value to encode + * @return {String} The encoded value + */ + encodeValue : function(v){ + var enc; + if(typeof v == "number"){ + enc = "n:" + v; + }else if(typeof v == "boolean"){ + enc = "b:" + (v ? "1" : "0"); + }else if(Ext.isDate(v)){ + enc = "d:" + v.toGMTString(); + }else if(Ext.isArray(v)){ + var flat = ""; + for(var i = 0, len = v.length; i < len; i++){ + flat += this.encodeValue(v[i]); + if(i != len-1) flat += "^"; + } + enc = "a:" + flat; + }else if(typeof v == "object"){ + var flat = ""; + for(var key in v){ + if(typeof v[key] != "function" && v[key] !== undefined){ + flat += key + "=" + this.encodeValue(v[key]) + "^"; + } + } + enc = "o:" + flat.substring(0, flat.length-1); + }else{ + enc = "s:" + v; + } + return escape(enc); + } +}); +/** + * @class Ext.state.Manager + * This is the global state manager. By default all components that are "state aware" check this class + * for state information if you don't pass them a custom state provider. In order for this class + * to be useful, it must be initialized with a provider when your application initializes. Example usage: +
+// in your initialization function +init : function(){ + Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); + var win = new Window(...); + win.restoreState(); +} +
+ * @singleton + */ +Ext.state.Manager = function(){ + var provider = new Ext.state.Provider(); + return { /** - * Reset constraints on all drag and drop objs - * @method _onResize - * @private - * @static + * Configures the default state provider for your application + * @param {Provider} stateProvider The state provider to set */ - _onResize: function(e) { - this._execOnAll("resetConstraints", []); + setProvider : function(stateProvider){ + provider = stateProvider; }, /** - * Lock all drag and drop functionality - * @method lock - * @static + * Returns the current value for a key + * @param {String} name The key name + * @param {Mixed} defaultValue The default value to return if the key lookup does not match + * @return {Mixed} The state data */ - lock: function() { this.locked = true; }, + get : function(key, defaultValue){ + return provider.get(key, defaultValue); + }, /** - * Unlock all drag and drop functionality - * @method unlock - * @static + * Sets the value for a key + * @param {String} name The key name + * @param {Mixed} value The state data */ - unlock: function() { this.locked = false; }, + set : function(key, value){ + provider.set(key, value); + }, /** - * Is drag and drop locked? - * @method isLocked - * @return {boolean} True if drag and drop is locked, false otherwise. - * @static + * Clears a value from the state + * @param {String} name The key name */ - isLocked: function() { return this.locked; }, + clear : function(key){ + provider.clear(key); + }, /** - * 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 + * Gets the currently configured state provider + * @return {Provider} The state provider */ - locationCache: {}, + getProvider : function(){ + return provider; + } + }; +}(); +/** + * @class Ext.state.CookieProvider + * @extends Ext.state.Provider + * The default Provider implementation which saves state via cookies. + *
Usage: +
+ var cp = new Ext.state.CookieProvider({ + path: "/cgi-bin/", + expires: new Date(new Date().getTime()+(1000*60*60*24*30)), //30 days + domain: "extjs.com" + }); + Ext.state.Manager.setProvider(cp); +
+ * @cfg {String} path The path for which the cookie is active (defaults to root '/' which makes it active for all pages in the site) + * @cfg {Date} expires The cookie expiration date (defaults to 7 days from now) + * @cfg {String} domain The domain to save the cookie for. Note that you cannot specify a different domain than + * your page is on, but you can specify a sub-domain, or simply the domain itself like 'extjs.com' to include + * all sub-domains if you need to access cookies across different sub-domains (defaults to null which uses the same + * domain the page is running on including the 'www' like 'www.extjs.com') + * @cfg {Boolean} secure True if the site is using SSL (defaults to false) + * @constructor + * Create a new CookieProvider + * @param {Object} config The configuration object + */ +Ext.state.CookieProvider = function(config){ + Ext.state.CookieProvider.superclass.constructor.call(this); + this.path = "/"; + this.expires = new Date(new Date().getTime()+(1000*60*60*24*7)); //7 days + this.domain = null; + this.secure = false; + Ext.apply(this, config); + this.state = this.readCookies(); +}; - /** - * 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, +Ext.extend(Ext.state.CookieProvider, Ext.state.Provider, { + // private + set : function(name, value){ + if(typeof value == "undefined" || value === null){ + this.clear(name); + return; + } + this.setCookie(name, value); + Ext.state.CookieProvider.superclass.set.call(this, name, value); + }, - /** - * 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, + // private + clear : function(name){ + this.clearCookie(name); + Ext.state.CookieProvider.superclass.clear.call(this, name); + }, - /** - * The number of milliseconds after the mousedown event to initiate the - * drag if we don't get a mouseup event. Default=350 - * @property clickTimeThresh - * @type int - * @static - */ - clickTimeThresh: 350, + // private + readCookies : function(){ + var cookies = {}; + var c = document.cookie + ";"; + var re = /\s?(.*?)=(.*?);/g; + var matches; + while((matches = re.exec(c)) != null){ + var name = matches[1]; + var value = matches[2]; + if(name && name.substring(0,3) == "ys-"){ + cookies[name.substr(3)] = this.decodeValue(value); + } + } + return cookies; + }, - /** - * 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, + // private + setCookie : function(name, value){ + document.cookie = "ys-"+ name + "=" + this.encodeValue(value) + + ((this.expires == null) ? "" : ("; expires=" + this.expires.toGMTString())) + + ((this.path == null) ? "" : ("; path=" + this.path)) + + ((this.domain == null) ? "" : ("; domain=" + this.domain)) + + ((this.secure == true) ? "; secure" : ""); + }, - /** - * Timeout used for the click time threshold - * @property clickTimeout - * @type Object - * @private - * @static - */ - clickTimeout: null, + // private + clearCookie : function(name){ + document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" + + ((this.path == null) ? "" : ("; path=" + this.path)) + + ((this.domain == null) ? "" : ("; domain=" + this.domain)) + + ((this.secure == true) ? "; secure" : ""); + } +});/** + * @class Ext.DataView + * @extends Ext.BoxComponent + * A mechanism for displaying data using custom layout templates and formatting. DataView uses an {@link Ext.XTemplate} + * as its internal templating mechanism, and is bound to an {@link Ext.data.Store} + * so that as the data in the store changes the view is automatically updated to reflect the changes. The view also + * provides built-in behavior for many common events that can occur for its contained items including click, doubleclick, + * mouseover, mouseout, etc. as well as a built-in selection model. In order to use these features, an {@link #itemSelector} + * config must be provided for the DataView to determine what nodes it will be working with. + * + *
The example below binds a DataView to a {@link Ext.data.Store} and renders it into an {@link Ext.Panel}.
+ *
+var store = new Ext.data.JsonStore({ + url: 'get-images.php', + root: 'images', + fields: [ + 'name', 'url', + {name:'size', type: 'float'}, + {name:'lastmod', type:'date', dateFormat:'timestamp'} + ] +}); +store.load(); - /** - * 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, +var tpl = new Ext.XTemplate( + '<tpl for=".">', + '<div class="thumb-wrap" id="{name}">', + '<div class="thumb"><img src="{url}" title="{name}"></div>', + '<span class="x-editable">{shortName}</span></div>', + '</tpl>', + '<div class="x-clear"></div>' +); - /** - * 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, +var panel = new Ext.Panel({ + id:'images-view', + frame:true, + width:535, + autoHeight:true, + collapsible:true, + layout:'fit', + title:'Simple DataView', - /** - * 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(); } + items: new Ext.DataView({ + store: store, + tpl: tpl, + autoHeight:true, + multiSelect: true, + overClass:'x-view-over', + itemSelector:'div.thumb-wrap', + emptyText: 'No images to display' + }) +}); +panel.render(document.body); +
+ * @constructor + * Create a new DataView + * @param {Object} config The config object + * @xtype dataview + */ +Ext.DataView = Ext.extend(Ext.BoxComponent, { + /** + * @cfg {String/Array} tpl + * The HTML fragment or an array of fragments that will make up the template used by this DataView. This should + * be specified in the same format expected by the constructor of {@link Ext.XTemplate}. + */ + /** + * @cfg {Ext.data.Store} store + * The {@link Ext.data.Store} to bind this DataView to. + */ + /** + * @cfg {String} itemSelector + * This is a required setting. A simple CSS selector (e.g. div.some-class or + * span:first-child) that will be used to determine what nodes this DataView will be + * working with. + */ + /** + * @cfg {Boolean} multiSelect + * True to allow selection of more than one item at a time, false to allow selection of only a single item + * at a time or no selection at all, depending on the value of {@link #singleSelect} (defaults to false). + */ + /** + * @cfg {Boolean} singleSelect + * True to allow selection of exactly one item at a time, false to allow no selection at all (defaults to false). + * Note that if {@link #multiSelect} = true, this value will be ignored. + */ + /** + * @cfg {Boolean} simpleSelect + * True to enable multiselection by clicking on multiple items without requiring the user to hold Shift or Ctrl, + * false to force the user to hold Ctrl or Shift to select more than on item (defaults to false). + */ + /** + * @cfg {String} overClass + * A CSS class to apply to each item in the view on mouseover (defaults to undefined). + */ + /** + * @cfg {String} loadingText + * A string to display during data load operations (defaults to undefined). If specified, this text will be + * displayed in a loading div and the view's contents will be cleared while loading, otherwise the view's + * contents will continue to display normally until the new data is loaded and the contents are replaced. + */ + /** + * @cfg {String} selectedClass + * A CSS class to apply to each selected item in the view (defaults to 'x-view-selected'). + */ + selectedClass : "x-view-selected", + /** + * @cfg {String} emptyText + * The text to display in the view when there is no data to display (defaults to ''). + */ + emptyText : "", - if (!this.ids[sGroup]) { - this.ids[sGroup] = {}; - } - this.ids[sGroup][oDD.id] = oDD; - }, + /** + * @cfg {Boolean} deferEmptyText True to defer emptyText being applied until the store's first load + */ + deferEmptyText: true, + /** + * @cfg {Boolean} trackOver True to enable mouseenter and mouseleave events + */ + trackOver: false, + + /** + * @cfg {Boolean} blockRefresh Set this to true to ignore datachanged events on the bound store. This is useful if + * you wish to provide custom transition animations via a plugin (defaults to false) + */ + blockRefresh: false, - /** - * 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] = {}; - } + //private + last: false, - var obj = this.ids[sGroup]; - if (obj && obj[oDD.id]) { - delete obj[oDD.id]; - } - }, + // private + initComponent : function(){ + Ext.DataView.superclass.initComponent.call(this); + if(Ext.isString(this.tpl) || Ext.isArray(this.tpl)){ + this.tpl = new Ext.XTemplate(this.tpl); + } - /** - * 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] && this.ids[g][oDD.id]) { - delete this.ids[g][oDD.id]; - } - } - delete this.handleIds[oDD.id]; - }, + this.addEvents( + /** + * @event beforeclick + * Fires before a click is processed. Returns false to cancel the default action. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "beforeclick", + /** + * @event click + * Fires when a template node is clicked. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "click", + /** + * @event mouseenter + * Fires when the mouse enters a template node. trackOver:true or an overClass must be set to enable this event. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "mouseenter", + /** + * @event mouseleave + * Fires when the mouse leaves a template node. trackOver:true or an overClass must be set to enable this event. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "mouseleave", + /** + * @event containerclick + * Fires when a click occurs and it is not on a template node. + * @param {Ext.DataView} this + * @param {Ext.EventObject} e The raw event object + */ + "containerclick", + /** + * @event dblclick + * Fires when a template node is double clicked. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "dblclick", + /** + * @event contextmenu + * Fires when a template node is right clicked. + * @param {Ext.DataView} this + * @param {Number} index The index of the target node + * @param {HTMLElement} node The target node + * @param {Ext.EventObject} e The raw event object + */ + "contextmenu", + /** + * @event containercontextmenu + * Fires when a right click occurs that is not on a template node. + * @param {Ext.DataView} this + * @param {Ext.EventObject} e The raw event object + */ + "containercontextmenu", + /** + * @event selectionchange + * Fires when the selected nodes change. + * @param {Ext.DataView} this + * @param {Array} selections Array of the selected nodes + */ + "selectionchange", - /** - * 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; - }, + /** + * @event beforeselect + * Fires before a selection is made. If any handlers return false, the selection is cancelled. + * @param {Ext.DataView} this + * @param {HTMLElement} node The node to be selected + * @param {Array} selections Array of currently selected nodes + */ + "beforeselect" + ); - /** - * 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; - }, + this.store = Ext.StoreMgr.lookup(this.store); + this.all = new Ext.CompositeElementLite(); + this.selected = new Ext.CompositeElementLite(); + }, - /** - * 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 (var j in this.ids[i]) { - var dd = this.ids[i][j]; - if (! this.isTypeOfDD(dd)) { - continue; - } - if (!bTargetsOnly || dd.isTarget) { - oDDs[oDDs.length] = dd; - } - } + // private + afterRender : function(){ + Ext.DataView.superclass.afterRender.call(this); + + this.mon(this.getTemplateTarget(), { + "click": this.onClick, + "dblclick": this.onDblClick, + "contextmenu": this.onContextMenu, + scope:this + }); + + if(this.overClass || this.trackOver){ + this.mon(this.getTemplateTarget(), { + "mouseover": this.onMouseOver, + "mouseout": this.onMouseOut, + scope:this + }); + } + + if(this.store){ + this.bindStore(this.store, true); + } + }, + + /** + * Refreshes the view by reloading the data from the store and re-rendering the template. + */ + refresh : function() { + this.clearSelections(false, true); + var el = this.getTemplateTarget(); + el.update(""); + var records = this.store.getRange(); + if(records.length < 1){ + if(!this.deferEmptyText || this.hasSkippedEmptyText){ + el.update(this.emptyText); } + this.all.clear(); + }else{ + this.tpl.overwrite(el, this.collectData(records, 0)); + this.all.fill(Ext.query(this.itemSelector, el.dom)); + this.updateIndexes(0); + } + this.hasSkippedEmptyText = true; + }, + + getTemplateTarget: function(){ + return this.el; + }, + + /** + * Function which can be overridden to provide custom formatting for each Record that is used by this + * DataView's {@link #tpl template} to render each node. + * @param {Array/Object} data The raw data object that was used to create the Record. + * @param {Number} recordIndex the index number of the Record being prepared for rendering. + * @param {Record} record The Record being prepared for rendering. + * @return {Array/Object} The formatted data in a format expected by the internal {@link #tpl template}'s overwrite() method. + * (either an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})) + */ + prepareData : function(data){ + return data; + }, + + /** + *
Function which can be overridden which returns the data object passed to this + * DataView's {@link #tpl template} to render the whole DataView.
+ *
This is usually an Array of data objects, each element of which is processed by an + * {@link Ext.XTemplate XTemplate} which uses '<tpl for=".">' to iterate over its supplied + * data object as an Array. However, named properties may be placed into the data object to + * provide non-repeating data such as headings, totals etc.
+ * @param {Array} records An Array of {@link Ext.data.Record}s to be rendered into the DataView. + * @param {Number} startIndex the index number of the Record being prepared for rendering. + * @return {Array} An Array of data objects to be processed by a repeating XTemplate. May also + * contain named properties. + */ + collectData : function(records, startIndex){ + var r = []; + for(var i = 0, len = records.length; i < len; i++){ + r[r.length] = this.prepareData(records[i].data, startIndex+i, records[i]); + } + return r; + }, + + // private + bufferRender : function(records){ + var div = document.createElement('div'); + this.tpl.overwrite(div, this.collectData(records)); + return Ext.query(this.itemSelector, div); + }, - return oDDs; - }, + // private + onUpdate : function(ds, record){ + var index = this.store.indexOf(record); + if(index > -1){ + var sel = this.isSelected(index); + var original = this.all.elements[index]; + var node = this.bufferRender([record], index)[0]; - /** - * 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 0){ + if(!skipUpdate){ + this.selected.removeClass(this.selectedClass); + } + this.selected.clear(); + this.last = false; + if(!suppressEvent){ + this.fireEvent("selectionchange", this, this.selected.elements); } + } + }, - this.dragCurrent = null; - this.dragOvers = {}; - }, + /** + * Returns true if the passed node is selected, else false. + * @param {HTMLElement/Number/Ext.data.Record} node The node, node index or record to check + * @return {Boolean} True if selected, else false + */ + isSelected : function(node){ + return this.selected.contains(this.getNode(node)); + }, - /** - * Internal function to handle the mousemove event. Will be invoked - * from the context of the html element. - * - * @TODO figure out what we can do about mouse events lost when the - * user drags objects beyond the window boundary. Currently we can - * detect this in internet explorer by verifying that the mouse is - * down during the mousemove event. Firefox doesn't give us the - * button state on the mousemove event. - * @method handleMouseMove - * @param {Event} e the event - * @private - * @static - */ - handleMouseMove: function(e) { - if (! this.dragCurrent) { - return true; + /** + * Deselects a node. + * @param {HTMLElement/Number/Record} node The node, node index or record to deselect + */ + deselect : function(node){ + if(this.isSelected(node)){ + node = this.getNode(node); + this.selected.removeElement(node); + if(this.last == node.viewIndex){ + this.last = false; } - // var button = e.which || e.button; + Ext.fly(node).removeClass(this.selectedClass); + this.fireEvent("selectionchange", this, this.selected.elements); + } + }, - // check for IE mouseup outside of page boundary - if (Ext.isIE && (e.button !== 0 && e.button !== 1 && e.button !== 2)) { - this.stopEvent(e); - return this.handleMouseUp(e); + /** + * Selects a set of nodes. + * @param {Array/HTMLElement/String/Number/Ext.data.Record} nodeInfo An HTMLElement template node, index of a template node, + * id of a template node, record associated with a node or an array of any of those to select + * @param {Boolean} keepExisting (optional) true to keep existing selections + * @param {Boolean} suppressEvent (optional) true to skip firing of the selectionchange vent + */ + select : function(nodeInfo, keepExisting, suppressEvent){ + if(Ext.isArray(nodeInfo)){ + if(!keepExisting){ + this.clearSelections(true); } - - if (!this.dragThreshMet) { - var diffX = Math.abs(this.startX - e.getPageX()); - var diffY = Math.abs(this.startY - e.getPageY()); - if (diffX > this.clickPixelThresh || - diffY > this.clickPixelThresh) { - this.startDrag(this.startX, this.startY); - } + for(var i = 0, len = nodeInfo.length; i < len; i++){ + this.select(nodeInfo[i], true, true); } - - if (this.dragThreshMet) { - this.dragCurrent.b4Drag(e); - this.dragCurrent.onDrag(e); - if(!this.dragCurrent.moveOnly){ - this.fireEvents(e, false); + if(!suppressEvent){ + this.fireEvent("selectionchange", this, this.selected.elements); + } + } else{ + var node = this.getNode(nodeInfo); + if(!keepExisting){ + this.clearSelections(true); + } + if(node && !this.isSelected(node)){ + if(this.fireEvent("beforeselect", this, node, this.selected.elements) !== false){ + Ext.fly(node).addClass(this.selectedClass); + this.selected.add(node); + this.last = node.viewIndex; + if(!suppressEvent){ + this.fireEvent("selectionchange", this, this.selected.elements); + } } } + } + }, - this.stopEvent(e); - - return true; - }, + /** + * Selects a range of nodes. All nodes between start and end are selected. + * @param {Number} start The index of the first node in the range + * @param {Number} end The index of the last node in the range + * @param {Boolean} keepExisting (optional) True to retain existing selections + */ + selectRange : function(start, end, keepExisting){ + if(!keepExisting){ + this.clearSelections(true); + } + this.select(this.getNodes(start, end), true); + }, - /** - * Iterates over all of the DragDrop elements to find ones we are - * hovering over or dropping on - * @method fireEvents - * @param {Event} e the event - * @param {boolean} isDrop is this a drop op or a mouseover op? - * @private - * @static - */ - fireEvents: function(e, isDrop) { - var dc = this.dragCurrent; + /** + * Gets a template node. + * @param {HTMLElement/String/Number/Ext.data.Record} nodeInfo An HTMLElement template node, index of a template node, + * the id of a template node or the record associated with the node. + * @return {HTMLElement} The node or null if it wasn't found + */ + getNode : function(nodeInfo){ + if(Ext.isString(nodeInfo)){ + return document.getElementById(nodeInfo); + }else if(Ext.isNumber(nodeInfo)){ + return this.all.elements[nodeInfo]; + }else if(nodeInfo instanceof Ext.data.Record){ + var idx = this.store.indexOf(nodeInfo); + return this.all.elements[idx]; + } + return nodeInfo; + }, - // If the user did the mouse up outside of the window, we could - // get here even though we have ended the drag. - if (!dc || dc.isLocked()) { - return; + /** + * Gets a range nodes. + * @param {Number} start (optional) The index of the first node in the range + * @param {Number} end (optional) The index of the last node in the range + * @return {Array} An array of nodes + */ + getNodes : function(start, end){ + var ns = this.all.elements; + start = start || 0; + end = !Ext.isDefined(end) ? Math.max(ns.length - 1, 0) : end; + var nodes = [], i; + if(start <= end){ + for(i = start; i <= end && ns[i]; i++){ + nodes.push(ns[i]); + } + } else{ + for(i = start; i >= end && ns[i]; i--){ + nodes.push(ns[i]); } + } + return nodes; + }, - var pt = e.getPoint(); + /** + * Finds the index of the passed node. + * @param {HTMLElement/String/Number/Record} nodeInfo An HTMLElement template node, index of a template node, the id of a template node + * or a record associated with a node. + * @return {Number} The index of the node or -1 + */ + indexOf : function(node){ + node = this.getNode(node); + if(Ext.isNumber(node.viewIndex)){ + return node.viewIndex; + } + return this.all.indexOf(node); + }, - // cache the previous dragOver array - var oldOvers = []; + // private + onBeforeLoad : function(){ + if(this.loadingText){ + this.clearSelections(false, true); + this.getTemplateTarget().update('
'+this.loadingText+'
'); + this.all.clear(); + } + }, - var outEvts = []; - var overEvts = []; - var dropEvts = []; - var enterEvts = []; + onDestroy : function(){ + this.all.clear(); + this.selected.clear(); + Ext.DataView.superclass.onDestroy.call(this); + this.bindStore(null); + } +}); - // Check to see if the object(s) we were hovering over is no longer - // being hovered over so we can fire the onDragOut event - for (var i in this.dragOvers) { +/** + * Changes the data store bound to this view and refreshes it. (deprecated in favor of bindStore) + * @param {Store} store The store to bind to this view + */ +Ext.DataView.prototype.setStore = Ext.DataView.prototype.bindStore; - var ddo = this.dragOvers[i]; +Ext.reg('dataview', Ext.DataView); +/** + * @class Ext.list.ListView + * @extends Ext.DataView + *
Ext.list.ListView is a fast and light-weight implentation of a + * {@link Ext.grid.GridPanel Grid} like view with the following characteristics:
+ *
+ *
resizable columns
+ *
selectable
+ *
column widths are initially proportioned by percentage based on the container + * width and number of columns
+ *
uses templates to render the data in any required format
+ *
no horizontal scrolling
+ *
no editing
+ *
+ *
Example usage:
+ *
+// consume JSON of this form: +{ + "images":[ + { + "name":"dance_fever.jpg", + "size":2067, + "lastmod":1236974993000, + "url":"images\/thumbs\/dance_fever.jpg" + }, + { + "name":"zack_sink.jpg", + "size":2303, + "lastmod":1236974993000, + "url":"images\/thumbs\/zack_sink.jpg" + } + ] +} +var store = new Ext.data.JsonStore({ + url: 'get-images.php', + root: 'images', + fields: [ + 'name', 'url', + {name:'size', type: 'float'}, + {name:'lastmod', type:'date', dateFormat:'timestamp'} + ] +}); +store.load(); - if (! this.isTypeOfDD(ddo)) { - continue; - } +var listView = new Ext.list.ListView({ + store: store, + multiSelect: true, + emptyText: 'No images to display', + reserveScrollOffset: true, + columns: [{ + header: 'File', + width: .5, + dataIndex: 'name' + },{ + header: 'Last Modified', + width: .35, + dataIndex: 'lastmod', + tpl: '{lastmod:date("m-d h:i a")}' + },{ + header: 'Size', + dataIndex: 'size', + tpl: '{size:fileSize}', // format using Ext.util.Format.fileSize() + align: 'right' + }] +}); - if (! this.isOverTarget(pt, ddo, this.mode)) { - outEvts.push( ddo ); - } +// put it in a Panel so it looks pretty +var panel = new Ext.Panel({ + id:'images-view', + width:425, + height:250, + collapsible:true, + layout:'fit', + title:'Simple ListView (0 items selected)', + items: listView +}); +panel.render(document.body); - oldOvers[i] = true; - delete this.dragOvers[i]; - } +// little bit of feedback +listView.on('selectionchange', function(view, nodes){ + var l = nodes.length; + var s = l != 1 ? 's' : ''; + panel.setTitle('Simple ListView ('+l+' item'+s+' selected)'); +}); + *
+ * @constructor + * @param {Object} config + * @xtype listview + */ +Ext.list.ListView = Ext.extend(Ext.DataView, { + /** + * Set this property to true to disable the header click handler disabling sort + * (defaults to false). + * @type Boolean + * @property disableHeaders + */ + /** + * @cfg {Boolean} hideHeaders + * true to hide the {@link #internalTpl header row} (defaults to false so + * the {@link #internalTpl header row} will be shown). + */ + /** + * @cfg {String} itemSelector + * Defaults to 'dl' to work with the preconfigured {@link Ext.DataView#tpl tpl}. + * This setting specifies the CSS selector (e.g. div.some-class or span:first-child) + * that will be used to determine what nodes the ListView will be working with. + */ + itemSelector: 'dl', + /** + * @cfg {String} selectedClass The CSS class applied to a selected row (defaults to + * 'x-list-selected'). An example overriding the default styling: +
+ .x-list-selected {background-color: yellow;} +
+ * @type String + */ + selectedClass:'x-list-selected', + /** + * @cfg {String} overClass The CSS class applied when over a row (defaults to + * 'x-list-over'). An example overriding the default styling: +
+ .x-list-over {background-color: orange;} +
+ * @type String + */ + overClass:'x-list-over', + /** + * @cfg {Boolean} reserveScrollOffset + * By default will defer accounting for the configured {@link #scrollOffset} + * for 10 milliseconds. Specify true to account for the configured + * {@link #scrollOffset} immediately. + */ + /** + * @cfg {Number} scrollOffset The amount of space to reserve for the scrollbar (defaults to + * undefined). If an explicit value isn't specified, this will be automatically + * calculated. + */ + scrollOffset : undefined, + /** + * @cfg {Boolean/Object} columnResize + * Specify true or specify a configuration object for {@link Ext.list.ListView.ColumnResizer} + * to enable the columns to be resizable (defaults to true). + */ + columnResize: true, + /** + * @cfg {Array} columns An array of column configuration objects, for example: + *
+{ + align: 'right', + dataIndex: 'size', + header: 'Size', + tpl: '{size:fileSize}', + width: .35 +} + *
+ * Acceptable properties for each column configuration object are: + *
+ *
align : String
Set the CSS text-align property + * of the column. Defaults to 'left'.
+ *
dataIndex : String
See {@link Ext.grid.Column}. + * {@link Ext.grid.Column#dataIndex dataIndex} for details.
+ *
header : String
See {@link Ext.grid.Column}. + * {@link Ext.grid.Column#header header} for details.
+ *
tpl : String
Specify a string to pass as the + * configuration string for {@link Ext.XTemplate}. By default an {@link Ext.XTemplate} + * will be implicitly created using the dataIndex.
+ *
width : Number
Percentage of the container width + * this column should be allocated. Columns that have no width specified will be + * allocated with an equal percentage to fill 100% of the container width. To easily take + * advantage of the full container width, leave the width of at least one column undefined. + * Note that if you do not want to take up the full width of the container, the width of + * every column needs to be explicitly defined.
+ *
+ */ + /** + * @cfg {Boolean/Object} columnSort + * Specify true or specify a configuration object for {@link Ext.list.ListView.Sorter} + * to enable the columns to be sortable (defaults to true). + */ + columnSort: true, + /** + * @cfg {String/Array} internalTpl + * The template to be used for the header row. See {@link #tpl} for more details. + */ - for (var sGroup in dc.groups) { + /* + * IE has issues when setting percentage based widths to 100%. Default to 99. + */ + maxWidth: Ext.isIE ? 99 : 100, - if ("string" != typeof sGroup) { - continue; - } + initComponent : function(){ + if(this.columnResize){ + this.colResizer = new Ext.list.ColumnResizer(this.colResizer); + this.colResizer.init(this); + } + if(this.columnSort){ + this.colSorter = new Ext.list.Sorter(this.columnSort); + this.colSorter.init(this); + } + if(!this.internalTpl){ + this.internalTpl = new Ext.XTemplate( + '
', + '', + '
', + '{header}', + '
', + '', + '
', + '
', + '
', + '
' + ); + } + if(!this.tpl){ + this.tpl = new Ext.XTemplate( + '', + '
', + '', + '
', + ' class="{cls}">', + '{[values.tpl.apply(parent)]}', + '
', + '', + '
', + '
', + '' + ); + }; - for (i in this.ids[sGroup]) { - var oDD = this.ids[sGroup][i]; - if (! this.isTypeOfDD(oDD)) { - continue; - } + var cs = this.columns, + allocatedWidth = 0, + colsWithWidth = 0, + len = cs.length, + columns = []; - if (oDD.isTarget && !oDD.isLocked() && ((oDD != dc) || (dc.ignoreSelf === false))) { - if (this.isOverTarget(pt, oDD, this.mode)) { - // look for drop interactions - if (isDrop) { - dropEvts.push( oDD ); - // look for drag enter and drag over interactions - } else { + for(var i = 0; i < len; i++){ + var c = cs[i]; + if(!c.isColumn) { + c.xtype = c.xtype ? (/^lv/.test(c.xtype) ? c.xtype : 'lv' + c.xtype) : 'lvcolumn'; + c = Ext.create(c); + } + if(c.width) { + allocatedWidth += c.width*100; + colsWithWidth++; + } + columns.push(c); + } - // initial drag over: dragEnter fires - if (!oldOvers[oDD.id]) { - enterEvts.push( oDD ); - // subsequent drag overs: dragOver fires - } else { - overEvts.push( oDD ); - } + cs = this.columns = columns; - this.dragOvers[oDD.id] = oDD; - } - } + // auto calculate missing column widths + if(colsWithWidth < len){ + var remaining = len - colsWithWidth; + if(allocatedWidth < this.maxWidth){ + var perCol = ((this.maxWidth-allocatedWidth) / remaining)/100; + for(var j = 0; j < len; j++){ + var c = cs[j]; + if(!c.width){ + c.width = perCol; } } } + } + Ext.list.ListView.superclass.initComponent.call(this); + }, - if (this.mode) { - if (outEvts.length) { - dc.b4DragOut(e, outEvts); - dc.onDragOut(e, outEvts); - } - - if (enterEvts.length) { - dc.onDragEnter(e, enterEvts); - } - - if (overEvts.length) { - dc.b4DragOver(e, overEvts); - dc.onDragOver(e, overEvts); - } + onRender : function(){ + this.autoEl = { + cls: 'x-list-wrap' + }; + Ext.list.ListView.superclass.onRender.apply(this, arguments); - if (dropEvts.length) { - dc.b4DragDrop(e, dropEvts); - dc.onDragDrop(e, dropEvts); - } + this.internalTpl.overwrite(this.el, {columns: this.columns}); - } else { - // fire dragout events - var len = 0; - for (i=0, len=outEvts.length; iFunction which can be overridden which returns the data object passed to this + * view's {@link #tpl template} to render the whole ListView. The returned object + * shall contain the following properties:
+ *
+ *
columns : String
See {@link #columns}
+ *
rows : String
See + * {@link Ext.DataView}.{@link Ext.DataView#collectData collectData}
+ *
+ * @param {Array} records An Array of {@link Ext.data.Record}s to be rendered into the DataView. + * @param {Number} startIndex the index number of the Record being prepared for rendering. + * @return {Object} A data object containing properties to be processed by a repeating + * XTemplate as described above. + */ + collectData : function(){ + var rs = Ext.list.ListView.superclass.collectData.apply(this, arguments); + return { + columns: this.columns, + rows: rs + } + }, - } + verifyInternalSize : function(){ + if(this.lastSize){ + this.onResize(this.lastSize.width, this.lastSize.height); + } + }, - // notify about a drop that did not find a target - if (isDrop && !dropEvts.length) { - dc.onInvalidDrop(e); + // private + onResize : function(w, h){ + var bd = this.innerBody.dom; + var hd = this.innerHd.dom; + if(!bd){ + return; + } + var bdp = bd.parentNode; + if(Ext.isNumber(w)){ + var sw = w - Ext.num(this.scrollOffset, Ext.getScrollBarWidth()); + if(this.reserveScrollOffset || ((bdp.offsetWidth - bdp.clientWidth) > 10)){ + bd.style.width = sw + 'px'; + hd.style.width = sw + 'px'; + }else{ + bd.style.width = w + 'px'; + hd.style.width = w + 'px'; + setTimeout(function(){ + if((bdp.offsetWidth - bdp.clientWidth) > 10){ + bd.style.width = sw + 'px'; + hd.style.width = sw + 'px'; + } + }, 10); } + } + if(Ext.isNumber(h)){ + bdp.style.height = (h - hd.parentNode.offsetHeight) + 'px'; + } + }, - }, - - /** - * Helper function for getting the best match from the list of drag - * and drop objects returned by the drag and drop events when we are - * in INTERSECT mode. It returns either the first object that the - * cursor is over, or the object that has the greatest overlap with - * the dragged element. - * @method getBestMatch - * @param {DragDrop[]} dds The array of drag and drop objects - * targeted - * @return {DragDrop} The best single match - * @static - */ - getBestMatch: function(dds) { - var winner = null; - // Return null if the input is not what we expect - //if (!dds || !dds.length || dds.length == 0) { - // winner = null; - // If there is only one item, it wins - //} else if (dds.length == 1) { - - var len = dds.length; + updateIndexes : function(){ + Ext.list.ListView.superclass.updateIndexes.apply(this, arguments); + this.verifyInternalSize(); + }, - if (len == 1) { - winner = dds[0]; - } else { - // Loop through the targeted items - for (var i=0; i - * Ext.dd.DragDropMgr.refreshCache(ddinstance.groups); - * - * Alternatively: - * - * Ext.dd.DragDropMgr.refreshCache({group1:true, group2:true}); - * - * @TODO this really should be an indexed array. Alternatively this - * method could accept both. - * @method refreshCache - * @param {Object} groups an associative array of groups to refresh - * @static - */ - refreshCache: function(groups) { - for (var sGroup in groups) { - if ("string" != typeof sGroup) { - continue; - } - for (var i in this.ids[sGroup]) { - var oDD = this.ids[sGroup][i]; + setHdWidths : function(){ + var els = this.innerHd.dom.getElementsByTagName('div'); + for(var i = 0, cs = this.columns, len = cs.length; i < len; i++){ + els[i].style.width = (cs[i].width*100) + '%'; + } + } +}); - if (this.isTypeOfDD(oDD)) { - // if (this.isTypeOfDD(oDD) && oDD.isTarget) { - var loc = this.getLocation(oDD); - if (loc) { - this.locationCache[oDD.id] = loc; - } else { - delete this.locationCache[oDD.id]; - // this will unregister the drag and drop object if - // the element is not in a usable state - // oDD.unreg(); - } - } - } - } - }, +Ext.reg('listview', Ext.list.ListView); - /** - * This checks to make sure an element exists and is in the DOM. The - * main purpose is to handle cases where innerHTML is used to remove - * drag and drop objects from the DOM. IE provides an 'unspecified - * error' when trying to access the offsetParent of such an element - * @method verifyEl - * @param {HTMLElement} el the element to check - * @return {boolean} true if the element looks usable - * @static - */ - verifyEl: function(el) { - if (el) { - var parent; - if(Ext.isIE){ - try{ - parent = el.offsetParent; - }catch(e){} - }else{ - parent = el.offsetParent; - } - if (parent) { - return true; - } - } +// Backwards compatibility alias +Ext.ListView = Ext.list.ListView;/** + * @class Ext.list.Column + * This class encapsulates column configuration data to be used in the initialization of a + * {@link Ext.list.ListView ListView}. + * While subclasses are provided to render data in different ways, this class renders a passed + * data field unchanged and is usually used for textual columns. + */ +Ext.list.Column = Ext.extend(Object, { + /** + * @private + * @cfg {Boolean} isColumn + * Used by ListView constructor method to avoid reprocessing a Column + * if isColumn is not set ListView will recreate a new Ext.list.Column + * Defaults to true. + */ + isColumn: true, + + /** + * @cfg {String} align + * Set the CSS text-align property of the column. Defaults to 'left'. + */ + align: 'left', + /** + * @cfg {String} header Optional. The header text to be used as innerHTML + * (html tags are accepted) to display in the ListView. Note: to + * have a clickable header with no text displayed use ' '. + */ + header: '', + + /** + * @cfg {Number} width Optional. Percentage of the container width + * this column should be allocated. Columns that have no width specified will be + * allocated with an equal percentage to fill 100% of the container width. To easily take + * advantage of the full container width, leave the width of at least one column undefined. + * Note that if you do not want to take up the full width of the container, the width of + * every column needs to be explicitly defined. + */ + width: null, - return false; - }, + /** + * @cfg {String} cls Optional. This option can be used to add a CSS class to the cell of each + * row for this column. + */ + cls: '', + + /** + * @cfg {String} tpl Optional. Specify a string to pass as the + * configuration string for {@link Ext.XTemplate}. By default an {@link Ext.XTemplate} + * will be implicitly created using the dataIndex. + */ - /** - * Returns a Region object containing the drag and drop element's position - * and size, including the padding configured for it - * @method getLocation - * @param {DragDrop} oDD the drag and drop object to get the - * location for - * @return {Ext.lib.Region} a Region object representing the total area - * the element occupies, including any padding - * the instance is configured for. - * @static - */ - getLocation: function(oDD) { - if (! this.isTypeOfDD(oDD)) { - return null; - } + /** + * @cfg {String} dataIndex Required. The name of the field in the + * ListViews's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from + * which to draw the column's value. + */ + + constructor : function(c){ + if(!c.tpl){ + c.tpl = new Ext.XTemplate('{' + c.dataIndex + '}'); + } + else if(Ext.isString(c.tpl)){ + c.tpl = new Ext.XTemplate(c.tpl); + } + + Ext.apply(this, c); + } +}); - var el = oDD.getEl(), pos, x1, x2, y1, y2, t, r, b, l; +Ext.reg('lvcolumn', Ext.list.Column); - try { - pos= Ext.lib.Dom.getXY(el); - } catch (e) { } +/** + * @class Ext.list.NumberColumn + * @extends Ext.list.Column + * A Column definition class which renders a numeric data field according to a {@link #format} string. See the + * {@link Ext.list.Column#xtype xtype} config option of {@link Ext.list.Column} for more details. + */ +Ext.list.NumberColumn = Ext.extend(Ext.list.Column, { + /** + * @cfg {String} format + * A formatting string as used by {@link Ext.util.Format#number} to format a numeric value for this Column + * (defaults to '0,000.00'). + */ + format: '0,000.00', + + constructor : function(c) { + c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':number("' + (c.format || this.format) + '")}'); + Ext.list.NumberColumn.superclass.constructor.call(this, c); + } +}); - if (!pos) { - return null; - } +Ext.reg('lvnumbercolumn', Ext.list.NumberColumn); - x1 = pos[0]; - x2 = x1 + el.offsetWidth; - y1 = pos[1]; - y2 = y1 + el.offsetHeight; +/** + * @class Ext.list.DateColumn + * @extends Ext.list.Column + * A Column definition class which renders a passed date according to the default locale, or a configured + * {@link #format}. See the {@link Ext.list.Column#xtype xtype} config option of {@link Ext.list.Column} + * for more details. + */ +Ext.list.DateColumn = Ext.extend(Ext.list.Column, { + format: 'm/d/Y', + constructor : function(c) { + c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':date("' + (c.format || this.format) + '")}'); + Ext.list.DateColumn.superclass.constructor.call(this, c); + } +}); +Ext.reg('lvdatecolumn', Ext.list.DateColumn); - t = y1 - oDD.padding[0]; - r = x2 + oDD.padding[1]; - b = y2 + oDD.padding[2]; - l = x1 - oDD.padding[3]; +/** + * @class Ext.list.BooleanColumn + * @extends Ext.list.Column + * A Column definition class which renders boolean data fields. See the {@link Ext.list.Column#xtype xtype} + * config option of {@link Ext.list.Column} for more details. + */ +Ext.list.BooleanColumn = Ext.extend(Ext.list.Column, { + /** + * @cfg {String} trueText + * The string returned by the renderer when the column value is not falsey (defaults to 'true'). + */ + trueText: 'true', + /** + * @cfg {String} falseText + * The string returned by the renderer when the column value is falsey (but not undefined) (defaults to + * 'false'). + */ + falseText: 'false', + /** + * @cfg {String} undefinedText + * The string returned by the renderer when the column value is undefined (defaults to ' '). + */ + undefinedText: ' ', + + constructor : function(c) { + c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':this.format}'); + + var t = this.trueText, f = this.falseText, u = this.undefinedText; + c.tpl.format = function(v){ + if(v === undefined){ + return u; + } + if(!v || v === 'false'){ + return f; + } + return t; + }; + + Ext.list.DateColumn.superclass.constructor.call(this, c); + } +}); - return new Ext.lib.Region( t, r, b, l ); - }, +Ext.reg('lvbooleancolumn', Ext.list.BooleanColumn);/** + * @class Ext.list.ColumnResizer + * @extends Ext.util.Observable + * Supporting Class for Ext.list.ListView + * @constructor + * @param {Object} config + */ +Ext.list.ColumnResizer = Ext.extend(Ext.util.Observable, { + /** + * @cfg {Number} minPct The minimum percentage to allot for any column (defaults to .05) + */ + minPct: .05, - /** - * Checks the cursor location to see if it over the target - * @method isOverTarget - * @param {Ext.lib.Point} pt The point to evaluate - * @param {DragDrop} oTarget the DragDrop object we are inspecting - * @return {boolean} true if the mouse is over the target - * @private - * @static - */ - isOverTarget: function(pt, oTarget, intersect) { - // use cache if available - var loc = this.locationCache[oTarget.id]; - if (!loc || !this.useCache) { - loc = this.getLocation(oTarget); - this.locationCache[oTarget.id] = loc; + constructor: function(config){ + Ext.apply(this, config); + Ext.list.ColumnResizer.superclass.constructor.call(this); + }, + init : function(listView){ + this.view = listView; + listView.on('render', this.initEvents, this); + }, + + initEvents : function(view){ + view.mon(view.innerHd, 'mousemove', this.handleHdMove, this); + this.tracker = new Ext.dd.DragTracker({ + onBeforeStart: this.onBeforeStart.createDelegate(this), + onStart: this.onStart.createDelegate(this), + onDrag: this.onDrag.createDelegate(this), + onEnd: this.onEnd.createDelegate(this), + tolerance: 3, + autoStart: 300 + }); + this.tracker.initEl(view.innerHd); + view.on('beforedestroy', this.tracker.destroy, this.tracker); + }, - } + handleHdMove : function(e, t){ + var hw = 5, + x = e.getPageX(), + hd = e.getTarget('em', 3, true); + if(hd){ + var r = hd.getRegion(), + ss = hd.dom.style, + pn = hd.dom.parentNode; - if (!loc) { - return false; + if(x - r.left <= hw && pn != pn.parentNode.firstChild){ + this.activeHd = Ext.get(pn.previousSibling.firstChild); + ss.cursor = Ext.isWebKit ? 'e-resize' : 'col-resize'; + } else if(r.right - x <= hw && pn != pn.parentNode.lastChild.previousSibling){ + this.activeHd = hd; + ss.cursor = Ext.isWebKit ? 'w-resize' : 'col-resize'; + } else{ + delete this.activeHd; + ss.cursor = ''; } + } + }, - oTarget.cursorIsOver = loc.contains( pt ); + onBeforeStart : function(e){ + this.dragHd = this.activeHd; + return !!this.dragHd; + }, - // DragDrop is using this as a sanity check for the initial mousedown - // in this case we are done. In POINT mode, if the drag obj has no - // contraints, we are also done. Otherwise we need to evaluate the - // location of the target as related to the actual location of the - // dragged element. - var dc = this.dragCurrent; - if (!dc || !dc.getTargetCoord || - (!intersect && !dc.constrainX && !dc.constrainY)) { - return oTarget.cursorIsOver; - } + onStart: function(e){ + this.view.disableHeaders = true; + this.proxy = this.view.el.createChild({cls:'x-list-resizer'}); + this.proxy.setHeight(this.view.el.getHeight()); - oTarget.overlap = null; + var x = this.tracker.getXY()[0], + w = this.view.innerHd.getWidth(); - // Get the current location of the drag element, this is the - // location of the mouse event less the delta that represents - // where the original mousedown happened on the element. We - // need to consider constraints and ticks as well. - var pos = dc.getTargetCoord(pt.x, pt.y); + this.hdX = this.dragHd.getX(); + this.hdIndex = this.view.findHeaderIndex(this.dragHd); - var el = dc.getDragEl(); - var curRegion = new Ext.lib.Region( pos.y, - pos.x + el.offsetWidth, - pos.y + el.offsetHeight, - pos.x ); + this.proxy.setX(this.hdX); + this.proxy.setWidth(x-this.hdX); - var overlap = curRegion.intersect(loc); + this.minWidth = w*this.minPct; + this.maxWidth = w - (this.minWidth*(this.view.columns.length-1-this.hdIndex)); + }, - if (overlap) { - oTarget.overlap = overlap; - return (intersect) ? true : oTarget.cursorIsOver; - } else { - return false; - } - }, + onDrag: function(e){ + var cursorX = this.tracker.getXY()[0]; + this.proxy.setWidth((cursorX-this.hdX).constrain(this.minWidth, this.maxWidth)); + }, - /** - * unload event handler - * @method _onUnload - * @private - * @static - */ - _onUnload: function(e, me) { - Ext.dd.DragDropMgr.unregAll(); - }, + onEnd: function(e){ + /* calculate desired width by measuring proxy and then remove it */ + var nw = this.proxy.getWidth(); + this.proxy.remove(); - /** - * Cleans up the drag and drop events and objects. - * @method unregAll - * @private - * @static - */ - unregAll: function() { + var index = this.hdIndex, + vw = this.view, + cs = vw.columns, + len = cs.length, + w = this.view.innerHd.getWidth(), + minPct = this.minPct * 100, + pct = Math.ceil((nw * vw.maxWidth) / w), + diff = (cs[index].width * 100) - pct, + eachItem = Math.floor(diff / (len-1-index)), + mod = diff - (eachItem * (len-1-index)); - if (this.dragCurrent) { - this.stopDrag(); - this.dragCurrent = null; + for(var i = index+1; i < len; i++){ + var cw = (cs[i].width * 100) + eachItem, + ncw = Math.max(minPct, cw); + if(cw != ncw){ + mod += cw - ncw; } + cs[i].width = ncw / 100; + } + cs[index].width = pct / 100; + cs[index+1].width += (mod / 100); + delete this.dragHd; + vw.setHdWidths(); + vw.refresh(); + setTimeout(function(){ + vw.disableHeaders = false; + }, 100); + } +}); - this._execOnAll("unreg", []); +// Backwards compatibility alias +Ext.ListView.ColumnResizer = Ext.list.ColumnResizer;/** + * @class Ext.list.Sorter + * @extends Ext.util.Observable + * Supporting Class for Ext.list.ListView + * @constructor + * @param {Object} config + */ +Ext.list.Sorter = Ext.extend(Ext.util.Observable, { + /** + * @cfg {Array} sortClasses + * The CSS classes applied to a header when it is sorted. (defaults to ["sort-asc", "sort-desc"]) + */ + sortClasses : ["sort-asc", "sort-desc"], - for (var i in this.elementCache) { - delete this.elementCache[i]; - } + constructor: function(config){ + Ext.apply(this, config); + Ext.list.Sorter.superclass.constructor.call(this); + }, - this.elementCache = {}; - this.ids = {}; - }, + init : function(listView){ + this.view = listView; + listView.on('render', this.initEvents, this); + }, - /** - * A cache of DOM elements - * @property elementCache - * @private - * @static - */ - elementCache: {}, + initEvents : function(view){ + view.mon(view.innerHd, 'click', this.onHdClick, this); + view.innerHd.setStyle('cursor', 'pointer'); + view.mon(view.store, 'datachanged', this.updateSortState, this); + this.updateSortState.defer(10, this, [view.store]); + }, - /** - * Get the wrapper for the DOM element specified - * @method getElWrapper - * @param {String} id the id of the element to get - * @return {Ext.dd.DDM.ElementWrapper} the wrapped element - * @private - * @deprecated This wrapper isn't that useful - * @static - */ - getElWrapper: function(id) { - var oWrapper = this.elementCache[id]; - if (!oWrapper || !oWrapper.el) { - oWrapper = this.elementCache[id] = - new this.ElementWrapper(Ext.getDom(id)); + updateSortState : function(store){ + var state = store.getSortState(); + if(!state){ + return; + } + this.sortState = state; + var cs = this.view.columns, sortColumn = -1; + for(var i = 0, len = cs.length; i < len; i++){ + if(cs[i].dataIndex == state.field){ + sortColumn = i; + break; } - return oWrapper; - }, + } + if(sortColumn != -1){ + var sortDir = state.direction; + this.updateSortIcon(sortColumn, sortDir); + } + }, - /** - * Returns the actual DOM element - * @method getElement - * @param {String} id the id of the elment to get - * @return {Object} The element - * @deprecated use Ext.lib.Ext.getDom instead - * @static - */ - getElement: function(id) { - return Ext.getDom(id); - }, + updateSortIcon : function(col, dir){ + var sc = this.sortClasses; + var hds = this.view.innerHd.select('em').removeClass(sc); + hds.item(col).addClass(sc[dir == "DESC" ? 1 : 0]); + }, - /** - * Returns the style property for the DOM element (i.e., - * document.getElById(id).style) - * @method getCss - * @param {String} id the id of the elment to get - * @return {Object} The style property of the element - * @deprecated use Ext.lib.Dom instead - * @static - */ - getCss: function(id) { - var el = Ext.getDom(id); - return (el) ? el.style : null; - }, + onHdClick : function(e){ + var hd = e.getTarget('em', 3); + if(hd && !this.view.disableHeaders){ + var index = this.view.findHeaderIndex(hd); + this.view.store.sort(this.view.columns[index].dataIndex); + } + } +}); - /** - * Inner class for cached elements - * @class Ext.dd.DragDropMgr.ElementWrapper - * @for DragDropMgr - * @private - * @deprecated - */ - ElementWrapper: function(el) { - /** - * The element - * @property el - */ - this.el = el || null; - /** - * The element id - * @property id - */ - this.id = this.el && el.id; - /** - * A reference to the style property - * @property css - */ - this.css = this.el && el.style; - }, +// Backwards compatibility alias +Ext.ListView.Sorter = Ext.list.Sorter;/** + * @class Ext.TabPanel + * A basic tab container. TabPanels can be used exactly like a standard {@link Ext.Panel} + * for layout purposes, but also have special support for containing child Components + * ({@link Ext.Container#items items}) that are managed using a + * {@link Ext.layout.CardLayout CardLayout layout manager}, and displayed as separate tabs. + * + * Note: By default, a tab's close tool destroys the child tab Component + * and all its descendants. This makes the child tab Component, and all its descendants unusable. To enable + * re-use of a tab, configure the TabPanel with {@link #autoDestroy autoDestroy: false}. + * + * TabPanel header/footer elements + * TabPanels use their {@link Ext.Panel#header header} or {@link Ext.Panel#footer footer} element + * (depending on the {@link #tabPosition} configuration) to accommodate the tab selector buttons. + * This means that a TabPanel will not display any configured title, and will not display any + * configured header {@link Ext.Panel#tools tools}. + * To display a header, embed the TabPanel in a {@link Ext.Panel Panel} which uses + * {@link Ext.Container#layout layout:'fit'}. + * + * Tab Events + * There is no actual tab class — each tab is simply a {@link Ext.BoxComponent Component} + * such as a {@link Ext.Panel Panel}. However, when rendered in a TabPanel, each child Component + * can fire additional events that only exist for tabs and are not available from other Components. + * These events are: + * + * {@link Ext.Panel#activate activate} : Fires when this Component becomes + * the active tab. + * {@link Ext.Panel#deactivate deactivate} : Fires when the Component that + * was the active tab becomes deactivated. + * {@link Ext.Panel#beforeclose beforeclose} : Fires when the user clicks on the close tool of a closeable tab. + * May be vetoed by returning false from a handler. + * {@link Ext.Panel#close close} : Fires a closeable tab has been closed by the user. + * + * Creating TabPanels from Code + * TabPanels can be created and rendered completely in code, as in this example: + * +var tabs = new Ext.TabPanel({ + renderTo: Ext.getBody(), + activeTab: 0, + items: [{ + title: 'Tab 1', + html: 'A simple tab' + },{ + title: 'Tab 2', + html: 'Another one' + }] +}); + + * Creating TabPanels from Existing Markup + * TabPanels can also be rendered from pre-existing markup in a couple of ways. + * + * + * Pre-Structured Markup + * + * A container div with one or more nested tab divs with class 'x-tab' can be rendered entirely + * from existing markup (See the {@link #autoTabs} example). + * + * + * Un-Structured Markup + * + * A TabPanel can also be rendered from markup that is not strictly structured by simply specifying by id + * which elements should be the container and the tabs. Using this method tab content can be pulled from different + * elements within the page by id regardless of page structure. For example: + * +var tabs = new Ext.TabPanel({ + renderTo: 'my-tabs', + activeTab: 0, + items:[ + {contentEl:'tab1', title:'Tab 1'}, + {contentEl:'tab2', title:'Tab 2'} + ] +}); - /** - * Returns the X position of an html element - * @method getPosX - * @param el the element for which to get the position - * @return {int} the X coordinate - * @for DragDropMgr - * @deprecated use Ext.lib.Dom.getX instead - * @static - */ - getPosX: function(el) { - return Ext.lib.Dom.getX(el); - }, +// Note that the tabs do not have to be nested within the container (although they can be) +<div id="my-tabs"></div> +<div id="tab1" class="x-hide-display">A simple tab</div> +<div id="tab2" class="x-hide-display">Another one</div> + + * Note that the tab divs in this example contain the class 'x-hide-display' so that they can be rendered + * deferred without displaying outside the tabs. You could alternately set {@link #deferredRender} = false + * to render all content tabs on page load. + * + * + * + * + * @extends Ext.Panel + * @constructor + * @param {Object} config The configuration options + * @xtype tabpanel + */ +Ext.TabPanel = Ext.extend(Ext.Panel, { + /** + * @cfg {Boolean} layoutOnTabChange + * Set to true to force a layout of the active tab when the tab is changed. Defaults to false. + * See {@link Ext.layout.CardLayout}.{@link Ext.layout.CardLayout#layoutOnCardChange layoutOnCardChange}. + */ + /** + * @cfg {String} tabCls This config option is used on child Components of ths TabPanel. A CSS + * class name applied to the tab strip item representing the child Component, allowing special + * styling to be applied. + */ + /** + * @cfg {Boolean} deferredRender + * true by default to defer the rendering of child {@link Ext.Container#items items} + * to the browsers DOM until a tab is activated. false will render all contained + * {@link Ext.Container#items items} as soon as the {@link Ext.layout.CardLayout layout} + * is rendered. If there is a significant amount of content or a lot of heavy controls being + * rendered into panels that are not displayed by default, setting this to true might + * improve performance. + * The deferredRender property is internally passed to the layout manager for + * TabPanels ({@link Ext.layout.CardLayout}) as its {@link Ext.layout.CardLayout#deferredRender} + * configuration value. + * Note: leaving deferredRender as true means that the content + * within an unactivated tab will not be available. For example, this means that if the TabPanel + * is within a {@link Ext.form.FormPanel form}, then until a tab is activated, any Fields within + * unactivated tabs will not be rendered, and will therefore not be submitted and will not be + * available to either {@link Ext.form.BasicForm#getValues getValues} or + * {@link Ext.form.BasicForm#setValues setValues}. + */ + deferredRender : true, + /** + * @cfg {Number} tabWidth The initial width in pixels of each new tab (defaults to 120). + */ + tabWidth : 120, + /** + * @cfg {Number} minTabWidth The minimum width in pixels for each tab when {@link #resizeTabs} = true (defaults to 30). + */ + minTabWidth : 30, + /** + * @cfg {Boolean} resizeTabs True to automatically resize each tab so that the tabs will completely fill the + * tab strip (defaults to false). Setting this to true may cause specific widths that might be set per tab to + * be overridden in order to fit them all into view (although {@link #minTabWidth} will always be honored). + */ + resizeTabs : false, + /** + * @cfg {Boolean} enableTabScroll True to enable scrolling to tabs that may be invisible due to overflowing the + * overall TabPanel width. Only available with tabPosition:'top' (defaults to false). + */ + enableTabScroll : false, + /** + * @cfg {Number} scrollIncrement The number of pixels to scroll each time a tab scroll button is pressed + * (defaults to 100, or if {@link #resizeTabs} = true, the calculated tab width). Only + * applies when {@link #enableTabScroll} = true. + */ + scrollIncrement : 0, + /** + * @cfg {Number} scrollRepeatInterval Number of milliseconds between each scroll while a tab scroll button is + * continuously pressed (defaults to 400). + */ + scrollRepeatInterval : 400, + /** + * @cfg {Float} scrollDuration The number of milliseconds that each scroll animation should last (defaults + * to .35). Only applies when {@link #animScroll} = true. + */ + scrollDuration : 0.35, + /** + * @cfg {Boolean} animScroll True to animate tab scrolling so that hidden tabs slide smoothly into view (defaults + * to true). Only applies when {@link #enableTabScroll} = true. + */ + animScroll : true, + /** + * @cfg {String} tabPosition The position where the tab strip should be rendered (defaults to 'top'). + * The only other supported value is 'bottom'. Note: tab scrolling is only supported for + * tabPosition: 'top'. + */ + tabPosition : 'top', + /** + * @cfg {String} baseCls The base CSS class applied to the panel (defaults to 'x-tab-panel'). + */ + baseCls : 'x-tab-panel', + /** + * @cfg {Boolean} autoTabs + * true to query the DOM for any divs with a class of 'x-tab' to be automatically converted + * to tabs and added to this panel (defaults to false). Note that the query will be executed within + * the scope of the container element only (so that multiple tab panels from markup can be supported via this + * method). + * This method is only possible when the markup is structured correctly as a container with nested divs + * containing the class 'x-tab'. To create TabPanels without these limitations, or to pull tab content + * from other elements on the page, see the example at the top of the class for generating tabs from markup. + * There are a couple of things to note when using this method: + * When using the autoTabs config (as opposed to passing individual tab configs in the TabPanel's + * {@link #items} collection), you must use {@link #applyTo} to correctly use the specified id + * as the tab container. The autoTabs method replaces existing content with the TabPanel + * components. + * Make sure that you set {@link #deferredRender}: false so that the content elements for each + * tab will be rendered into the TabPanel immediately upon page load, otherwise they will not be transformed + * until each tab is activated and will be visible outside the TabPanel. + * Example usage: + * +var tabs = new Ext.TabPanel({ + applyTo: 'my-tabs', + activeTab: 0, + deferredRender: false, + autoTabs: true +}); + +// This markup will be converted to a TabPanel from the code above +<div id="my-tabs"> + <div class="x-tab" title="Tab 1">A simple tab</div> + <div class="x-tab" title="Tab 2">Another one</div> +</div> + + */ + autoTabs : false, + /** + * @cfg {String} autoTabSelector The CSS selector used to search for tabs in existing markup when + * {@link #autoTabs} = true (defaults to 'div.x-tab'). This can be any valid selector + * supported by {@link Ext.DomQuery#select}. Note that the query will be executed within the scope of this + * tab panel only (so that multiple tab panels from markup can be supported on a page). + */ + autoTabSelector : 'div.x-tab', + /** + * @cfg {String/Number} activeTab A string id or the numeric index of the tab that should be initially + * activated on render (defaults to undefined). + */ + activeTab : undefined, + /** + * @cfg {Number} tabMargin The number of pixels of space to calculate into the sizing and scrolling of + * tabs. If you change the margin in CSS, you will need to update this value so calculations are correct + * with either {@link #resizeTabs} or scrolling tabs. (defaults to 2) + */ + tabMargin : 2, + /** + * @cfg {Boolean} plaintrue to render the tab strip without a background container image + * (defaults to false). + */ + plain : false, + /** + * @cfg {Number} wheelIncrement For scrolling tabs, the number of pixels to increment on mouse wheel + * scrolling (defaults to 20). + */ + wheelIncrement : 20, - /** - * Returns the Y position of an html element - * @method getPosY - * @param el the element for which to get the position - * @return {int} the Y coordinate - * @deprecated use Ext.lib.Dom.getY instead - * @static - */ - getPosY: function(el) { - return Ext.lib.Dom.getY(el); - }, + /* + * This is a protected property used when concatenating tab ids to the TabPanel id for internal uniqueness. + * It does not generally need to be changed, but can be if external code also uses an id scheme that can + * potentially clash with this one. + */ + idDelimiter : '__', - /** - * Swap two nodes. In IE, we use the native method, for others we - * emulate the IE behavior - * @method swapNode - * @param n1 the first node to swap - * @param n2 the other node to swap - * @static - */ - swapNode: function(n1, n2) { - if (n1.swapNode) { - n1.swapNode(n2); - } else { - var p = n2.parentNode; - var s = n2.nextSibling; + // private + itemCls : 'x-tab-item', - if (s == n1) { - p.insertBefore(n1, n2); - } else if (n2 == n1.nextSibling) { - p.insertBefore(n2, n1); - } else { - n1.parentNode.replaceChild(n2, n1); - p.insertBefore(n1, s); - } - } - }, + // private config overrides + elements : 'body', + headerAsText : false, + frame : false, + hideBorders :true, + // private + initComponent : function(){ + this.frame = false; + Ext.TabPanel.superclass.initComponent.call(this); + this.addEvents( + /** + * @event beforetabchange + * Fires before the active tab changes. Handlers can return false to cancel the tab change. + * @param {TabPanel} this + * @param {Panel} newTab The tab being activated + * @param {Panel} currentTab The current active tab + */ + 'beforetabchange', + /** + * @event tabchange + * Fires after the active tab has changed. + * @param {TabPanel} this + * @param {Panel} tab The new active tab + */ + 'tabchange', + /** + * @event contextmenu + * Relays the contextmenu event from a tab selector element in the tab strip. + * @param {TabPanel} this + * @param {Panel} tab The target tab + * @param {EventObject} e + */ + 'contextmenu' + ); /** - * Returns the current scroll position - * @method getScroll - * @private - * @static + * @cfg {Object} layoutConfig + * TabPanel implicitly uses {@link Ext.layout.CardLayout} as its layout manager. + * layoutConfig may be used to configure this layout manager. + * {@link #deferredRender} and {@link #layoutOnTabChange} + * configured on the TabPanel will be applied as configs to the layout manager. */ - getScroll: function () { - var t, l, dde=document.documentElement, db=document.body; - if (dde && (dde.scrollTop || dde.scrollLeft)) { - t = dde.scrollTop; - l = dde.scrollLeft; - } else if (db) { - t = db.scrollTop; - l = db.scrollLeft; - } else { + this.setLayout(new Ext.layout.CardLayout(Ext.apply({ + layoutOnCardChange: this.layoutOnTabChange, + deferredRender: this.deferredRender + }, this.layoutConfig))); - } - return { top: t, left: l }; - }, + if(this.tabPosition == 'top'){ + this.elements += ',header'; + this.stripTarget = 'header'; + }else { + this.elements += ',footer'; + this.stripTarget = 'footer'; + } + if(!this.stack){ + this.stack = Ext.TabPanel.AccessStack(); + } + this.initItems(); + }, - /** - * Returns the specified element style property - * @method getStyle - * @param {HTMLElement} el the element - * @param {string} styleProp the style property - * @return {string} The value of the style property - * @deprecated use Ext.lib.Dom.getStyle - * @static - */ - getStyle: function(el, styleProp) { - return Ext.fly(el).getStyle(styleProp); - }, + // private + onRender : function(ct, position){ + Ext.TabPanel.superclass.onRender.call(this, ct, position); - /** - * Gets the scrollTop - * @method getScrollTop - * @return {int} the document's scrollTop - * @static - */ - getScrollTop: function () { return this.getScroll().top; }, + if(this.plain){ + var pos = this.tabPosition == 'top' ? 'header' : 'footer'; + this[pos].addClass('x-tab-panel-'+pos+'-plain'); + } - /** - * Gets the scrollLeft - * @method getScrollLeft - * @return {int} the document's scrollTop - * @static - */ - getScrollLeft: function () { return this.getScroll().left; }, + var st = this[this.stripTarget]; - /** - * Sets the x/y position of an element to the location of the - * target element. - * @method moveToEl - * @param {HTMLElement} moveEl The element to move - * @param {HTMLElement} targetEl The position reference element - * @static - */ - moveToEl: function (moveEl, targetEl) { - var aCoord = Ext.lib.Dom.getXY(targetEl); - Ext.lib.Dom.setXY(moveEl, aCoord); - }, + this.stripWrap = st.createChild({cls:'x-tab-strip-wrap', cn:{ + tag:'ul', cls:'x-tab-strip x-tab-strip-'+this.tabPosition}}); - /** - * Numeric array sort function - * @method numericSort - * @static - */ - numericSort: function(a, b) { return (a - b); }, + var beforeEl = (this.tabPosition=='bottom' ? this.stripWrap : null); + st.createChild({cls:'x-tab-strip-spacer'}, beforeEl); + this.strip = new Ext.Element(this.stripWrap.dom.firstChild); - /** - * Internal counter - * @property _timeoutCount - * @private - * @static - */ - _timeoutCount: 0, + // create an empty span with class x-tab-strip-text to force the height of the header element when there's no tabs. + this.edge = this.strip.createChild({tag:'li', cls:'x-tab-edge', cn: [{tag: 'span', cls: 'x-tab-strip-text', cn: ' '}]}); + this.strip.createChild({cls:'x-clear'}); - /** - * Trying to make the load order less important. Without this we get - * an error if this file is loaded before the Event Utility. - * @method _addListeners - * @private - * @static - */ - _addListeners: function() { - var DDM = Ext.dd.DDM; - if ( Ext.lib.Event && document ) { - DDM._onLoad(); - } else { - if (DDM._timeoutCount > 2000) { - } else { - setTimeout(DDM._addListeners, 10); - if (document && document.body) { - DDM._timeoutCount += 1; - } - } - } - }, + this.body.addClass('x-tab-panel-body-'+this.tabPosition); /** - * Recursively searches the immediate parent and all child nodes for - * the handle element in order to determine wheter or not it was - * clicked. - * @method handleWasClicked - * @param node the html element to inspect - * @static - */ - handleWasClicked: function(node, id) { - if (this.isHandle(id, node.id)) { - return true; - } else { - // check to see if this is a text node child of the one we want - var p = node.parentNode; - - while (p) { - if (this.isHandle(id, p.id)) { - return true; - } else { - p = p.parentNode; - } - } - } + * @cfg {Template/XTemplate} itemTpl
(Optional) A {@link Ext.Template Template} or + * {@link Ext.XTemplate XTemplate} which may be provided to process the data object returned from + * {@link #getTemplateArgs} to produce a clickable selector element in the tab strip.
+ *
The main element created should be a <li> element. In order for a click event on + * a selector element to be connected to its item, it must take its id from the TabPanel's + * native {@link #getTemplateArgs}.
+ *
The child element which contains the title text must be marked by the CSS class + * x-tab-strip-inner.
+ *
To enable closability, the created element should contain an element marked by the CSS class + * x-tab-strip-close.
+ *
If a custom itemTpl is supplied, it is the developer's responsibility to create CSS + * style rules to create the desired appearance.
+ * Below is an example of how to create customized tab selector items:
+new Ext.TabPanel({ + renderTo: document.body, + minTabWidth: 115, + tabWidth: 135, + enableTabScroll: true, + width: 600, + height: 250, + defaults: {autoScroll:true}, + itemTpl: new Ext.XTemplate( + '<li class="{cls}" id="{id}" style="overflow:hidden">', + '<tpl if="closable">', + '<a class="x-tab-strip-close"></a>', + '</tpl>', + '<a class="x-tab-right" href="#" style="padding-left:6px">', + '<em class="x-tab-left">', + '<span class="x-tab-strip-inner">', + '<img src="{src}" style="float:left;margin:3px 3px 0 0">', + '<span style="margin-left:20px" class="x-tab-strip-text {iconCls}">{text} {extra}</span>', + '</span>', + '</em>', + '</a>', + '</li>' + ), + getTemplateArgs: function(item) { +// Call the native method to collect the base data. Like the ID! + var result = Ext.TabPanel.prototype.getTemplateArgs.call(this, item); - return false; +// Add stuff used in our template + return Ext.apply(result, { + closable: item.closable, + src: item.iconSrc, + extra: item.extraText || '' + }); + }, + items: [{ + title: 'New Tab 1', + iconSrc: '../shared/icons/fam/grid.png', + html: 'Tab Body 1', + closable: true + }, { + title: 'New Tab 2', + iconSrc: '../shared/icons/fam/grid.png', + html: 'Tab Body 2', + extraText: 'Extra stuff in the tab button' + }] +}); +
+ */ + if(!this.itemTpl){ + var tt = new Ext.Template( + '
', + '', + '{text}', + '
' + ); + tt.disableFormats = true; + tt.compile(); + Ext.TabPanel.prototype.itemTpl = tt; } - }; - -}(); - -// shorter alias, save a few bytes -Ext.dd.DDM = Ext.dd.DragDropMgr; -Ext.dd.DDM._addListeners(); - -} - -/** - * @class Ext.dd.DD - * A DragDrop implementation where the linked element follows the - * mouse cursor during a drag. - * @extends Ext.dd.DragDrop - * @constructor - * @param {String} id the id of the linked element - * @param {String} sGroup the group of related DragDrop items - * @param {object} config an object containing configurable attributes - * Valid properties for DD: - * scroll - */ -Ext.dd.DD = function(id, sGroup, config) { - if (id) { - this.init(id, sGroup, config); - } -}; - -Ext.extend(Ext.dd.DD, Ext.dd.DragDrop, { - - /** - * When set to true, the utility automatically tries to scroll the browser - * window when a drag and drop element is dragged near the viewport boundary. - * Defaults to true. - * @property scroll - * @type boolean - */ - scroll: true, + this.items.each(this.initTab, this); + }, - /** - * Sets the pointer offset to the distance between the linked element's top - * left corner and the location the element was clicked - * @method autoOffset - * @param {int} iPageX the X coordinate of the click - * @param {int} iPageY the Y coordinate of the click - */ - autoOffset: function(iPageX, iPageY) { - var x = iPageX - this.startPageX; - var y = iPageY - this.startPageY; - this.setDelta(x, y); + // private + afterRender : function(){ + Ext.TabPanel.superclass.afterRender.call(this); + if(this.autoTabs){ + this.readTabs(false); + } + if(this.activeTab !== undefined){ + var item = Ext.isObject(this.activeTab) ? this.activeTab : this.items.get(this.activeTab); + delete this.activeTab; + this.setActiveTab(item); + } }, - /** - * Sets the pointer offset. You can call this directly to force the - * offset to be in a particular location (e.g., pass in 0,0 to set it - * to the center of the object) - * @method setDelta - * @param {int} iDeltaX the distance from the left - * @param {int} iDeltaY the distance from the top - */ - setDelta: function(iDeltaX, iDeltaY) { - this.deltaX = iDeltaX; - this.deltaY = iDeltaY; + // private + initEvents : function(){ + Ext.TabPanel.superclass.initEvents.call(this); + this.mon(this.strip, { + scope: this, + mousedown: this.onStripMouseDown, + contextmenu: this.onStripContextMenu + }); + if(this.enableTabScroll){ + this.mon(this.strip, 'mousewheel', this.onWheel, this); + } }, - /** - * Sets the drag element to the location of the mousedown or click event, - * maintaining the cursor location relative to the location on the element - * that was clicked. Override this if you want to place the element in a - * location other than where the cursor is. - * @method setDragElPos - * @param {int} iPageX the X coordinate of the mousedown or drag event - * @param {int} iPageY the Y coordinate of the mousedown or drag event - */ - setDragElPos: function(iPageX, iPageY) { - // the first time we do this, we are going to check to make sure - // the element has css positioning + // private + findTargets : function(e){ + var item = null, + itemEl = e.getTarget('li:not(.x-tab-edge)', this.strip); - var el = this.getDragEl(); - this.alignElWithMouse(el, iPageX, iPageY); + if(itemEl){ + item = this.getComponent(itemEl.id.split(this.idDelimiter)[1]); + if(item.disabled){ + return { + close : null, + item : null, + el : null + }; + } + } + return { + close : e.getTarget('.x-tab-strip-close', this.strip), + item : item, + el : itemEl + }; }, - /** - * Sets the element to the location of the mousedown or click event, - * maintaining the cursor location relative to the location on the element - * that was clicked. Override this if you want to place the element in a - * location other than where the cursor is. - * @method alignElWithMouse - * @param {HTMLElement} el the element to move - * @param {int} iPageX the X coordinate of the mousedown or drag event - * @param {int} iPageY the Y coordinate of the mousedown or drag event - */ - alignElWithMouse: function(el, iPageX, iPageY) { - var oCoord = this.getTargetCoord(iPageX, iPageY); - var fly = el.dom ? el : Ext.fly(el, '_dd'); - if (!this.deltaSetXY) { - var aCoord = [oCoord.x, oCoord.y]; - fly.setXY(aCoord); - var newLeft = fly.getLeft(true); - var newTop = fly.getTop(true); - this.deltaSetXY = [ newLeft - oCoord.x, newTop - oCoord.y ]; - } else { - fly.setLeftTop(oCoord.x + this.deltaSetXY[0], oCoord.y + this.deltaSetXY[1]); + // private + onStripMouseDown : function(e){ + if(e.button !== 0){ + return; + } + e.preventDefault(); + var t = this.findTargets(e); + if(t.close){ + if (t.item.fireEvent('beforeclose', t.item) !== false) { + t.item.fireEvent('close', t.item); + this.remove(t.item); + } + return; + } + if(t.item && t.item != this.activeTab){ + this.setActiveTab(t.item); } + }, - this.cachePosition(oCoord.x, oCoord.y); - this.autoScroll(oCoord.x, oCoord.y, el.offsetHeight, el.offsetWidth); - return oCoord; + // private + onStripContextMenu : function(e){ + e.preventDefault(); + var t = this.findTargets(e); + if(t.item){ + this.fireEvent('contextmenu', this, t.item, e); + } }, /** - * Saves the most recent position so that we can reset the constraints and - * tick marks on-demand. We need to know this so that we can calculate the - * number of pixels the element is offset from its original position. - * @method cachePosition - * @param iPageX the current x position (optional, this just makes it so we - * don't have to look it up again) - * @param iPageY the current y position (optional, this just makes it so we - * don't have to look it up again) + * True to scan the markup in this tab panel for {@link #autoTabs} using the + * {@link #autoTabSelector} + * @param {Boolean} removeExisting True to remove existing tabs */ - cachePosition: function(iPageX, iPageY) { - if (iPageX) { - this.lastPageX = iPageX; - this.lastPageY = iPageY; - } else { - var aCoord = Ext.lib.Dom.getXY(this.getEl()); - this.lastPageX = aCoord[0]; - this.lastPageY = aCoord[1]; + readTabs : function(removeExisting){ + if(removeExisting === true){ + this.items.each(function(item){ + this.remove(item); + }, this); + } + var tabs = this.el.query(this.autoTabSelector); + for(var i = 0, len = tabs.length; i < len; i++){ + var tab = tabs[i], + title = tab.getAttribute('title'); + tab.removeAttribute('title'); + this.add({ + title: title, + contentEl: tab + }); } }, - /** - * Auto-scroll the window if the dragged object has been moved beyond the - * visible window boundary. - * @method autoScroll - * @param {int} x the drag element's x position - * @param {int} y the drag element's y position - * @param {int} h the height of the drag element - * @param {int} w the width of the drag element - * @private - */ - autoScroll: function(x, y, h, w) { - - if (this.scroll) { - // The client height - var clientH = Ext.lib.Dom.getViewHeight(); - - // The client width - var clientW = Ext.lib.Dom.getViewWidth(); - - // The amt scrolled down - var st = this.DDM.getScrollTop(); - - // The amt scrolled right - var sl = this.DDM.getScrollLeft(); + // private + initTab : function(item, index){ + var before = this.strip.dom.childNodes[index], + p = this.getTemplateArgs(item), + el = before ? + this.itemTpl.insertBefore(before, p) : + this.itemTpl.append(this.strip, p), + cls = 'x-tab-strip-over', + tabEl = Ext.get(el); - // Location of the bottom of the element - var bot = h + y; + tabEl.hover(function(){ + if(!item.disabled){ + tabEl.addClass(cls); + } + }, function(){ + tabEl.removeClass(cls); + }); - // Location of the right of the element - var right = w + x; + if(item.tabTip){ + tabEl.child('span.x-tab-strip-text', true).qtip = item.tabTip; + } + item.tabEl = el; - // The distance from the cursor to the bottom of the visible area, - // adjusted so that we don't scroll if the cursor is beyond the - // element drag constraints - var toBot = (clientH + st - y - this.deltaY); + // Route *keyboard triggered* click events to the tab strip mouse handler. + tabEl.select('a').on('click', function(e){ + if(!e.getPageX()){ + this.onStripMouseDown(e); + } + }, this, {preventDefault: true}); - // The distance from the cursor to the right of the visible area - var toRight = (clientW + sl - x - this.deltaX); + item.on({ + scope: this, + disable: this.onItemDisabled, + enable: this.onItemEnabled, + titlechange: this.onItemTitleChanged, + iconchange: this.onItemIconChanged, + beforeshow: this.onBeforeShowItem + }); + }, - // How close to the edge the cursor must be before we scroll - // var thresh = (document.all) ? 100 : 40; - var thresh = 40; - // How many pixels to scroll per autoscroll op. This helps to reduce - // clunky scrolling. IE is more sensitive about this ... it needs this - // value to be higher. - var scrAmt = (document.all) ? 80 : 30; + /** + *
Provides template arguments for rendering a tab selector item in the tab strip.
+ *
This method returns an object hash containing properties used by the TabPanel's {@link #itemTpl} + * to create a formatted, clickable tab selector element. The properties which must be returned + * are:
+ *
id : String
A unique identifier which links to the item
+ *
text : String
The text to display
+ *
cls : String
The CSS class name
+ *
iconCls : String
A CSS class to provide appearance for an icon.
+ *
+ * @param {Ext.BoxComponent} item The {@link Ext.BoxComponent BoxComponent} for which to create a selector element in the tab strip. + * @return {Object} An object hash containing the properties required to render the selector element. + */ + getTemplateArgs : function(item) { + var cls = item.closable ? 'x-tab-strip-closable' : ''; + if(item.disabled){ + cls += ' x-item-disabled'; + } + if(item.iconCls){ + cls += ' x-tab-with-icon'; + } + if(item.tabCls){ + cls += ' ' + item.tabCls; + } - // Scroll down if we are near the bottom of the visible page and the - // obj extends below the crease - if ( bot > clientH && toBot < thresh ) { - window.scrollTo(sl, st + scrAmt); - } + return { + id: this.id + this.idDelimiter + item.getItemId(), + text: item.title, + cls: cls, + iconCls: item.iconCls || '' + }; + }, - // Scroll up if the window is scrolled down and the top of the object - // goes above the top border - if ( y < st && st > 0 && y - st < thresh ) { - window.scrollTo(sl, st - scrAmt); + // private + onAdd : function(c){ + Ext.TabPanel.superclass.onAdd.call(this, c); + if(this.rendered){ + var items = this.items; + this.initTab(c, items.indexOf(c)); + if(items.getCount() == 1 && !this.collapsed){ + this.syncSize(); } + this.delegateUpdates(); + } + }, - // Scroll right if the obj is beyond the right border and the cursor is - // near the border. - if ( right > clientW && toRight < thresh ) { - window.scrollTo(sl + scrAmt, st); - } + // private + onBeforeAdd : function(item){ + var existing = item.events ? (this.items.containsKey(item.getItemId()) ? item : null) : this.items.get(item); + if(existing){ + this.setActiveTab(item); + return false; + } + Ext.TabPanel.superclass.onBeforeAdd.apply(this, arguments); + var es = item.elements; + item.elements = es ? es.replace(',header', '') : es; + item.border = (item.border === true); + }, - // Scroll left if the window has been scrolled to the right and the obj - // extends past the left border - if ( x < sl && sl > 0 && x - sl < thresh ) { - window.scrollTo(sl - scrAmt, st); + // private + onRemove : function(c){ + var te = Ext.get(c.tabEl); + // check if the tabEl exists, it won't if the tab isn't rendered + if(te){ + te.select('a').removeAllListeners(); + Ext.destroy(te); + } + Ext.TabPanel.superclass.onRemove.call(this, c); + this.stack.remove(c); + delete c.tabEl; + c.un('disable', this.onItemDisabled, this); + c.un('enable', this.onItemEnabled, this); + c.un('titlechange', this.onItemTitleChanged, this); + c.un('iconchange', this.onItemIconChanged, this); + c.un('beforeshow', this.onBeforeShowItem, this); + if(c == this.activeTab){ + var next = this.stack.next(); + if(next){ + this.setActiveTab(next); + }else if(this.items.getCount() > 0){ + this.setActiveTab(0); + }else{ + this.setActiveTab(null); } } + if(!this.destroying){ + this.delegateUpdates(); + } }, - /** - * Finds the location the element should be placed if we want to move - * it to where the mouse location less the click offset would place us. - * @method getTargetCoord - * @param {int} iPageX the X coordinate of the click - * @param {int} iPageY the Y coordinate of the click - * @return an object that contains the coordinates (Object.x and Object.y) - * @private - */ - getTargetCoord: function(iPageX, iPageY) { - + // private + onBeforeShowItem : function(item){ + if(item != this.activeTab){ + this.setActiveTab(item); + return false; + } + }, - var x = iPageX - this.deltaX; - var y = iPageY - this.deltaY; + // private + onItemDisabled : function(item){ + var el = this.getTabEl(item); + if(el){ + Ext.fly(el).addClass('x-item-disabled'); + } + this.stack.remove(item); + }, - if (this.constrainX) { - if (x < this.minX) { x = this.minX; } - if (x > this.maxX) { x = this.maxX; } + // private + onItemEnabled : function(item){ + var el = this.getTabEl(item); + if(el){ + Ext.fly(el).removeClass('x-item-disabled'); } + }, - if (this.constrainY) { - if (y < this.minY) { y = this.minY; } - if (y > this.maxY) { y = this.maxY; } + // private + onItemTitleChanged : function(item){ + var el = this.getTabEl(item); + if(el){ + Ext.fly(el).child('span.x-tab-strip-text', true).innerHTML = item.title; } + }, - x = this.getTick(x, this.xTicks); - y = this.getTick(y, this.yTicks); + //private + onItemIconChanged : function(item, iconCls, oldCls){ + var el = this.getTabEl(item); + if(el){ + el = Ext.get(el); + el.child('span.x-tab-strip-text').replaceClass(oldCls, iconCls); + el[Ext.isEmpty(iconCls) ? 'removeClass' : 'addClass']('x-tab-with-icon'); + } + }, + /** + * Gets the DOM element for the tab strip item which activates the child panel with the specified + * ID. Access this to change the visual treatment of the item, for example by changing the CSS class name. + * @param {Panel/Number/String} tab The tab component, or the tab's index, or the tabs id or itemId. + * @return {HTMLElement} The DOM node + */ + getTabEl : function(item){ + var c = this.getComponent(item); + return c ? c.tabEl : null; + }, - return {x:x, y:y}; + // private + onResize : function(){ + Ext.TabPanel.superclass.onResize.apply(this, arguments); + this.delegateUpdates(); }, /** - * Sets up config options specific to this class. Overrides - * Ext.dd.DragDrop, but all versions of this method through the - * inheritance chain are called + * Suspends any internal calculations or scrolling while doing a bulk operation. See {@link #endUpdate} */ - applyConfig: function() { - Ext.dd.DD.superclass.applyConfig.call(this); - this.scroll = (this.config.scroll !== false); + beginUpdate : function(){ + this.suspendUpdates = true; }, /** - * Event that fires prior to the onMouseDown event. Overrides - * Ext.dd.DragDrop. + * Resumes calculations and scrolling at the end of a bulk operation. See {@link #beginUpdate} */ - b4MouseDown: function(e) { - // this.resetConstraints(); - this.autoOffset(e.getPageX(), - e.getPageY()); + endUpdate : function(){ + this.suspendUpdates = false; + this.delegateUpdates(); }, /** - * Event that fires prior to the onDrag event. Overrides - * Ext.dd.DragDrop. + * Hides the tab strip item for the passed tab + * @param {Number/String/Panel} item The tab index, id or item */ - b4Drag: function(e) { - this.setDragElPos(e.getPageX(), - e.getPageY()); + hideTabStripItem : function(item){ + item = this.getComponent(item); + var el = this.getTabEl(item); + if(el){ + el.style.display = 'none'; + this.delegateUpdates(); + } + this.stack.remove(item); }, - toString: function() { - return ("DD " + this.id); - } - - ////////////////////////////////////////////////////////////////////////// - // Debugging ygDragDrop events that can be overridden - ////////////////////////////////////////////////////////////////////////// - /* - startDrag: function(x, y) { + /** + * Unhides the tab strip item for the passed tab + * @param {Number/String/Panel} item The tab index, id or item + */ + unhideTabStripItem : function(item){ + item = this.getComponent(item); + var el = this.getTabEl(item); + if(el){ + el.style.display = ''; + this.delegateUpdates(); + } }, - onDrag: function(e) { + // private + delegateUpdates : function(){ + if(this.suspendUpdates){ + return; + } + if(this.resizeTabs && this.rendered){ + this.autoSizeTabs(); + } + if(this.enableTabScroll && this.rendered){ + this.autoScrollTabs(); + } }, - onDragEnter: function(e, id) { - }, + // private + autoSizeTabs : function(){ + var count = this.items.length, + ce = this.tabPosition != 'bottom' ? 'header' : 'footer', + ow = this[ce].dom.offsetWidth, + aw = this[ce].dom.clientWidth; - onDragOver: function(e, id) { - }, + if(!this.resizeTabs || count < 1 || !aw){ // !aw for display:none + return; + } - onDragOut: function(e, id) { + var each = Math.max(Math.min(Math.floor((aw-4) / count) - this.tabMargin, this.tabWidth), this.minTabWidth); // -4 for float errors in IE + this.lastTabWidth = each; + var lis = this.strip.query('li:not(.x-tab-edge)'); + for(var i = 0, len = lis.length; i < len; i++) { + var li = lis[i], + inner = Ext.fly(li).child('.x-tab-strip-inner', true), + tw = li.offsetWidth, + iw = inner.offsetWidth; + inner.style.width = (each - (tw-iw)) + 'px'; + } }, - onDragDrop: function(e, id) { + // private + adjustBodyWidth : function(w){ + if(this.header){ + this.header.setWidth(w); + } + if(this.footer){ + this.footer.setWidth(w); + } + return w; }, - endDrag: function(e) { - } - - */ - -}); -/** - * @class Ext.dd.DDProxy - * A DragDrop implementation that inserts an empty, bordered div into - * the document that follows the cursor during drag operations. At the time of - * the click, the frame div is resized to the dimensions of the linked html - * element, and moved to the exact location of the linked element. - * - * References to the "frame" element refer to the single proxy element that - * was created to be dragged in place of all DDProxy elements on the - * page. - * - * @extends Ext.dd.DD - * @constructor - * @param {String} id the id of the linked html element - * @param {String} sGroup the group of related DragDrop objects - * @param {object} config an object containing configurable attributes - * Valid properties for DDProxy in addition to those in DragDrop: - * resizeFrame, centerFrame, dragElId - */ -Ext.dd.DDProxy = function(id, sGroup, config) { - if (id) { - this.init(id, sGroup, config); - this.initFrame(); - } -}; - -/** - * The default drag frame div id - * @property Ext.dd.DDProxy.dragElId - * @type String - * @static - */ -Ext.dd.DDProxy.dragElId = "ygddfdiv"; - -Ext.extend(Ext.dd.DDProxy, Ext.dd.DD, { - /** - * By default we resize the drag frame to be the same size as the element - * we want to drag (this is to get the frame effect). We can turn it off - * if we want a different behavior. - * @property resizeFrame - * @type boolean + * Sets the specified tab as the active tab. This method fires the {@link #beforetabchange} event which + * can return false to cancel the tab change. + * @param {String/Number} item + * The id or tab Panel to activate. This parameter may be any of the following: + *
+ *
a String : representing the {@link Ext.Component#itemId itemId} + * or {@link Ext.Component#id id} of the child component
+ *
a Number : representing the position of the child component + * within the {@link Ext.Container#items items} property
+ *
+ *
For additional information see {@link Ext.util.MixedCollection#get}. */ - resizeFrame: true, + setActiveTab : function(item){ + item = this.getComponent(item); + if(this.fireEvent('beforetabchange', this, item, this.activeTab) === false){ + return; + } + if(!this.rendered){ + this.activeTab = item; + return; + } + if(this.activeTab != item){ + if(this.activeTab){ + var oldEl = this.getTabEl(this.activeTab); + if(oldEl){ + Ext.fly(oldEl).removeClass('x-tab-strip-active'); + } + } + if(item){ + var el = this.getTabEl(item); + Ext.fly(el).addClass('x-tab-strip-active'); + this.activeTab = item; + this.stack.add(item); + + this.layout.setActiveItem(item); + if(this.scrolling){ + this.scrollToTab(item, this.animScroll); + } + } + this.fireEvent('tabchange', this, item); + } + }, /** - * By default the frame is positioned exactly where the drag element is, so - * we use the cursor offset provided by Ext.dd.DD. Another option that works only if - * you do not have constraints on the obj is to have the drag frame centered - * around the cursor. Set centerFrame to true for this effect. - * @property centerFrame - * @type boolean + * Returns the Component which is the currently active tab. Note that before the TabPanel + * first activates a child Component, this method will return whatever was configured in the + * {@link #activeTab} config option. + * @return {BoxComponent} The currently active child Component if one is active, or the {@link #activeTab} config value. */ - centerFrame: false, + getActiveTab : function(){ + return this.activeTab || null; + }, /** - * Creates the proxy element if it does not yet exist - * @method createFrame + * Gets the specified tab by id. + * @param {String} id The tab id + * @return {Panel} The tab */ - createFrame: function() { - var self = this; - var body = document.body; + getItem : function(item){ + return this.getComponent(item); + }, - if (!body || !body.firstChild) { - setTimeout( function() { self.createFrame(); }, 50 ); + // private + autoScrollTabs : function(){ + this.pos = this.tabPosition=='bottom' ? this.footer : this.header; + var count = this.items.length, + ow = this.pos.dom.offsetWidth, + tw = this.pos.dom.clientWidth, + wrap = this.stripWrap, + wd = wrap.dom, + cw = wd.offsetWidth, + pos = this.getScrollPos(), + l = this.edge.getOffsetsTo(this.stripWrap)[0] + pos; + + if(!this.enableTabScroll || count < 1 || cw < 20){ // 20 to prevent display:none issues return; } + if(l <= tw){ + wd.scrollLeft = 0; + wrap.setWidth(tw); + if(this.scrolling){ + this.scrolling = false; + this.pos.removeClass('x-tab-scrolling'); + this.scrollLeft.hide(); + this.scrollRight.hide(); + // See here: http://extjs.com/forum/showthread.php?t=49308&highlight=isSafari + if(Ext.isAir || Ext.isWebKit){ + wd.style.marginLeft = ''; + wd.style.marginRight = ''; + } + } + }else{ + if(!this.scrolling){ + this.pos.addClass('x-tab-scrolling'); + // See here: http://extjs.com/forum/showthread.php?t=49308&highlight=isSafari + if(Ext.isAir || Ext.isWebKit){ + wd.style.marginLeft = '18px'; + wd.style.marginRight = '18px'; + } + } + tw -= wrap.getMargins('lr'); + wrap.setWidth(tw > 20 ? tw : 20); + if(!this.scrolling){ + if(!this.scrollLeft){ + this.createScrollers(); + }else{ + this.scrollLeft.show(); + this.scrollRight.show(); + } + } + this.scrolling = true; + if(pos > (l-tw)){ // ensure it stays within bounds + wd.scrollLeft = l-tw; + }else{ // otherwise, make sure the active tab is still visible + this.scrollToTab(this.activeTab, false); + } + this.updateScrollButtons(); + } + }, - var div = this.getDragEl(); + // private + createScrollers : function(){ + this.pos.addClass('x-tab-scrolling-' + this.tabPosition); + var h = this.stripWrap.dom.offsetHeight; - if (!div) { - div = document.createElement("div"); - div.id = this.dragElId; - var s = div.style; + // left + var sl = this.pos.insertFirst({ + cls:'x-tab-scroller-left' + }); + sl.setHeight(h); + sl.addClassOnOver('x-tab-scroller-left-over'); + this.leftRepeater = new Ext.util.ClickRepeater(sl, { + interval : this.scrollRepeatInterval, + handler: this.onScrollLeft, + scope: this + }); + this.scrollLeft = sl; - s.position = "absolute"; - s.visibility = "hidden"; - s.cursor = "move"; - s.border = "2px solid #aaa"; - s.zIndex = 999; + // right + var sr = this.pos.insertFirst({ + cls:'x-tab-scroller-right' + }); + sr.setHeight(h); + sr.addClassOnOver('x-tab-scroller-right-over'); + this.rightRepeater = new Ext.util.ClickRepeater(sr, { + interval : this.scrollRepeatInterval, + handler: this.onScrollRight, + scope: this + }); + this.scrollRight = sr; + }, - // appendChild can blow up IE if invoked prior to the window load event - // while rendering a table. It is possible there are other scenarios - // that would cause this to happen as well. - body.insertBefore(div, body.firstChild); - } + // private + getScrollWidth : function(){ + return this.edge.getOffsetsTo(this.stripWrap)[0] + this.getScrollPos(); }, - /** - * Initialization for the drag frame element. Must be called in the - * constructor of all subclasses - * @method initFrame - */ - initFrame: function() { - this.createFrame(); + // private + getScrollPos : function(){ + return parseInt(this.stripWrap.dom.scrollLeft, 10) || 0; }, - applyConfig: function() { - Ext.dd.DDProxy.superclass.applyConfig.call(this); + // private + getScrollArea : function(){ + return parseInt(this.stripWrap.dom.clientWidth, 10) || 0; + }, - this.resizeFrame = (this.config.resizeFrame !== false); - this.centerFrame = (this.config.centerFrame); - this.setDragElId(this.config.dragElId || Ext.dd.DDProxy.dragElId); + // private + getScrollAnim : function(){ + return {duration:this.scrollDuration, callback: this.updateScrollButtons, scope: this}; + }, + + // private + getScrollIncrement : function(){ + return this.scrollIncrement || (this.resizeTabs ? this.lastTabWidth+2 : 100); }, /** - * Resizes the drag frame to the dimensions of the clicked object, positions - * it over the object, and finally displays it - * @method showFrame - * @param {int} iPageX X click position - * @param {int} iPageY Y click position - * @private + * Scrolls to a particular tab if tab scrolling is enabled + * @param {Panel} item The item to scroll to + * @param {Boolean} animate True to enable animations */ - showFrame: function(iPageX, iPageY) { - var el = this.getEl(); - var dragEl = this.getDragEl(); - var s = dragEl.style; - - this._resizeProxy(); - if (this.centerFrame) { - this.setDelta( Math.round(parseInt(s.width, 10)/2), - Math.round(parseInt(s.height, 10)/2) ); + scrollToTab : function(item, animate){ + if(!item){ + return; + } + var el = this.getTabEl(item), + pos = this.getScrollPos(), + area = this.getScrollArea(), + left = Ext.fly(el).getOffsetsTo(this.stripWrap)[0] + pos, + right = left + el.offsetWidth; + if(left < pos){ + this.scrollTo(left, animate); + }else if(right > (pos + area)){ + this.scrollTo(right - area, animate); } - - this.setDragElPos(iPageX, iPageY); - - Ext.fly(dragEl).show(); }, - /** - * The proxy is automatically resized to the dimensions of the linked - * element when a drag is initiated, unless resizeFrame is set to false - * @method _resizeProxy - * @private - */ - _resizeProxy: function() { - if (this.resizeFrame) { - var el = this.getEl(); - Ext.fly(this.getDragEl()).setSize(el.offsetWidth, el.offsetHeight); + // private + scrollTo : function(pos, animate){ + this.stripWrap.scrollTo('left', pos, animate ? this.getScrollAnim() : false); + if(!animate){ + this.updateScrollButtons(); } }, - // overrides Ext.dd.DragDrop - b4MouseDown: function(e) { - var x = e.getPageX(); - var y = e.getPageY(); - this.autoOffset(x, y); - this.setDragElPos(x, y); - }, + onWheel : function(e){ + var d = e.getWheelDelta()*this.wheelIncrement*-1; + e.stopEvent(); - // overrides Ext.dd.DragDrop - b4StartDrag: function(x, y) { - // show the drag frame - this.showFrame(x, y); - }, + var pos = this.getScrollPos(), + newpos = pos + d, + sw = this.getScrollWidth()-this.getScrollArea(); - // overrides Ext.dd.DragDrop - b4EndDrag: function(e) { - Ext.fly(this.getDragEl()).hide(); + var s = Math.max(0, Math.min(sw, newpos)); + if(s != pos){ + this.scrollTo(s, false); + } }, - // overrides Ext.dd.DragDrop - // By default we try to move the element to the last location of the frame. - // This is so that the default behavior mirrors that of Ext.dd.DD. - endDrag: function(e) { - - var lel = this.getEl(); - var del = this.getDragEl(); - - // Show the drag frame briefly so we can get its position - del.style.visibility = ""; - - this.beforeMove(); - // Hide the linked element before the move to get around a Safari - // rendering bug. - lel.style.visibility = "hidden"; - Ext.dd.DDM.moveToEl(lel, del); - del.style.visibility = "hidden"; - lel.style.visibility = ""; - - this.afterDrag(); + // private + onScrollRight : function(){ + var sw = this.getScrollWidth()-this.getScrollArea(), + pos = this.getScrollPos(), + s = Math.min(sw, pos + this.getScrollIncrement()); + if(s != pos){ + this.scrollTo(s, this.animScroll); + } }, - beforeMove : function(){ - + // private + onScrollLeft : function(){ + var pos = this.getScrollPos(), + s = Math.max(0, pos - this.getScrollIncrement()); + if(s != pos){ + this.scrollTo(s, this.animScroll); + } }, - afterDrag : function(){ - + // private + updateScrollButtons : function(){ + var pos = this.getScrollPos(); + this.scrollLeft[pos === 0 ? 'addClass' : 'removeClass']('x-tab-scroller-left-disabled'); + this.scrollRight[pos >= (this.getScrollWidth()-this.getScrollArea()) ? 'addClass' : 'removeClass']('x-tab-scroller-right-disabled'); }, - toString: function() { - return ("DDProxy " + this.id); - } - -}); -/** - * @class Ext.dd.DDTarget - * A DragDrop implementation that does not move, but can be a drop - * target. You would get the same result by simply omitting implementation - * for the event callbacks, but this way we reduce the processing cost of the - * event listener and the callbacks. - * @extends Ext.dd.DragDrop - * @constructor - * @param {String} id the id of the element that is a drop target - * @param {String} sGroup the group of related DragDrop objects - * @param {object} config an object containing configurable attributes - * Valid properties for DDTarget in addition to those in - * DragDrop: - * none - */ -Ext.dd.DDTarget = function(id, sGroup, config) { - if (id) { - this.initTarget(id, sGroup, config); + // private + beforeDestroy : function() { + Ext.destroy(this.leftRepeater, this.rightRepeater); + this.deleteMembers('strip', 'edge', 'scrollLeft', 'scrollRight', 'stripWrap'); + this.activeTab = null; + Ext.TabPanel.superclass.beforeDestroy.apply(this); } -}; -// Ext.dd.DDTarget.prototype = new Ext.dd.DragDrop(); -Ext.extend(Ext.dd.DDTarget, Ext.dd.DragDrop, { /** + * @cfg {Boolean} collapsible * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - getDragEl: Ext.emptyFn, /** + * @cfg {String} header * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - isValidHandleChild: Ext.emptyFn, /** + * @cfg {Boolean} headerAsText * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - startDrag: Ext.emptyFn, /** + * @property header * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - endDrag: Ext.emptyFn, /** + * @cfg title * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onDrag: Ext.emptyFn, /** + * @cfg {Array} tools * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onDragDrop: Ext.emptyFn, /** + * @cfg {Array} toolTemplate * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onDragEnter: Ext.emptyFn, /** + * @cfg {Boolean} hideCollapseTool * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onDragOut: Ext.emptyFn, /** + * @cfg {Boolean} titleCollapse * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onDragOver: Ext.emptyFn, /** + * @cfg {Boolean} collapsed * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onInvalidDrop: Ext.emptyFn, /** + * @cfg {String} layout * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onMouseDown: Ext.emptyFn, /** + * @cfg {Boolean} preventBodyReset * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method */ - onMouseUp: Ext.emptyFn, +}); +Ext.reg('tabpanel', Ext.TabPanel); + +/** + * See {@link #setActiveTab}. Sets the specified tab as the active tab. This method fires + * the {@link #beforetabchange} event which can return false to cancel the tab change. + * @param {String/Panel} tab The id or tab Panel to activate + * @method activate + */ +Ext.TabPanel.prototype.activate = Ext.TabPanel.prototype.setActiveTab; + +// private utility class used by TabPanel +Ext.TabPanel.AccessStack = function(){ + var items = []; + return { + add : function(item){ + items.push(item); + if(items.length > 10){ + items.shift(); + } + }, + + remove : function(item){ + var s = []; + for(var i = 0, len = items.length; i < len; i++) { + if(items[i] != item){ + s.push(items[i]); + } + } + items = s; + }, + + next : function(){ + return items.pop(); + } + }; +}; +/** + * @class Ext.Button + * @extends Ext.BoxComponent + * Simple Button class + * @cfg {String} text The button text to be used as innerHTML (html tags are accepted) + * @cfg {String} icon The path to an image to display in the button (the image will be set as the background-image + * CSS property of the button by default, so if you want a mixed icon/text button, set cls:'x-btn-text-icon') + * @cfg {Function} handler A function called when the button is clicked (can be used instead of click event). + * The handler is passed the following parameters:
+ *
b : Button
This Button.
+ *
e : EventObject
The click event.
+ *
+ * @cfg {Number} minWidth The minimum width for this button (used to give a set of buttons a common width). + * See also {@link Ext.Panel}.{@link Ext.Panel#minButtonWidth minButtonWidth}. + * @cfg {String/Object} tooltip The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config object + * @cfg {Boolean} hidden True to start hidden (defaults to false) + * @cfg {Boolean} disabled True to start disabled (defaults to false) + * @cfg {Boolean} pressed True to start pressed (only if enableToggle = true) + * @cfg {String} toggleGroup The group this toggle button is a member of (only 1 per group can be pressed) + * @cfg {Boolean/Object} repeat True to repeat fire the click event while the mouse is down. This can also be + * a {@link Ext.util.ClickRepeater ClickRepeater} config object (defaults to false). + * @constructor + * Create a new button + * @param {Object} config The config object + * @xtype button + */ +Ext.Button = Ext.extend(Ext.BoxComponent, { /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Read-only. True if this button is hidden + * @type Boolean */ - setXConstraint: Ext.emptyFn, + hidden : false, /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Read-only. True if this button is disabled + * @type Boolean */ - setYConstraint: Ext.emptyFn, + disabled : false, /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Read-only. True if this button is pressed (only if enableToggle = true) + * @type Boolean */ - resetConstraints: Ext.emptyFn, + pressed : false, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {Number} tabIndex Set a DOM tabIndex for this button (defaults to undefined) */ - clearConstraints: Ext.emptyFn, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {Boolean} allowDepress + * False to not allow a pressed Button to be depressed (defaults to undefined). Only valid when {@link #enableToggle} is true. */ - clearTicks: Ext.emptyFn, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {Boolean} enableToggle + * True to enable pressed/not pressed toggling (defaults to false) */ - setInitPosition: Ext.emptyFn, + enableToggle : false, /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {Function} toggleHandler + * Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed:
+ *
button : Ext.Button
this Button object
+ *
state : Boolean
The next state of the Button, true means pressed.
+ *
*/ - setDragElId: Ext.emptyFn, /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {Mixed} menu + * Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined). */ - setHandleElId: Ext.emptyFn, /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {String} menuAlign + * The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?'). */ - setOuterHandleElId: Ext.emptyFn, + menuAlign : 'tl-bl?', + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * @cfg {String} overflowText If used in a {@link Ext.Toolbar Toolbar}, the + * text to be used if this item is shown in the overflow menu. See also + * {@link Ext.Toolbar.Item}.{@link Ext.Toolbar.Item#overflowText overflowText}. + */ + /** + * @cfg {String} iconCls + * A css class which sets a background image to be used as the icon for this button + */ + /** + * @cfg {String} type + * submit, reset or button - defaults to 'button' + */ + type : 'button', + + // private + menuClassTarget : 'tr:nth(2)', + + /** + * @cfg {String} clickEvent + * The DOM event that will fire the handler of the button. This can be any valid event name (dblclick, contextmenu). + * Defaults to 'click'. + */ + clickEvent : 'click', + + /** + * @cfg {Boolean} handleMouseEvents + * False to disable visual cues on mouseover, mouseout and mousedown (defaults to true) + */ + handleMouseEvents : true, + + /** + * @cfg {String} tooltipType + * The type of tooltip to use. Either 'qtip' (default) for QuickTips or 'title' for title attribute. + */ + tooltipType : 'qtip', + + /** + * @cfg {String} buttonSelector + *
(Optional) A {@link Ext.DomQuery DomQuery} selector which is used to extract the active, clickable element from the + * DOM structure created.
+ *
When a custom {@link #template} is used, you must ensure that this selector results in the selection of + * a focussable element.
+ *
Defaults to 'button:first-child'.
+ */ + buttonSelector : 'button:first-child', + + /** + * @cfg {String} scale + *
(Optional) The size of the Button. Three values are allowed:
+ *
+ *
'small'
Results in the button element being 16px high.
+ *
'medium'
Results in the button element being 24px high.
+ *
'large'
Results in the button element being 32px high.
+ *
+ *
Defaults to 'small'.
+ */ + scale : 'small', + + /** + * @cfg {Object} scope The scope (this reference) in which the + * {@link #handler} and {@link #toggleHandler} is + * executed. Defaults to this Button. + */ + + /** + * @cfg {String} iconAlign + *
(Optional) The side of the Button box to render the icon. Four values are allowed:
+ *
+ *
'top'
+ *
'right'
+ *
'bottom'
+ *
'left'
+ *
+ *
Defaults to 'left'.
+ */ + iconAlign : 'left', + + /** + * @cfg {String} arrowAlign + *
(Optional) The side of the Button box to render the arrow if the button has an associated {@link #menu}. + * Two values are allowed:
+ *
+ *
'right'
+ *
'bottom'
+ *
+ *
Defaults to 'right'.
+ */ + arrowAlign : 'right', + + /** + * @cfg {Ext.Template} template (Optional) + *
A {@link Ext.Template Template} used to create the Button's DOM structure.
+ * Instances, or subclasses which need a different DOM structure may provide a different + * template layout in conjunction with an implementation of {@link #getTemplateArgs}. + * @type Ext.Template + * @property template + */ + /** + * @cfg {String} cls + * A CSS class string to apply to the button's main element. + */ + /** + * @property menu + * @type Menu + * The {@link Ext.menu.Menu Menu} object associated with this Button when configured with the {@link #menu} config option. + */ + + initComponent : function(){ + Ext.Button.superclass.initComponent.call(this); + + this.addEvents( + /** + * @event click + * Fires when this button is clicked + * @param {Button} this + * @param {EventObject} e The click event + */ + 'click', + /** + * @event toggle + * Fires when the 'pressed' state of this button changes (only if enableToggle = true) + * @param {Button} this + * @param {Boolean} pressed + */ + 'toggle', + /** + * @event mouseover + * Fires when the mouse hovers over the button + * @param {Button} this + * @param {Event} e The event object + */ + 'mouseover', + /** + * @event mouseout + * Fires when the mouse exits the button + * @param {Button} this + * @param {Event} e The event object + */ + 'mouseout', + /** + * @event menushow + * If this button has a menu, this event fires when it is shown + * @param {Button} this + * @param {Menu} menu + */ + 'menushow', + /** + * @event menuhide + * If this button has a menu, this event fires when it is hidden + * @param {Button} this + * @param {Menu} menu + */ + 'menuhide', + /** + * @event menutriggerover + * If this button has a menu, this event fires when the mouse enters the menu triggering element + * @param {Button} this + * @param {Menu} menu + * @param {EventObject} e + */ + 'menutriggerover', + /** + * @event menutriggerout + * If this button has a menu, this event fires when the mouse leaves the menu triggering element + * @param {Button} this + * @param {Menu} menu + * @param {EventObject} e + */ + 'menutriggerout' + ); + if(this.menu){ + this.menu = Ext.menu.MenuMgr.get(this.menu); + } + if(Ext.isString(this.toggleGroup)){ + this.enableToggle = true; + } + }, + +/** + *
This method returns an Array which provides substitution parameters for the {@link #template Template} used + * to create this Button's DOM structure.
+ *
Instances or subclasses which use a different Template to create a different DOM structure may need to provide their + * own implementation of this method.
+ *
The default implementation which provides data for the default {@link #template} returns an Array containing the + * following items:
+ *
The <button>'s {@link #type}
+ *
A CSS class name applied to the Button's main <tbody> element which determines the button's scale and icon alignment.
+ *
A CSS class to determine the presence and position of an arrow icon. ('x-btn-arrow' or 'x-btn-arrow-bottom' or '')
+ *
The {@link #cls} CSS class name applied to the button's wrapping <table> element.
+ *
The Component id which is applied to the button's wrapping <table> element.
+ *
+ * @return {Array} Substitution data for a Template. + */ + getTemplateArgs : function(){ + return [this.type, 'x-btn-' + this.scale + ' x-btn-icon-' + this.scale + '-' + this.iconAlign, this.getMenuClass(), this.cls, this.id]; + }, + + // private + setButtonClass : function(){ + if(this.useSetClass){ + if(!Ext.isEmpty(this.oldCls)){ + this.el.removeClass([this.oldCls, 'x-btn-pressed']); + } + this.oldCls = (this.iconCls || this.icon) ? (this.text ? ' x-btn-text-icon' : ' x-btn-icon') : ' x-btn-noicon'; + this.el.addClass([this.oldCls, this.pressed ? 'x-btn-pressed' : null]); + } + }, + + // protected + getMenuClass : function(){ + return this.menu ? (this.arrowAlign != 'bottom' ? 'x-btn-arrow' : 'x-btn-arrow-bottom') : ''; + }, + + // private + onRender : function(ct, position){ + if(!this.template){ + if(!Ext.Button.buttonTemplate){ + // hideous table template + Ext.Button.buttonTemplate = new Ext.Template( + '', + '', + '', + '', + '

'); + Ext.Button.buttonTemplate.compile(); + } + this.template = Ext.Button.buttonTemplate; + } + + var btn, targs = this.getTemplateArgs(); + + if(position){ + btn = this.template.insertBefore(position, targs, true); + }else{ + btn = this.template.append(ct, targs, true); + } + /** + * An {@link Ext.Element Element} encapsulating the Button's clickable element. By default, + * this references a <button> element. Read only. + * @type Ext.Element + * @property btnEl + */ + this.btnEl = btn.child(this.buttonSelector); + this.mon(this.btnEl, { + scope: this, + focus: this.onFocus, + blur: this.onBlur + }); + + this.initButtonEl(btn, this.btnEl); + + Ext.ButtonToggleMgr.register(this); + }, + + // private + initButtonEl : function(btn, btnEl){ + this.el = btn; + this.setIcon(this.icon); + this.setText(this.text); + this.setIconClass(this.iconCls); + if(Ext.isDefined(this.tabIndex)){ + btnEl.dom.tabIndex = this.tabIndex; + } + if(this.tooltip){ + this.setTooltip(this.tooltip, true); + } + + if(this.handleMouseEvents){ + this.mon(btn, { + scope: this, + mouseover: this.onMouseOver, + mousedown: this.onMouseDown + }); + + // new functionality for monitoring on the document level + //this.mon(btn, 'mouseout', this.onMouseOut, this); + } + + if(this.menu){ + this.mon(this.menu, { + scope: this, + show: this.onMenuShow, + hide: this.onMenuHide + }); + } + + if(this.repeat){ + var repeater = new Ext.util.ClickRepeater(btn, Ext.isObject(this.repeat) ? this.repeat : {}); + this.mon(repeater, 'click', this.onClick, this); + } + this.mon(btn, this.clickEvent, this.onClick, this); + }, + + // private + afterRender : function(){ + Ext.Button.superclass.afterRender.call(this); + this.useSetClass = true; + this.setButtonClass(); + this.doc = Ext.getDoc(); + this.doAutoWidth(); + }, + + /** + * Sets the CSS class that provides a background image to use as the button's icon. This method also changes + * the value of the {@link iconCls} config internally. + * @param {String} cls The CSS class providing the icon image + * @return {Ext.Button} this + */ + setIconClass : function(cls){ + this.iconCls = cls; + if(this.el){ + this.btnEl.dom.className = ''; + this.btnEl.addClass(['x-btn-text', cls || '']); + this.setButtonClass(); + } + return this; + }, + + /** + * Sets the tooltip for this Button. + * @param {String/Object} tooltip. This may be:
+ *
String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip
+ *
Object : A configuration object for {@link Ext.QuickTips#register}.
+ *
+ * @return {Ext.Button} this */ - addInvalidHandleClass: Ext.emptyFn, + setTooltip : function(tooltip, /* private */ initial){ + if(this.rendered){ + if(!initial){ + this.clearTip(); + } + if(Ext.isObject(tooltip)){ + Ext.QuickTips.register(Ext.apply({ + target: this.btnEl.id + }, tooltip)); + this.tooltip = tooltip; + }else{ + this.btnEl.dom[this.tooltipType] = tooltip; + } + }else{ + this.tooltip = tooltip; + } + return this; + }, + + // private + clearTip : function(){ + if(Ext.isObject(this.tooltip)){ + Ext.QuickTips.unregister(this.btnEl); + } + }, + + // private + beforeDestroy : function(){ + if(this.rendered){ + this.clearTip(); + } + if(this.menu && this.destroyMenu !== false) { + Ext.destroy(this.menu); + } + Ext.destroy(this.repeater); + }, + + // private + onDestroy : function(){ + if(this.rendered){ + this.doc.un('mouseover', this.monitorMouseOver, this); + this.doc.un('mouseup', this.onMouseUp, this); + delete this.doc; + delete this.btnEl; + Ext.ButtonToggleMgr.unregister(this); + } + Ext.Button.superclass.onDestroy.call(this); + }, + + // private + doAutoWidth : function(){ + if(this.el && this.text && this.width === undefined){ + this.el.setWidth('auto'); + if(Ext.isIE7 && Ext.isStrict){ + var ib = this.btnEl; + if(ib && ib.getWidth() > 20){ + ib.clip(); + ib.setWidth(Ext.util.TextMetrics.measure(ib, this.text).width+ib.getFrameWidth('lr')); + } + } + if(this.minWidth){ + if(this.el.getWidth() < this.minWidth){ + this.el.setWidth(this.minWidth); + } + } + } + }, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Assigns this Button's click handler + * @param {Function} handler The function to call when the button is clicked + * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed. + * Defaults to this Button. + * @return {Ext.Button} this */ - addInvalidHandleId: Ext.emptyFn, + setHandler : function(handler, scope){ + this.handler = handler; + this.scope = scope; + return this; + }, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Sets this Button's text + * @param {String} text The button text + * @return {Ext.Button} this */ - addInvalidHandleType: Ext.emptyFn, + setText : function(text){ + this.text = text; + if(this.el){ + this.btnEl.update(text || ' '); + this.setButtonClass(); + } + this.doAutoWidth(); + return this; + }, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Sets the background image (inline style) of the button. This method also changes + * the value of the {@link icon} config internally. + * @param {String} icon The path to an image to display in the button + * @return {Ext.Button} this */ - removeInvalidHandleClass: Ext.emptyFn, + setIcon : function(icon){ + this.icon = icon; + if(this.el){ + this.btnEl.setStyle('background-image', icon ? 'url(' + icon + ')' : ''); + this.setButtonClass(); + } + return this; + }, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * Gets the text for this Button + * @return {String} The button text */ - removeInvalidHandleId: Ext.emptyFn, + getText : function(){ + return this.text; + }, + /** - * @hide - * Overridden and disabled. A DDTarget does not support being dragged. - * @method + * If a state it passed, it becomes the pressed state otherwise the current state is toggled. + * @param {Boolean} state (optional) Force a particular state + * @param {Boolean} supressEvent (optional) True to stop events being fired when calling this method. + * @return {Ext.Button} this */ - removeInvalidHandleType: Ext.emptyFn, + toggle : function(state, suppressEvent){ + state = state === undefined ? !this.pressed : !!state; + if(state != this.pressed){ + if(this.rendered){ + this.el[state ? 'addClass' : 'removeClass']('x-btn-pressed'); + } + this.pressed = state; + if(!suppressEvent){ + this.fireEvent('toggle', this, state); + if(this.toggleHandler){ + this.toggleHandler.call(this.scope || this, this, state); + } + } + } + return this; + }, - toString: function() { - return ("DDTarget " + this.id); - } -});/** - * @class Ext.dd.DragTracker - * @extends Ext.util.Observable - */ -Ext.dd.DragTracker = Ext.extend(Ext.util.Observable, { - /** - * @cfg {Boolean} active - * Defaults to false. - */ - active: false, - /** - * @cfg {Number} tolerance - * Defaults to 5. - */ - tolerance: 5, - /** - * @cfg {Boolean/Number} autoStart - * Defaults to false. Specify true to defer trigger start by 1000 ms. - * Specify a Number for the number of milliseconds to defer trigger start. - */ - autoStart: false, - - constructor : function(config){ - Ext.apply(this, config); - this.addEvents( - /** - * @event mousedown - * @param {Object} this - * @param {Object} e event object - */ - 'mousedown', - /** - * @event mouseup - * @param {Object} this - * @param {Object} e event object - */ - 'mouseup', - /** - * @event mousemove - * @param {Object} this - * @param {Object} e event object - */ - 'mousemove', - /** - * @event dragstart - * @param {Object} this - * @param {Object} startXY the page coordinates of the event - */ - 'dragstart', - /** - * @event dragend - * @param {Object} this - * @param {Object} e event object - */ - 'dragend', - /** - * @event drag - * @param {Object} this - * @param {Object} e event object - */ - 'drag' - ); - - this.dragRegion = new Ext.lib.Region(0,0,0,0); - - if(this.el){ - this.initEl(this.el); - } - Ext.dd.DragTracker.superclass.constructor.call(this, config); - }, - - initEl: function(el){ - this.el = Ext.get(el); - el.on('mousedown', this.onMouseDown, this, - this.delegate ? {delegate: this.delegate} : undefined); - }, - - destroy : function(){ - this.el.un('mousedown', this.onMouseDown, this); - }, - - onMouseDown: function(e, target){ - if(this.fireEvent('mousedown', this, e) !== false && this.onBeforeStart(e) !== false){ - this.startXY = this.lastXY = e.getXY(); - this.dragTarget = this.delegate ? target : this.el.dom; - if(this.preventDefault !== false){ - e.preventDefault(); - } - var doc = Ext.getDoc(); - doc.on('mouseup', this.onMouseUp, this); - doc.on('mousemove', this.onMouseMove, this); - doc.on('selectstart', this.stopSelect, this); - if(this.autoStart){ - this.timer = this.triggerStart.defer(this.autoStart === true ? 1000 : this.autoStart, this); - } - } - }, - - onMouseMove: function(e, target){ - // HACK: IE hack to see if button was released outside of window. */ - if(this.active && Ext.isIE && !e.browserEvent.button){ - e.preventDefault(); - this.onMouseUp(e); - return; - } - - e.preventDefault(); - var xy = e.getXY(), s = this.startXY; - this.lastXY = xy; - if(!this.active){ - if(Math.abs(s[0]-xy[0]) > this.tolerance || Math.abs(s[1]-xy[1]) > this.tolerance){ - this.triggerStart(); - }else{ - return; - } - } - this.fireEvent('mousemove', this, e); - this.onDrag(e); - this.fireEvent('drag', this, e); - }, - - onMouseUp: function(e){ - var doc = Ext.getDoc(); - doc.un('mousemove', this.onMouseMove, this); - doc.un('mouseup', this.onMouseUp, this); - doc.un('selectstart', this.stopSelect, this); - e.preventDefault(); - this.clearStart(); - var wasActive = this.active; - this.active = false; - delete this.elRegion; - this.fireEvent('mouseup', this, e); - if(wasActive){ - this.onEnd(e); - this.fireEvent('dragend', this, e); - } - }, - - triggerStart: function(isTimer){ - this.clearStart(); - this.active = true; - this.onStart(this.startXY); - this.fireEvent('dragstart', this, this.startXY); - }, - - clearStart : function(){ - if(this.timer){ - clearTimeout(this.timer); - delete this.timer; - } - }, - - stopSelect : function(e){ - e.stopEvent(); - return false; - }, - - onBeforeStart : function(e){ - - }, - - onStart : function(xy){ - - }, - - onDrag : function(e){ - - }, - - onEnd : function(e){ - - }, - - getDragTarget : function(){ - return this.dragTarget; - }, - - getDragCt : function(){ - return this.el; - }, - - getXY : function(constrain){ - return constrain ? - this.constrainModes[constrain].call(this, this.lastXY) : this.lastXY; - }, - - getOffset : function(constrain){ - var xy = this.getXY(constrain); - var s = this.startXY; - return [s[0]-xy[0], s[1]-xy[1]]; - }, - - constrainModes: { - 'point' : function(xy){ - - if(!this.elRegion){ - this.elRegion = this.getDragCt().getRegion(); - } - - var dr = this.dragRegion; - - dr.left = xy[0]; - dr.top = xy[1]; - dr.right = xy[0]; - dr.bottom = xy[1]; - - dr.constrainTo(this.elRegion); - - return [dr.left, dr.top]; - } - } -});/** - * @class Ext.dd.ScrollManager - *
Provides automatic scrolling of overflow regions in the page during drag operations.
- *
The ScrollManager configs will be used as the defaults for any scroll container registered with it, - * but you can also override most of the configs per scroll container by adding a - * ddScrollConfig object to the target element that contains these properties: {@link #hthresh}, - * {@link #vthresh}, {@link #increment} and {@link #frequency}. Example usage: - *
-var el = Ext.get('scroll-ct'); -el.ddScrollConfig = { - vthresh: 50, - hthresh: -1, - frequency: 100, - increment: 200 -}; -Ext.dd.ScrollManager.register(el); -
- * Note: This class uses "Point Mode" and is untested in "Intersect Mode". - * @singleton - */ -Ext.dd.ScrollManager = function(){ - var ddm = Ext.dd.DragDropMgr; - var els = {}; - var dragEl = null; - var proc = {}; - - var onStop = function(e){ - dragEl = null; - clearProc(); - }; - - var triggerRefresh = function(){ - if(ddm.dragCurrent){ - ddm.refreshCache(ddm.dragCurrent.groups); - } - }; - - var doScroll = function(){ - if(ddm.dragCurrent){ - var dds = Ext.dd.ScrollManager; - var inc = proc.el.ddScrollConfig ? - proc.el.ddScrollConfig.increment : dds.increment; - if(!dds.animate){ - if(proc.el.scroll(proc.dir, inc)){ - triggerRefresh(); - } - }else{ - proc.el.scroll(proc.dir, inc, true, dds.animDuration, triggerRefresh); - } - } - }; - - var clearProc = function(){ - if(proc.id){ - clearInterval(proc.id); - } - proc.id = 0; - proc.el = null; - proc.dir = ""; - }; - - var startProc = function(el, dir){ - clearProc(); - proc.el = el; - proc.dir = dir; - var freq = (el.ddScrollConfig && el.ddScrollConfig.frequency) ? - el.ddScrollConfig.frequency : Ext.dd.ScrollManager.frequency; - proc.id = setInterval(doScroll, freq); - }; - - var onFire = function(e, isDrop){ - if(isDrop || !ddm.dragCurrent){ return; } - var dds = Ext.dd.ScrollManager; - if(!dragEl || dragEl != ddm.dragCurrent){ - dragEl = ddm.dragCurrent; - // refresh regions on drag start - dds.refreshCache(); - } - - var xy = Ext.lib.Event.getXY(e); - var pt = new Ext.lib.Point(xy[0], xy[1]); - for(var id in els){ - var el = els[id], r = el._region; - var c = el.ddScrollConfig ? el.ddScrollConfig : dds; - if(r && r.contains(pt) && el.isScrollable()){ - if(r.bottom - pt.y <= c.vthresh){ - if(proc.el != el){ - startProc(el, "down"); - } - return; - }else if(r.right - pt.x <= c.hthresh){ - if(proc.el != el){ - startProc(el, "left"); - } - return; - }else if(pt.y - r.top <= c.vthresh){ - if(proc.el != el){ - startProc(el, "up"); - } - return; - }else if(pt.x - r.left <= c.hthresh){ - if(proc.el != el){ - startProc(el, "right"); - } - return; - } - } - } - clearProc(); - }; - - ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm); - ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm); - - return { - /** - * Registers new overflow element(s) to auto scroll - * @param {Mixed/Array} el The id of or the element to be scrolled or an array of either - */ - register : function(el){ - if(Ext.isArray(el)){ - for(var i = 0, len = el.length; i < len; i++) { - this.register(el[i]); - } - }else{ - el = Ext.get(el); - els[el.id] = el; - } - }, - - /** - * Unregisters overflow element(s) so they are no longer scrolled - * @param {Mixed/Array} el The id of or the element to be removed or an array of either - */ - unregister : function(el){ - if(Ext.isArray(el)){ - for(var i = 0, len = el.length; i < len; i++) { - this.unregister(el[i]); - } - }else{ - el = Ext.get(el); - delete els[el.id]; - } - }, - - /** - * The number of pixels from the top or bottom edge of a container the pointer needs to be to - * trigger scrolling (defaults to 25) - * @type Number - */ - vthresh : 25, - /** - * The number of pixels from the right or left edge of a container the pointer needs to be to - * trigger scrolling (defaults to 25) - * @type Number - */ - hthresh : 25, - - /** - * The number of pixels to scroll in each scroll increment (defaults to 50) - * @type Number - */ - increment : 100, - - /** - * The frequency of scrolls in milliseconds (defaults to 500) - * @type Number - */ - frequency : 500, - - /** - * True to animate the scroll (defaults to true) - * @type Boolean - */ - animate: true, - - /** - * The animation duration in seconds - - * MUST BE less than Ext.dd.ScrollManager.frequency! (defaults to .4) - * @type Number - */ - animDuration: .4, - - /** - * Manually trigger a cache refresh. - */ - refreshCache : function(){ - for(var id in els){ - if(typeof els[id] == 'object'){ // for people extending the object prototype - els[id]._region = els[id].getRegion(); - } - } - } - }; -}();/** - * @class Ext.dd.Registry - * Provides easy access to all drag drop components that are registered on a page. Items can be retrieved either - * directly by DOM node id, or by passing in the drag drop event that occurred and looking up the event target. - * @singleton - */ -Ext.dd.Registry = function(){ - var elements = {}; - var handles = {}; - var autoIdSeed = 0; - - var getId = function(el, autogen){ - if(typeof el == "string"){ - return el; - } - var id = el.id; - if(!id && autogen !== false){ - id = "extdd-" + (++autoIdSeed); - el.id = id; - } - return id; - }; - - return { - /** - * Resgister a drag drop element - * @param {String/HTMLElement) element The id or DOM node to register - * @param {Object} data (optional) An custom data object that will be passed between the elements that are involved - * in drag drop operations. You can populate this object with any arbitrary properties that your own code - * knows how to interpret, plus there are some specific properties known to the Registry that should be - * populated in the data object (if applicable): - *
-Value Description
---------- ------------------------------------------
-handles Array of DOM nodes that trigger dragging
- for the element being registered
-isHandle True if the element passed in triggers
- dragging itself, else false -
- */ - register : function(el, data){ - data = data || {}; - if(typeof el == "string"){ - el = document.getElementById(el); - } - data.ddel = el; - elements[getId(el)] = data; - if(data.isHandle !== false){ - handles[data.ddel.id] = data; - } - if(data.handles){ - var hs = data.handles; - for(var i = 0, len = hs.length; i < len; i++){ - handles[getId(hs[i])] = data; - } - } - }, - - /** - * Unregister a drag drop element - * @param {String/HTMLElement) element The id or DOM node to unregister - */ - unregister : function(el){ - var id = getId(el, false); - var data = elements[id]; - if(data){ - delete elements[id]; - if(data.handles){ - var hs = data.handles; - for(var i = 0, len = hs.length; i < len; i++){ - delete handles[getId(hs[i], false)]; - } - } - } - }, - - /** - * Returns the handle registered for a DOM Node by id - * @param {String/HTMLElement} id The DOM node or id to look up - * @return {Object} handle The custom handle data - */ - getHandle : function(id){ - if(typeof id != "string"){ // must be element? - id = id.id; - } - return handles[id]; - }, - - /** - * Returns the handle that is registered for the DOM node that is the target of the event - * @param {Event} e The event - * @return {Object} handle The custom handle data - */ - getHandleFromEvent : function(e){ - var t = Ext.lib.Event.getTarget(e); - return t ? handles[t.id] : null; - }, - - /** - * Returns a custom data object that is registered for a DOM node by id - * @param {String/HTMLElement} id The DOM node or id to look up - * @return {Object} data The custom data - */ - getTarget : function(id){ - if(typeof id != "string"){ // must be element? - id = id.id; - } - return elements[id]; - }, - - /** - * Returns a custom data object that is registered for the DOM node that is the target of the event - * @param {Event} e The event - * @return {Object} data The custom data - */ - getTargetFromEvent : function(e){ - var t = Ext.lib.Event.getTarget(e); - return t ? elements[t.id] || handles[t.id] : null; - } - }; -}();/** - * @class Ext.dd.StatusProxy - * A specialized drag proxy that supports a drop status icon, {@link Ext.Layer} styles and auto-repair. This is the - * default drag proxy used by all Ext.dd components. - * @constructor - * @param {Object} config - */ -Ext.dd.StatusProxy = function(config){ - Ext.apply(this, config); - this.id = this.id || Ext.id(); - this.el = new Ext.Layer({ - dh: { - id: this.id, tag: "div", cls: "x-dd-drag-proxy "+this.dropNotAllowed, children: [ - {tag: "div", cls: "x-dd-drop-icon"}, - {tag: "div", cls: "x-dd-drag-ghost"} - ] - }, - shadow: !config || config.shadow !== false - }); - this.ghost = Ext.get(this.el.dom.childNodes[1]); - this.dropStatus = this.dropNotAllowed; -}; - -Ext.dd.StatusProxy.prototype = { - /** - * @cfg {String} dropAllowed - * The CSS class to apply to the status element when drop is allowed (defaults to "x-dd-drop-ok"). - */ - dropAllowed : "x-dd-drop-ok", - /** - * @cfg {String} dropNotAllowed - * The CSS class to apply to the status element when drop is not allowed (defaults to "x-dd-drop-nodrop"). - */ - dropNotAllowed : "x-dd-drop-nodrop", - - /** - * Updates the proxy's visual element to indicate the status of whether or not drop is allowed - * over the current target element. - * @param {String} cssClass The css class for the new drop status indicator image - */ - setStatus : function(cssClass){ - cssClass = cssClass || this.dropNotAllowed; - if(this.dropStatus != cssClass){ - this.el.replaceClass(this.dropStatus, cssClass); - this.dropStatus = cssClass; - } - }, - - /** - * Resets the status indicator to the default dropNotAllowed value - * @param {Boolean} clearGhost True to also remove all content from the ghost, false to preserve it - */ - reset : function(clearGhost){ - this.el.dom.className = "x-dd-drag-proxy " + this.dropNotAllowed; - this.dropStatus = this.dropNotAllowed; - if(clearGhost){ - this.ghost.update(""); - } - }, - - /** - * Updates the contents of the ghost element - * @param {String/HTMLElement} html The html that will replace the current innerHTML of the ghost element, or a - * DOM node to append as the child of the ghost element (in which case the innerHTML will be cleared first). - */ - update : function(html){ - if(typeof html == "string"){ - this.ghost.update(html); - }else{ - this.ghost.update(""); - html.style.margin = "0"; - this.ghost.dom.appendChild(html); - } - var el = this.ghost.dom.firstChild; - if(el){ - Ext.fly(el).setStyle('float', 'none'); - } - }, - - /** - * Returns the underlying proxy {@link Ext.Layer} - * @return {Ext.Layer} el - */ - getEl : function(){ - return this.el; - }, - - /** - * Returns the ghost element - * @return {Ext.Element} el - */ - getGhost : function(){ - return this.ghost; - }, - - /** - * Hides the proxy - * @param {Boolean} clear True to reset the status and clear the ghost contents, false to preserve them - */ - hide : function(clear){ - this.el.hide(); - if(clear){ - this.reset(true); - } - }, - - /** - * Stops the repair animation if it's currently running - */ - stop : function(){ - if(this.anim && this.anim.isAnimated && this.anim.isAnimated()){ - this.anim.stop(); - } - }, - - /** - * Displays this proxy - */ - show : function(){ - this.el.show(); - }, - - /** - * Force the Layer to sync its shadow and shim positions to the element - */ - sync : function(){ - this.el.sync(); - }, - - /** - * Causes the proxy to return to its position of origin via an animation. Should be called after an - * invalid drop operation by the item being dragged. - * @param {Array} xy The XY position of the element ([x, y]) - * @param {Function} callback The function to call after the repair is complete. - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window. - */ - repair : function(xy, callback, scope){ - this.callback = callback; - this.scope = scope; - if(xy && this.animRepair !== false){ - this.el.addClass("x-dd-drag-repair"); - this.el.hideUnders(true); - this.anim = this.el.shift({ - duration: this.repairDuration || .5, - easing: 'easeOut', - xy: xy, - stopFx: true, - callback: this.afterRepair, - scope: this - }); - }else{ - this.afterRepair(); - } - }, - - // private - afterRepair : function(){ - this.hide(true); - if(typeof this.callback == "function"){ - this.callback.call(this.scope || this); - } - this.callback = null; - this.scope = null; - }, - - destroy: function(){ - Ext.destroy(this.ghost, this.el); - } -};/** - * @class Ext.dd.DragSource - * @extends Ext.dd.DDProxy - * A simple class that provides the basic implementation needed to make any element draggable. - * @constructor - * @param {Mixed} el The container element - * @param {Object} config - */ -Ext.dd.DragSource = function(el, config){ - this.el = Ext.get(el); - if(!this.dragData){ - this.dragData = {}; - } - - Ext.apply(this, config); - - if(!this.proxy){ - this.proxy = new Ext.dd.StatusProxy(); - } - Ext.dd.DragSource.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, - {dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true}); - - this.dragging = false; -}; - -Ext.extend(Ext.dd.DragSource, Ext.dd.DDProxy, { - /** - * @cfg {String} ddGroup - * A named drag drop group to which this object belongs. If a group is specified, then this object will only - * interact with other drag drop objects in the same group (defaults to undefined). - */ - /** - * @cfg {String} dropAllowed - * The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok"). - */ - dropAllowed : "x-dd-drop-ok", - /** - * @cfg {String} dropNotAllowed - * The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop"). - */ - dropNotAllowed : "x-dd-drop-nodrop", - - /** - * Returns the data object associated with this drag source - * @return {Object} data An object containing arbitrary data - */ - getDragData : function(e){ - return this.dragData; - }, - - // private - onDragEnter : function(e, id){ - var target = Ext.dd.DragDropMgr.getDDById(id); - this.cachedTarget = target; - if(this.beforeDragEnter(target, e, id) !== false){ - if(target.isNotifyTarget){ - var status = target.notifyEnter(this, e, this.dragData); - this.proxy.setStatus(status); - }else{ - this.proxy.setStatus(this.dropAllowed); - } - - if(this.afterDragEnter){ - /** - * An empty function by default, but provided so that you can perform a custom action - * when the dragged item enters the drop target by providing an implementation. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @method afterDragEnter - */ - this.afterDragEnter(target, e, id); - } - } - }, - - /** - * An empty function by default, but provided so that you can perform a custom action - * before the dragged item enters the drop target and optionally cancel the onDragEnter. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @return {Boolean} isValid True if the drag event is valid, else false to cancel - */ - beforeDragEnter : function(target, e, id){ - return true; - }, - - // private - alignElWithMouse: function() { - Ext.dd.DragSource.superclass.alignElWithMouse.apply(this, arguments); - this.proxy.sync(); - }, - - // private - onDragOver : function(e, id){ - var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id); - if(this.beforeDragOver(target, e, id) !== false){ - if(target.isNotifyTarget){ - var status = target.notifyOver(this, e, this.dragData); - this.proxy.setStatus(status); - } - - if(this.afterDragOver){ - /** - * An empty function by default, but provided so that you can perform a custom action - * while the dragged item is over the drop target by providing an implementation. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @method afterDragOver - */ - this.afterDragOver(target, e, id); - } - } - }, - - /** - * An empty function by default, but provided so that you can perform a custom action - * while the dragged item is over the drop target and optionally cancel the onDragOver. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @return {Boolean} isValid True if the drag event is valid, else false to cancel - */ - beforeDragOver : function(target, e, id){ - return true; - }, - - // private - onDragOut : function(e, id){ - var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id); - if(this.beforeDragOut(target, e, id) !== false){ - if(target.isNotifyTarget){ - target.notifyOut(this, e, this.dragData); - } - this.proxy.reset(); - if(this.afterDragOut){ - /** - * An empty function by default, but provided so that you can perform a custom action - * after the dragged item is dragged out of the target without dropping. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @method afterDragOut - */ - this.afterDragOut(target, e, id); - } - } - this.cachedTarget = null; - }, - - /** - * An empty function by default, but provided so that you can perform a custom action before the dragged - * item is dragged out of the target without dropping, and optionally cancel the onDragOut. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @return {Boolean} isValid True if the drag event is valid, else false to cancel - */ - beforeDragOut : function(target, e, id){ - return true; - }, - - // private - onDragDrop : function(e, id){ - var target = this.cachedTarget || Ext.dd.DragDropMgr.getDDById(id); - if(this.beforeDragDrop(target, e, id) !== false){ - if(target.isNotifyTarget){ - if(target.notifyDrop(this, e, this.dragData)){ // valid drop? - this.onValidDrop(target, e, id); - }else{ - this.onInvalidDrop(target, e, id); - } - }else{ - this.onValidDrop(target, e, id); - } - - if(this.afterDragDrop){ - /** - * An empty function by default, but provided so that you can perform a custom action - * after a valid drag drop has occurred by providing an implementation. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dropped element - * @method afterDragDrop - */ - this.afterDragDrop(target, e, id); - } - } - delete this.cachedTarget; - }, - - /** - * An empty function by default, but provided so that you can perform a custom action before the dragged - * item is dropped onto the target and optionally cancel the onDragDrop. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @return {Boolean} isValid True if the drag drop event is valid, else false to cancel - */ - beforeDragDrop : function(target, e, id){ - return true; - }, - - // private - onValidDrop : function(target, e, id){ - this.hideProxy(); - if(this.afterValidDrop){ - /** - * An empty function by default, but provided so that you can perform a custom action - * after a valid drop has occurred by providing an implementation. - * @param {Object} target The target DD - * @param {Event} e The event object - * @param {String} id The id of the dropped element - * @method afterInvalidDrop - */ - this.afterValidDrop(target, e, id); - } - }, - - // private - getRepairXY : function(e, data){ - return this.el.getXY(); - }, - - // private - onInvalidDrop : function(target, e, id){ - this.beforeInvalidDrop(target, e, id); - if(this.cachedTarget){ - if(this.cachedTarget.isNotifyTarget){ - this.cachedTarget.notifyOut(this, e, this.dragData); - } - this.cacheTarget = null; - } - this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this); - - if(this.afterInvalidDrop){ - /** - * An empty function by default, but provided so that you can perform a custom action - * after an invalid drop has occurred by providing an implementation. - * @param {Event} e The event object - * @param {String} id The id of the dropped element - * @method afterInvalidDrop - */ - this.afterInvalidDrop(e, id); - } - }, - - // private - afterRepair : function(){ - if(Ext.enableFx){ - this.el.highlight(this.hlColor || "c3daf9"); - } - this.dragging = false; - }, - - /** - * An empty function by default, but provided so that you can perform a custom action after an invalid - * drop has occurred. - * @param {Ext.dd.DragDrop} target The drop target - * @param {Event} e The event object - * @param {String} id The id of the dragged element - * @return {Boolean} isValid True if the invalid drop should proceed, else false to cancel - */ - beforeInvalidDrop : function(target, e, id){ - return true; - }, - - // private - handleMouseDown : function(e){ - if(this.dragging) { - return; - } - var data = this.getDragData(e); - if(data && this.onBeforeDrag(data, e) !== false){ - this.dragData = data; - this.proxy.stop(); - Ext.dd.DragSource.superclass.handleMouseDown.apply(this, arguments); - } - }, - - /** - * An empty function by default, but provided so that you can perform a custom action before the initial - * drag event begins and optionally cancel it. - * @param {Object} data An object containing arbitrary data to be shared with drop targets - * @param {Event} e The event object - * @return {Boolean} isValid True if the drag event is valid, else false to cancel - */ - onBeforeDrag : function(data, e){ - return true; - }, - - /** - * An empty function by default, but provided so that you can perform a custom action once the initial - * drag event has begun. The drag cannot be canceled from this function. - * @param {Number} x The x position of the click on the dragged object - * @param {Number} y The y position of the click on the dragged object - */ - onStartDrag : Ext.emptyFn, - - // private override - startDrag : function(x, y){ - this.proxy.reset(); - this.dragging = true; - this.proxy.update(""); - this.onInitDrag(x, y); - this.proxy.show(); - }, - - // private - onInitDrag : function(x, y){ - var clone = this.el.dom.cloneNode(true); - clone.id = Ext.id(); // prevent duplicate ids - this.proxy.update(clone); - this.onStartDrag(x, y); - return true; - }, - - /** - * Returns the drag source's underlying {@link Ext.dd.StatusProxy} - * @return {Ext.dd.StatusProxy} proxy The StatusProxy - */ - getProxy : function(){ - return this.proxy; - }, - - /** - * Hides the drag source's {@link Ext.dd.StatusProxy} - */ - hideProxy : function(){ - this.proxy.hide(); - this.proxy.reset(true); - this.dragging = false; - }, - - // private - triggerCacheRefresh : function(){ - Ext.dd.DDM.refreshCache(this.groups); - }, - - // private - override to prevent hiding - b4EndDrag: function(e) { - }, - - // private - override to prevent moving - endDrag : function(e){ - this.onEndDrag(this.dragData, e); - }, - - // private - onEndDrag : function(data, e){ - }, - - // private - pin to cursor - autoOffset : function(x, y) { - this.setDelta(-12, -20); - }, - - destroy: function(){ - Ext.dd.DragSource.superclass.destroy.call(this); - Ext.destroy(this.proxy); - } -});/** - * @class Ext.dd.DropTarget - * @extends Ext.dd.DDTarget - * A simple class that provides the basic implementation needed to make any element a drop target that can have - * draggable items dropped onto it. The drop has no effect until an implementation of notifyDrop is provided. - * @constructor - * @param {Mixed} el The container element - * @param {Object} config - */ -Ext.dd.DropTarget = function(el, config){ - this.el = Ext.get(el); - - Ext.apply(this, config); - - if(this.containerScroll){ - Ext.dd.ScrollManager.register(this.el); - } - - Ext.dd.DropTarget.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group, - {isTarget: true}); - -}; - -Ext.extend(Ext.dd.DropTarget, Ext.dd.DDTarget, { - /** - * @cfg {String} ddGroup - * A named drag drop group to which this object belongs. If a group is specified, then this object will only - * interact with other drag drop objects in the same group (defaults to undefined). - */ - /** - * @cfg {String} overClass - * The CSS class applied to the drop target element while the drag source is over it (defaults to ""). - */ - /** - * @cfg {String} dropAllowed - * The CSS class returned to the drag source when drop is allowed (defaults to "x-dd-drop-ok"). - */ - dropAllowed : "x-dd-drop-ok", - /** - * @cfg {String} dropNotAllowed - * The CSS class returned to the drag source when drop is not allowed (defaults to "x-dd-drop-nodrop"). - */ - dropNotAllowed : "x-dd-drop-nodrop", - - // private - isTarget : true, - - // private - isNotifyTarget : true, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the source is now over the - * target. This default implementation adds the CSS class specified by overClass (if any) to the drop element - * and returns the dropAllowed config value. This method should be overridden if drop validation is required. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - notifyEnter : function(dd, e, data){ - if(this.overClass){ - this.el.addClass(this.overClass); - } - return this.dropAllowed; - }, - - /** - * The function a {@link Ext.dd.DragSource} calls continuously while it is being dragged over the target. - * This method will be called on every mouse movement while the drag source is over the drop target. - * This default implementation simply returns the dropAllowed config value. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - notifyOver : function(dd, e, data){ - return this.dropAllowed; - }, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the source has been dragged - * out of the target without dropping. This default implementation simply removes the CSS class specified by - * overClass (if any) from the drop element. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - */ - notifyOut : function(dd, e, data){ - if(this.overClass){ - this.el.removeClass(this.overClass); - } - }, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop target that the dragged item has - * been dropped on it. This method has no default implementation and returns false, so you must provide an - * implementation that does something to process the drop event and returns true so that the drag source's - * repair action does not run. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {Boolean} True if the drop was valid, else false - */ - notifyDrop : function(dd, e, data){ - return false; - } -});/** - * @class Ext.dd.DragZone - * @extends Ext.dd.DragSource - *
This class provides a container DD instance that allows dragging of multiple child source nodes.
- *
This class does not move the drag target nodes, but a proxy element which may contain - * any DOM structure you wish. The DOM element to show in the proxy is provided by either a - * provided implementation of {@link #getDragData}, or by registered draggables registered with {@link Ext.dd.Registry}
- *
If you wish to provide draggability for an arbitrary number of DOM nodes, each of which represent some - * application object (For example nodes in a {@link Ext.DataView DataView}) then use of this class - * is the most efficient way to "activate" those nodes.
- *
By default, this class requires that draggable child nodes are registered with {@link Ext.dd.Registry}. - * However a simpler way to allow a DragZone to manage any number of draggable elements is to configure - * the DragZone with an implementation of the {@link #getDragData} method which interrogates the passed - * mouse event to see if it has taken place within an element, or class of elements. This is easily done - * by using the event's {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a - * {@link Ext.DomQuery} selector. For example, to make the nodes of a DataView draggable, use the following - * technique. Knowledge of the use of the DataView is required:
-myDataView.on('render', function(v) { - myDataView.dragZone = new Ext.dd.DragZone(v.getEl(), { - -// On receipt of a mousedown event, see if it is within a DataView node. -// Return a drag data object if so. - getDragData: function(e) { - -// Use the DataView's own itemSelector (a mandatory property) to -// test if the mousedown is within one of the DataView's nodes. - var sourceEl = e.getTarget(v.itemSelector, 10); - -// If the mousedown is within a DataView node, clone the node to produce -// a ddel element for use by the drag proxy. Also add application data -// to the returned data object. - if (sourceEl) { - d = sourceEl.cloneNode(true); - d.id = Ext.id(); - return { - ddel: d, - sourceEl: sourceEl, - repairXY: Ext.fly(sourceEl).getXY(), - sourceStore: v.store, - draggedRecord: v.{@link Ext.DataView#getRecord getRecord}(sourceEl) - } - } - }, - -// Provide coordinates for the proxy to slide back to on failed drag. -// This is the original XY coordinates of the draggable element captured -// in the getDragData method. - getRepairXY: function() { - return this.dragData.repairXY; - } - }); -});
- * See the {@link Ext.dd.DropZone DropZone} documentation for details about building a DropZone which - * cooperates with this DragZone. - * @constructor - * @param {Mixed} el The container element - * @param {Object} config - */ -Ext.dd.DragZone = function(el, config){ - Ext.dd.DragZone.superclass.constructor.call(this, el, config); - if(this.containerScroll){ - Ext.dd.ScrollManager.register(this.el); - } -}; - -Ext.extend(Ext.dd.DragZone, Ext.dd.DragSource, { - /** - * This property contains the data representing the dragged object. This data is set up by the implementation - * of the {@link #getDragData} method. It must contain a ddel property, but can contain - * any other data according to the application's needs. - * @type Object - * @property dragData - */ - /** - * @cfg {Boolean} containerScroll True to register this container with the Scrollmanager - * for auto scrolling during drag operations. - */ - /** - * @cfg {String} hlColor The color to use when visually highlighting the drag source in the afterRepair - * method after a failed drop (defaults to "c3daf9" - light blue) - */ - - /** - * Called when a mousedown occurs in this container. Looks in {@link Ext.dd.Registry} - * for a valid target to drag based on the mouse down. Override this method - * to provide your own lookup logic (e.g. finding a child by class name). Make sure your returned - * object has a "ddel" attribute (with an HTML Element) for other functions to work. - * @param {EventObject} e The mouse down event - * @return {Object} The dragData - */ - getDragData : function(e){ - return Ext.dd.Registry.getHandleFromEvent(e); - }, - - /** - * Called once drag threshold has been reached to initialize the proxy element. By default, it clones the - * this.dragData.ddel - * @param {Number} x The x position of the click on the dragged object - * @param {Number} y The y position of the click on the dragged object - * @return {Boolean} true to continue the drag, false to cancel - */ - onInitDrag : function(x, y){ - this.proxy.update(this.dragData.ddel.cloneNode(true)); - this.onStartDrag(x, y); - return true; - }, - - /** - * Called after a repair of an invalid drop. By default, highlights this.dragData.ddel - */ - afterRepair : function(){ - if(Ext.enableFx){ - Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9"); - } - this.dragging = false; - }, - - /** - * Called before a repair of an invalid drop to get the XY to animate to. By default returns - * the XY of this.dragData.ddel - * @param {EventObject} e The mouse up event - * @return {Array} The xy location (e.g. [100, 200]) - */ - getRepairXY : function(e){ - return Ext.Element.fly(this.dragData.ddel).getXY(); - } -});/** - * @class Ext.dd.DropZone - * @extends Ext.dd.DropTarget - *
This class provides a container DD instance that allows dropping on multiple child target nodes.
- *
By default, this class requires that child nodes accepting drop are registered with {@link Ext.dd.Registry}. - * However a simpler way to allow a DropZone to manage any number of target elements is to configure the - * DropZone with an implementation of {@link #getTargetFromEvent} which interrogates the passed - * mouse event to see if it has taken place within an element, or class of elements. This is easily done - * by using the event's {@link Ext.EventObject#getTarget getTarget} method to identify a node based on a - * {@link Ext.DomQuery} selector.
- *
Once the DropZone has detected through calling getTargetFromEvent, that the mouse is over - * a drop target, that target is passed as the first parameter to {@link #onNodeEnter}, {@link #onNodeOver}, - * {@link #onNodeOut}, {@link #onNodeDrop}. You may configure the instance of DropZone with implementations - * of these methods to provide application-specific behaviour for these events to update both - * application state, and UI state.
- *
For example to make a GridPanel a cooperating target with the example illustrated in - * {@link Ext.dd.DragZone DragZone}, the following technique might be used:
-myGridPanel.on('render', function() { - myGridPanel.dropZone = new Ext.dd.DropZone(myGridPanel.getView().scroller, { - -// If the mouse is over a grid row, return that node. This is -// provided as the "target" parameter in all "onNodeXXXX" node event handling functions - getTargetFromEvent: function(e) { - return e.getTarget(myGridPanel.getView().rowSelector); - }, - -// On entry into a target node, highlight that node. - onNodeEnter : function(target, dd, e, data){ - Ext.fly(target).addClass('my-row-highlight-class'); - }, - -// On exit from a target node, unhighlight that node. - onNodeOut : function(target, dd, e, data){ - Ext.fly(target).removeClass('my-row-highlight-class'); - }, - -// While over a target node, return the default drop allowed class which -// places a "tick" icon into the drag proxy. - onNodeOver : function(target, dd, e, data){ - return Ext.dd.DropZone.prototype.dropAllowed; - }, - -// On node drop we can interrogate the target to find the underlying -// application object that is the real target of the dragged data. -// In this case, it is a Record in the GridPanel's Store. -// We can use the data set up by the DragZone's getDragData method to read -// any data we decided to attach in the DragZone's getDragData method. - onNodeDrop : function(target, dd, e, data){ - var rowIndex = myGridPanel.getView().findRowIndex(target); - var r = myGridPanel.getStore().getAt(rowIndex); - Ext.Msg.alert('Drop gesture', 'Dropped Record id ' + data.draggedRecord.id + - ' on Record id ' + r.id); - return true; - } - }); -} -
- * See the {@link Ext.dd.DragZone DragZone} documentation for details about building a DragZone which - * cooperates with this DropZone. - * @constructor - * @param {Mixed} el The container element - * @param {Object} config - */ -Ext.dd.DropZone = function(el, config){ - Ext.dd.DropZone.superclass.constructor.call(this, el, config); -}; - -Ext.extend(Ext.dd.DropZone, Ext.dd.DropTarget, { - /** - * Returns a custom data object associated with the DOM node that is the target of the event. By default - * this looks up the event target in the {@link Ext.dd.Registry}, although you can override this method to - * provide your own custom lookup. - * @param {Event} e The event - * @return {Object} data The custom data - */ - getTargetFromEvent : function(e){ - return Ext.dd.Registry.getTargetFromEvent(e); - }, - - /** - * Called when the DropZone determines that a {@link Ext.dd.DragSource} has entered a drop node - * that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}. - * This method has no default implementation and should be overridden to provide - * node-specific processing if necessary. - * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from - * {@link #getTargetFromEvent} for this node) - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - */ - onNodeEnter : function(n, dd, e, data){ - - }, - - /** - * Called while the DropZone determines that a {@link Ext.dd.DragSource} is over a drop node - * that has either been registered or detected by a configured implementation of {@link #getTargetFromEvent}. - * The default implementation returns this.dropNotAllowed, so it should be - * overridden to provide the proper feedback. - * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from - * {@link #getTargetFromEvent} for this node) - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - onNodeOver : function(n, dd, e, data){ - return this.dropAllowed; - }, - - /** - * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dragged out of - * the drop node without dropping. This method has no default implementation and should be overridden to provide - * node-specific processing if necessary. - * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from - * {@link #getTargetFromEvent} for this node) - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - */ - onNodeOut : function(n, dd, e, data){ - - }, - - /** - * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped onto - * the drop node. The default implementation returns false, so it should be overridden to provide the - * appropriate processing of the drop event and return true so that the drag source's repair action does not run. - * @param {Object} nodeData The custom data associated with the drop node (this is the same value returned from - * {@link #getTargetFromEvent} for this node) - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {Boolean} True if the drop was valid, else false - */ - onNodeDrop : function(n, dd, e, data){ - return false; - }, - - /** - * Called while the DropZone determines that a {@link Ext.dd.DragSource} is being dragged over it, - * but not over any of its registered drop nodes. The default implementation returns this.dropNotAllowed, so - * it should be overridden to provide the proper feedback if necessary. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - onContainerOver : function(dd, e, data){ - return this.dropNotAllowed; - }, - - /** - * Called when the DropZone determines that a {@link Ext.dd.DragSource} has been dropped on it, - * but not on any of its registered drop nodes. The default implementation returns false, so it should be - * overridden to provide the appropriate processing of the drop event if you need the drop zone itself to - * be able to accept drops. It should return true when valid so that the drag source's repair action does not run. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {Boolean} True if the drop was valid, else false - */ - onContainerDrop : function(dd, e, data){ - return false; - }, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source is now over - * the zone. The default implementation returns this.dropNotAllowed and expects that only registered drop - * nodes can process drag drop operations, so if you need the drop zone itself to be able to process drops - * you should override this method and provide a custom implementation. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - notifyEnter : function(dd, e, data){ - return this.dropNotAllowed; - }, - - /** - * The function a {@link Ext.dd.DragSource} calls continuously while it is being dragged over the drop zone. - * This method will be called on every mouse movement while the drag source is over the drop zone. - * It will call {@link #onNodeOver} while the drag source is over a registered node, and will also automatically - * delegate to the appropriate node-specific methods as necessary when the drag source enters and exits - * registered nodes ({@link #onNodeEnter}, {@link #onNodeOut}). If the drag source is not currently over a - * registered node, it will call {@link #onContainerOver}. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {String} status The CSS class that communicates the drop status back to the source so that the - * underlying {@link Ext.dd.StatusProxy} can be updated - */ - notifyOver : function(dd, e, data){ - var n = this.getTargetFromEvent(e); - if(!n){ // not over valid drop target - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - return this.onContainerOver(dd, e, data); - } - if(this.lastOverNode != n){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - } - this.onNodeEnter(n, dd, e, data); - this.lastOverNode = n; - } - return this.onNodeOver(n, dd, e, data); - }, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the source has been dragged - * out of the zone without dropping. If the drag source is currently over a registered node, the notification - * will be delegated to {@link #onNodeOut} for node-specific handling, otherwise it will be ignored. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop target - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag zone - */ - notifyOut : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - }, - - /** - * The function a {@link Ext.dd.DragSource} calls once to notify this drop zone that the dragged item has - * been dropped on it. The drag zone will look up the target node based on the event passed in, and if there - * is a node registered for that event, it will delegate to {@link #onNodeDrop} for node-specific handling, - * otherwise it will call {@link #onContainerDrop}. - * @param {Ext.dd.DragSource} source The drag source that was dragged over this drop zone - * @param {Event} e The event - * @param {Object} data An object containing arbitrary data supplied by the drag source - * @return {Boolean} True if the drop was valid, else false - */ - notifyDrop : function(dd, e, data){ - if(this.lastOverNode){ - this.onNodeOut(this.lastOverNode, dd, e, data); - this.lastOverNode = null; - } - var n = this.getTargetFromEvent(e); - return n ? - this.onNodeDrop(n, dd, e, data) : - this.onContainerDrop(dd, e, data); - }, - - // private - triggerCacheRefresh : function(){ - Ext.dd.DDM.refreshCache(this.groups); - } -});/** - * @class Ext.Element - */ -Ext.Element.addMethods({ - /** - * Initializes a {@link Ext.dd.DD} drag drop object for this element. - * @param {String} group The group the DD object is member of - * @param {Object} config The DD config object - * @param {Object} overrides An object containing methods to override/implement on the DD object - * @return {Ext.dd.DD} The DD object - */ - initDD : function(group, config, overrides){ - var dd = new Ext.dd.DD(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, - - /** - * Initializes a {@link Ext.dd.DDProxy} object for this element. - * @param {String} group The group the DDProxy object is member of - * @param {Object} config The DDProxy config object - * @param {Object} overrides An object containing methods to override/implement on the DDProxy object - * @return {Ext.dd.DDProxy} The DDProxy object - */ - initDDProxy : function(group, config, overrides){ - var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - }, - - /** - * Initializes a {@link Ext.dd.DDTarget} object for this element. - * @param {String} group The group the DDTarget object is member of - * @param {Object} config The DDTarget config object - * @param {Object} overrides An object containing methods to override/implement on the DDTarget object - * @return {Ext.dd.DDTarget} The DDTarget object - */ - initDDTarget : function(group, config, overrides){ - var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config); - return Ext.apply(dd, overrides); - } -}); -/** - * @class Ext.data.Api - * @extends Object - * Ext.data.Api is a singleton designed to manage the data API including methods - * for validating a developer's DataProxy API. Defines variables for CRUD actions - * create, read, update and destroy in addition to a mapping of RESTful HTTP methods - * GET, POST, PUT and DELETE to CRUD actions. - * @singleton - */ -Ext.data.Api = (function() { + // private + onDisable : function(){ + this.onDisableChange(true); + }, - // private validActions. validActions is essentially an inverted hash of Ext.data.Api.actions, where value becomes the key. - // Some methods in this singleton (e.g.: getActions, getVerb) will loop through actions with the code for (var verb in this.actions) - // For efficiency, some methods will first check this hash for a match. Those methods which do acces validActions will cache their result here. - // We cannot pre-define this hash since the developer may over-ride the actions at runtime. - var validActions = {}; + // private + onEnable : function(){ + this.onDisableChange(false); + }, - return { - /** - * Defined actions corresponding to remote actions: - *
-actions: { - create : 'create', // Text representing the remote-action to create records on server. - read : 'read', // Text representing the remote-action to read/load data from server. - update : 'update', // Text representing the remote-action to update records on server. - destroy : 'destroy' // Text representing the remote-action to destroy records on server. -} - *
- * @property actions - * @type Object - */ - actions : { - create : 'create', - read : 'read', - update : 'update', - destroy : 'destroy' - }, + onDisableChange : function(disabled){ + if(this.el){ + if(!Ext.isIE6 || !this.text){ + this.el[disabled ? 'addClass' : 'removeClass'](this.disabledClass); + } + this.el.dom.disabled = disabled; + } + this.disabled = disabled; + }, - /** - * Defined {CRUD action}:{HTTP method} pairs to associate HTTP methods with the - * corresponding actions for {@link Ext.data.DataProxy#restful RESTful proxies}. - * Defaults to: - *
-restActions : { - create : 'POST', - read : 'GET', - update : 'PUT', - destroy : 'DELETE' -}, - *
- */ - restActions : { - create : 'POST', - read : 'GET', - update : 'PUT', - destroy : 'DELETE' - }, + /** + * Show this button's menu (if it has one) + */ + showMenu : function(){ + if(this.rendered && this.menu){ + if(this.tooltip){ + Ext.QuickTips.getQuickTip().cancelShow(this.btnEl); + } + if(this.menu.isVisible()){ + this.menu.hide(); + } + this.menu.ownerCt = this; + this.menu.show(this.el, this.menuAlign); + } + return this; + }, - /** - * Returns true if supplied action-name is a valid API action defined in {@link #actions} constants - * @param {String} action - * @param {String[]}(Optional) List of available CRUD actions. Pass in list when executing multiple times for efficiency. - * @return {Boolean} - */ - isAction : function(action) { - return (Ext.data.Api.actions[action]) ? true : false; - }, + /** + * Hide this button's menu (if it has one) + */ + hideMenu : function(){ + if(this.hasVisibleMenu()){ + this.menu.hide(); + } + return this; + }, - /** - * Returns the actual CRUD action KEY "create", "read", "update" or "destroy" from the supplied action-name. This method is used internally and shouldn't generally - * need to be used directly. The key/value pair of Ext.data.Api.actions will often be identical but this is not necessarily true. A developer can override this naming - * convention if desired. However, the framework internally calls methods based upon the KEY so a way of retreiving the the words "create", "read", "update" and "destroy" is - * required. This method will cache discovered KEYS into the private validActions hash. - * @param {String} name The runtime name of the action. - * @return {String||null} returns the action-key, or verb of the user-action or null if invalid. - * @nodoc - */ - getVerb : function(name) { - if (validActions[name]) { - return validActions[name]; // <-- found in cache. return immediately. + /** + * Returns true if the button has a menu and it is visible + * @return {Boolean} + */ + hasVisibleMenu : function(){ + return this.menu && this.menu.ownerCt == this && this.menu.isVisible(); + }, + + // private + onClick : function(e){ + if(e){ + e.preventDefault(); + } + if(e.button !== 0){ + return; + } + if(!this.disabled){ + if(this.enableToggle && (this.allowDepress !== false || !this.pressed)){ + this.toggle(); } - for (var verb in this.actions) { - if (this.actions[verb] === name) { - validActions[name] = verb; - break; - } + if(this.menu && !this.hasVisibleMenu() && !this.ignoreNextClick){ + this.showMenu(); } - return (validActions[name] !== undefined) ? validActions[name] : null; - }, - - /** - * Returns true if the supplied API is valid; that is, check that all keys match defined actions - * otherwise returns an array of mistakes. - * @return {String[]||true} - */ - isValid : function(api){ - var invalid = []; - var crud = this.actions; // <-- cache a copy of the actions. - for (var action in api) { - if (!(action in crud)) { - invalid.push(action); - } + this.fireEvent('click', this, e); + if(this.handler){ + //this.el.removeClass('x-btn-over'); + this.handler.call(this.scope || this, this, e); } - return (!invalid.length) ? true : invalid; - }, + } + }, - /** - * Returns true if the supplied verb upon the supplied proxy points to a unique url in that none of the other api-actions - * point to the same url. The question is important for deciding whether to insert the "xaction" HTTP parameter within an - * Ajax request. This method is used internally and shouldn't generally need to be called directly. - * @param {Ext.data.DataProxy} proxy - * @param {String} verb - * @return {Boolean} - */ - hasUniqueUrl : function(proxy, verb) { - var url = (proxy.api[verb]) ? proxy.api[verb].url : null; - var unique = true; - for (var action in proxy.api) { - if ((unique = (action === verb) ? true : (proxy.api[action].url != url) ? true : false) === false) { - break; - } - } - return unique; - }, + // private + isMenuTriggerOver : function(e, internal){ + return this.menu && !internal; + }, - /** - * This method is used internally by {@link Ext.data.DataProxy DataProxy} and should not generally need to be used directly. - * Each action of a DataProxy api can be initially defined as either a String or an Object. When specified as an object, - * one can explicitly define the HTTP method (GET|POST) to use for each CRUD action. This method will prepare the supplied API, setting - * each action to the Object form. If your API-actions do not explicitly define the HTTP method, the "method" configuration-parameter will - * be used. If the method configuration parameter is not specified, POST will be used. -
-new Ext.data.HttpProxy({ - method: "POST", // <-- default HTTP method when not specified. - api: { - create: 'create.php', - load: 'read.php', - save: 'save.php', - destroy: 'destroy.php' - } -}); + // private + isMenuTriggerOut : function(e, internal){ + return this.menu && !internal; + }, -// Alternatively, one can use the object-form to specify the API -new Ext.data.HttpProxy({ - api: { - load: {url: 'read.php', method: 'GET'}, - create: 'create.php', - destroy: 'destroy.php', - save: 'update.php' - } -}); -
- * - * @param {Ext.data.DataProxy} proxy - */ - prepare : function(proxy) { - if (!proxy.api) { - proxy.api = {}; // <-- No api? create a blank one. - } - for (var verb in this.actions) { - var action = this.actions[verb]; - proxy.api[action] = proxy.api[action] || proxy.url || proxy.directFn; - if (typeof(proxy.api[action]) == 'string') { - proxy.api[action] = { - url: proxy.api[action], - method: (proxy.restful === true) ? Ext.data.Api.restActions[action] : undefined - }; + // private + onMouseOver : function(e){ + if(!this.disabled){ + var internal = e.within(this.el, true); + if(!internal){ + this.el.addClass('x-btn-over'); + if(!this.monitoringMouseOver){ + this.doc.on('mouseover', this.monitorMouseOver, this); + this.monitoringMouseOver = true; } + this.fireEvent('mouseover', this, e); } - }, - - /** - * Prepares a supplied Proxy to be RESTful. Sets the HTTP method for each api-action to be one of - * GET, POST, PUT, DELETE according to the defined {@link #restActions}. - * @param {Ext.data.DataProxy} proxy - */ - restify : function(proxy) { - proxy.restful = true; - for (var verb in this.restActions) { - proxy.api[this.actions[verb]].method || - (proxy.api[this.actions[verb]].method = this.restActions[verb]); + if(this.isMenuTriggerOver(e, internal)){ + this.fireEvent('menutriggerover', this, this.menu, e); } - // TODO: perhaps move this interceptor elsewhere? like into DataProxy, perhaps? Placed here - // to satisfy initial 3.0 final release of REST features. - proxy.onWrite = proxy.onWrite.createInterceptor(function(action, o, response, rs) { - var reader = o.reader; - var res = new Ext.data.Response({ - action: action, - raw: response - }); + } + }, - switch (response.status) { - case 200: // standard 200 response, send control back to HttpProxy#onWrite by returning true from this intercepted #onWrite - return true; - break; - case 201: // entity created but no response returned - if (Ext.isEmpty(res.raw.responseText)) { - res.success = true; - } else { - //if the response contains data, treat it like a 200 - return true; - } - break; - case 204: // no-content. Create a fake response. - res.success = true; - res.data = null; - break; - default: - return true; - break; - } - if (res.success === true) { - this.fireEvent("write", this, action, res.data, res, rs, o.request.arg); - } else { - this.fireEvent('exception', this, 'remote', action, o, res, rs); - } - o.request.callback.call(o.request.scope, res.data, res, res.success); + // private + monitorMouseOver : function(e){ + if(e.target != this.el.dom && !e.within(this.el)){ + if(this.monitoringMouseOver){ + this.doc.un('mouseover', this.monitorMouseOver, this); + this.monitoringMouseOver = false; + } + this.onMouseOut(e); + } + }, - return false; // <-- false to prevent intercepted function from running. - }, proxy); + // private + onMouseOut : function(e){ + var internal = e.within(this.el) && e.target != this.el.dom; + this.el.removeClass('x-btn-over'); + this.fireEvent('mouseout', this, e); + if(this.isMenuTriggerOut(e, internal)){ + this.fireEvent('menutriggerout', this, this.menu, e); } - }; -})(); + }, -/** - * Ext.data.Response - * Experimental. Do not use directly. - */ -Ext.data.Response = function(params, response) { - Ext.apply(this, params, { - raw: response - }); -}; -Ext.data.Response.prototype = { - message : null, - success : false, - status : null, - root : null, - raw : null, + focus : function() { + this.btnEl.focus(); + }, - getMessage : function() { - return this.message; + blur : function() { + this.btnEl.blur(); }, - getSuccess : function() { - return this.success; + + // private + onFocus : function(e){ + if(!this.disabled){ + this.el.addClass('x-btn-focus'); + } }, - getStatus : function() { - return this.status; + // private + onBlur : function(e){ + this.el.removeClass('x-btn-focus'); }, - getRoot : function() { - return this.root; + + // private + getClickEl : function(e, isUp){ + return this.el; }, - getRawResponse : function() { - return this.raw; - } -}; -/** - * @class Ext.data.Api.Error - * @extends Ext.Error - * Error class for Ext.data.Api errors - */ -Ext.data.Api.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); + // private + onMouseDown : function(e){ + if(!this.disabled && e.button === 0){ + this.getClickEl(e).addClass('x-btn-click'); + this.doc.on('mouseup', this.onMouseUp, this); + } }, - name: 'Ext.data.Api' -}); -Ext.apply(Ext.data.Api.Error.prototype, { - lang: { - 'action-url-undefined': 'No fallback url defined for this action. When defining a DataProxy api, please be sure to define an url for each CRUD action in Ext.data.Api.actions or define a default url in addition to your api-configuration.', - 'invalid': 'received an invalid API-configuration. Please ensure your proxy API-configuration contains only the actions defined in Ext.data.Api.actions', - 'invalid-url': 'Invalid url. Please review your proxy configuration.', - 'execute': 'Attempted to execute an unknown action. Valid API actions are defined in Ext.data.Api.actions"' + // private + onMouseUp : function(e){ + if(e.button === 0){ + this.getClickEl(e, true).removeClass('x-btn-click'); + this.doc.un('mouseup', this.onMouseUp, this); + } + }, + // private + onMenuShow : function(e){ + if(this.menu.ownerCt == this){ + this.menu.ownerCt = this; + this.ignoreNextClick = 0; + this.el.addClass('x-btn-menu-active'); + this.fireEvent('menushow', this, this.menu); + } + }, + // private + onMenuHide : function(e){ + if(this.menu.ownerCt == this){ + this.el.removeClass('x-btn-menu-active'); + this.ignoreNextClick = this.restoreClick.defer(250, this); + this.fireEvent('menuhide', this, this.menu); + delete this.menu.ownerCt; + } + }, + + // private + restoreClick : function(){ + this.ignoreNextClick = 0; } + + /** + * @cfg {String} autoEl @hide + */ + /** + * @cfg {String/Object} html @hide + */ + /** + * @cfg {String} contentEl @hide + */ + /** + * @cfg {Mixed} data @hide + */ + /** + * @cfg {Mixed} tpl @hide + */ + /** + * @cfg {String} tplWriteMode @hide + */ }); +Ext.reg('button', Ext.Button); +// Private utility class used by Button +Ext.ButtonToggleMgr = function(){ + var groups = {}; - -/** - * @class Ext.data.SortTypes - * @singleton - * Defines the default sorting (casting?) comparison functions used when sorting data. - */ -Ext.data.SortTypes = { - /** - * Default sort that does nothing - * @param {Mixed} s The value being converted - * @return {Mixed} The comparison value - */ - none : function(s){ - return s; - }, - - /** - * The regular expression used to strip tags - * @type {RegExp} - * @property - */ - stripTagsRE : /<\/?[^>]+>/gi, - - /** - * Strips all HTML tags to sort on text only - * @param {Mixed} s The value being converted - * @return {String} The comparison value - */ - asText : function(s){ - return String(s).replace(this.stripTagsRE, ""); - }, - - /** - * Strips all HTML tags to sort on text only - Case insensitive - * @param {Mixed} s The value being converted - * @return {String} The comparison value - */ - asUCText : function(s){ - return String(s).toUpperCase().replace(this.stripTagsRE, ""); - }, - - /** - * Case insensitive string - * @param {Mixed} s The value being converted - * @return {String} The comparison value - */ - asUCString : function(s) { - return String(s).toUpperCase(); - }, - - /** - * Date sorting - * @param {Mixed} s The value being converted - * @return {Number} The comparison value - */ - asDate : function(s) { - if(!s){ - return 0; - } - if(Ext.isDate(s)){ - return s.getTime(); - } - return Date.parse(String(s)); - }, - - /** - * Float sorting - * @param {Mixed} s The value being converted - * @return {Float} The comparison value - */ - asFloat : function(s) { - var val = parseFloat(String(s).replace(/,/g, "")); - return isNaN(val) ? 0 : val; - }, - - /** - * Integer sorting - * @param {Mixed} s The value being converted - * @return {Number} The comparison value - */ - asInt : function(s) { - var val = parseInt(String(s).replace(/,/g, ""), 10); - return isNaN(val) ? 0 : val; - } -};/** - * @class Ext.data.Record - *
Instances of this class encapsulate both Record definition information, and Record - * value information for use in {@link Ext.data.Store} objects, or any code which needs - * to access Records cached in an {@link Ext.data.Store} object.
- *
Constructors for this class are generated by passing an Array of field definition objects to {@link #create}. - * Instances are usually only created by {@link Ext.data.Reader} implementations when processing unformatted data - * objects.
- *
Note that an instance of a Record class may only belong to one {@link Ext.data.Store Store} at a time. - * In order to copy data from one Store to another, use the {@link #copy} method to create an exact - * copy of the Record, and insert the new instance into the other Store.
- *
When serializing a Record for submission to the server, be aware that it contains many private - * properties, and also a reference to its owning Store which in turn holds references to its Records. - * This means that a whole Record may not be encoded using {@link Ext.util.JSON.encode}. Instead, use the - * {@link #data} and {@link #id} properties.
- *
Record objects generated by this constructor inherit all the methods of Ext.data.Record listed below.
- * @constructor - *
This constructor should not be used to create Record objects. Instead, use {@link #create} to - * generate a subclass of Ext.data.Record configured with information about its constituent fields.
- *
The generated constructor has the same signature as this constructor.
- * @param {Object} data (Optional) An object, the properties of which provide values for the new Record's - * fields. If not specified the {@link Ext.data.Field#defaultValue defaultValue} - * for each field will be assigned. - * @param {Object} id (Optional) The id of the Record. The id is used by the - * {@link Ext.data.Store} object which owns the Record to index its collection - * of Records (therefore this id should be unique within each store). If an - * id is not specified a {@link #phantom} - * Record will be created with an {@link #Record.id automatically generated id}. - */ -Ext.data.Record = function(data, id){ - // if no id, call the auto id method - this.id = (id || id === 0) ? id : Ext.data.Record.id(this); - this.data = data || {}; -}; + function toggleGroup(btn, state){ + if(state){ + var g = groups[btn.toggleGroup]; + for(var i = 0, l = g.length; i < l; i++){ + if(g[i] != btn){ + g[i].toggle(false); + } + } + } + } -/** - * Generate a constructor for a specific Record layout. - * @param {Array} o An Array of {@link Ext.data.Field Field} definition objects. - * The constructor generated by this method may be used to create new Record instances. The data - * object must contain properties named after the {@link Ext.data.Field field} - * {@link Ext.data.Field#name}s. Example usage:
-// create a Record constructor from a description of the fields -var TopicRecord = Ext.data.Record.create([ // creates a subclass of Ext.data.Record - {{@link Ext.data.Field#name name}: 'title', {@link Ext.data.Field#mapping mapping}: 'topic_title'}, - {name: 'author', mapping: 'username', allowBlank: false}, - {name: 'totalPosts', mapping: 'topic_replies', type: 'int'}, - {name: 'lastPost', mapping: 'post_time', type: 'date'}, - {name: 'lastPoster', mapping: 'user2'}, - {name: 'excerpt', mapping: 'post_text', allowBlank: false}, - // In the simplest case, if no properties other than name are required, - // a field definition may consist of just a String for the field name. - 'signature' -]); + return { + register : function(btn){ + if(!btn.toggleGroup){ + return; + } + var g = groups[btn.toggleGroup]; + if(!g){ + g = groups[btn.toggleGroup] = []; + } + g.push(btn); + btn.on('toggle', toggleGroup); + }, -// create Record instance -var myNewRecord = new TopicRecord( - { - title: 'Do my job please', - author: 'noobie', - totalPosts: 1, - lastPost: new Date(), - lastPoster: 'Animal', - excerpt: 'No way dude!', - signature: '' - }, - id // optionally specify the id of the record otherwise {@link #Record.id one is auto-assigned} -); -myStore.{@link Ext.data.Store#add add}(myNewRecord); + unregister : function(btn){ + if(!btn.toggleGroup){ + return; + } + var g = groups[btn.toggleGroup]; + if(g){ + g.remove(btn); + btn.un('toggle', toggleGroup); + } + }, + + /** + * Gets the pressed button in the passed group or null + * @param {String} group + * @return Button + */ + getPressed : function(group){ + var g = groups[group]; + if(g){ + for(var i = 0, len = g.length; i < len; i++){ + if(g[i].pressed === true){ + return g[i]; + } + } + } + return null; + } + }; +}(); +/** + * @class Ext.SplitButton + * @extends Ext.Button + * A split button that provides a built-in dropdown arrow that can fire an event separately from the default + * click event of the button. Typically this would be used to display a dropdown menu that provides additional + * options to the primary button action, but any custom handler can provide the arrowclick implementation. Example usage: + * +// display a dropdown menu: +new Ext.SplitButton({ + renderTo: 'button-ct', // the container id + text: 'Options', + handler: optionsHandler, // handle a click on the button itself + menu: new Ext.menu.Menu({ + items: [ + // these items will render as dropdown menu items when the arrow is clicked: + {text: 'Item 1', handler: item1Handler}, + {text: 'Item 2', handler: item2Handler} + ] + }) +}); + +// Instead of showing a menu, you provide any type of custom +// functionality you want when the dropdown arrow is clicked: +new Ext.SplitButton({ + renderTo: 'button-ct', + text: 'Options', + handler: optionsHandler, + arrowHandler: myCustomHandler +}); - * @method create - * @return {function} A constructor which is used to create new Records according - * to the definition. The constructor has the same signature as {@link #Record}. - * @static + * @cfg {Function} arrowHandler A function called when the arrow button is clicked (can be used instead of click event) + * @cfg {String} arrowTooltip The title attribute of the arrow + * @constructor + * Create a new menu button + * @param {Object} config The config object + * @xtype splitbutton */ -Ext.data.Record.create = function(o){ - var f = Ext.extend(Ext.data.Record, {}); - var p = f.prototype; - p.fields = new Ext.util.MixedCollection(false, function(field){ - return field.name; - }); - for(var i = 0, len = o.length; i < len; i++){ - p.fields.add(new Ext.data.Field(o[i])); - } - f.getField = function(name){ - return p.fields.get(name); - }; - return f; -}; +Ext.SplitButton = Ext.extend(Ext.Button, { + // private + arrowSelector : 'em', + split: true, -Ext.data.Record.PREFIX = 'ext-record'; -Ext.data.Record.AUTO_ID = 1; -Ext.data.Record.EDIT = 'edit'; -Ext.data.Record.REJECT = 'reject'; -Ext.data.Record.COMMIT = 'commit'; + // private + initComponent : function(){ + Ext.SplitButton.superclass.initComponent.call(this); + /** + * @event arrowclick + * Fires when this button's arrow is clicked + * @param {MenuButton} this + * @param {EventObject} e The click event + */ + this.addEvents("arrowclick"); + }, + // private + onRender : function(){ + Ext.SplitButton.superclass.onRender.apply(this, arguments); + if(this.arrowTooltip){ + this.el.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip; + } + }, -/** - * Generates a sequential id. This method is typically called when a record is {@link #create}d - * and {@link #Record no id has been specified}. The returned id takes the form: - * {PREFIX}-{AUTO_ID}. - * PREFIX : StringExt.data.Record.PREFIX - * (defaults to 'ext-record') - * AUTO_ID : StringExt.data.Record.AUTO_ID - * (defaults to 1 initially) - * - * @param {Record} rec The record being created. The record does not exist, it's a {@link #phantom}. - * @return {String} auto-generated string id, "ext-record-i++'; - */ -Ext.data.Record.id = function(rec) { - rec.phantom = true; - return [Ext.data.Record.PREFIX, '-', Ext.data.Record.AUTO_ID++].join(''); -}; + /** + * Sets this button's arrow click handler. + * @param {Function} handler The function to call when the arrow is clicked + * @param {Object} scope (optional) Scope for the function passed above + */ + setArrowHandler : function(handler, scope){ + this.arrowHandler = handler; + this.scope = scope; + }, -Ext.data.Record.prototype = { + getMenuClass : function(){ + return 'x-btn-split' + (this.arrowAlign == 'bottom' ? '-bottom' : ''); + }, + + isClickOnArrow : function(e){ + if (this.arrowAlign != 'bottom') { + var visBtn = this.el.child('em.x-btn-split'); + var right = visBtn.getRegion().right - visBtn.getPadding('r'); + return e.getPageX() > right; + } else { + return e.getPageY() > this.btnEl.getRegion().bottom; + } + }, + + // private + onClick : function(e, t){ + e.preventDefault(); + if(!this.disabled){ + if(this.isClickOnArrow(e)){ + if(this.menu && !this.menu.isVisible() && !this.ignoreNextClick){ + this.showMenu(); + } + this.fireEvent("arrowclick", this, e); + if(this.arrowHandler){ + this.arrowHandler.call(this.scope || this, this, e); + } + }else{ + if(this.enableToggle){ + this.toggle(); + } + this.fireEvent("click", this, e); + if(this.handler){ + this.handler.call(this.scope || this, this, e); + } + } + } + }, + + // private + isMenuTriggerOver : function(e){ + return this.menu && e.target.tagName == this.arrowSelector; + }, + + // private + isMenuTriggerOut : function(e, internal){ + return this.menu && e.target.tagName != this.arrowSelector; + } +}); + +Ext.reg('splitbutton', Ext.SplitButton);/** + * @class Ext.CycleButton + * @extends Ext.SplitButton + * A specialized SplitButton that contains a menu of {@link Ext.menu.CheckItem} elements. The button automatically + * cycles through each menu item on click, raising the button's {@link #change} event (or calling the button's + * {@link #changeHandler} function, if supplied) for the active menu item. Clicking on the arrow section of the + * button displays the dropdown menu just like a normal SplitButton. Example usage: + * +var btn = new Ext.CycleButton({ + showText: true, + prependText: 'View as ', + items: [{ + text:'text only', + iconCls:'view-text', + checked:true + },{ + text:'HTML', + iconCls:'view-html' + }], + changeHandler:function(btn, item){ + Ext.Msg.alert('Change View', item.text); + } +}); + + * @constructor + * Create a new split button + * @param {Object} config The config object + * @xtype cycle + */ +Ext.CycleButton = Ext.extend(Ext.SplitButton, { /** - * This property is stored in the Record definition's prototype - * A MixedCollection containing the defined {@link Ext.data.Field Field}s for this Record. Read-only. - * @property fields - * @type Ext.util.MixedCollection + * @cfg {Array} items An array of {@link Ext.menu.CheckItem} config objects to be used when creating the + * button's menu items (e.g., {text:'Foo', iconCls:'foo-icon'}) */ /** - * An object hash representing the data for this Record. Every field name in the Record definition - * is represented by a property of that name in this object. Note that unless you specified a field - * with {@link Ext.data.Field#name name} "id" in the Record definition, this will not contain - * an id property. - * @property data - * @type {Object} + * @cfg {Boolean} showText True to display the active item's text as the button text (defaults to false) */ /** - * The unique ID of the Record {@link #Record as specified at construction time}. - * @property id - * @type {Object} + * @cfg {String} prependText A static string to prepend before the active item's text when displayed as the + * button's text (only applies when showText = true, defaults to '') */ /** - * Only present if this Record was created by an {@link Ext.data.XmlReader XmlReader}. - * The XML element which was the source of the data for this Record. - * @property node - * @type {XMLElement} + * @cfg {Function} changeHandler A callback function that will be invoked each time the active menu + * item in the button's menu has changed. If this callback is not supplied, the SplitButton will instead + * fire the {@link #change} event on active item change. The changeHandler function will be called with the + * following argument list: (SplitButton this, Ext.menu.CheckItem item) */ /** - * Only present if this Record was created by an {@link Ext.data.ArrayReader ArrayReader} or a {@link Ext.data.JsonReader JsonReader}. - * The Array or object which was the source of the data for this Record. - * @property json - * @type {Array|Object} + * @cfg {String} forceIcon A css class which sets an image to be used as the static icon for this button. This + * icon will always be displayed regardless of which item is selected in the dropdown list. This overrides the + * default behavior of changing the button's icon to match the selected item's icon on change. */ /** - * Readonly flag - true if this Record has been modified. - * @type Boolean + * @property menu + * @type Menu + * The {@link Ext.menu.Menu Menu} object used to display the {@link Ext.menu.CheckItem CheckItems} representing the available choices. */ - dirty : false, - editing : false, - error : null, + + // private + getItemText : function(item){ + if(item && this.showText === true){ + var text = ''; + if(this.prependText){ + text += this.prependText; + } + text += item.text; + return text; + } + return undefined; + }, + /** - * This object contains a key and value storing the original values of all modified - * fields or is null if no fields have been modified. - * @property modified - * @type {Object} + * Sets the button's active menu item. + * @param {Ext.menu.CheckItem} item The item to activate + * @param {Boolean} suppressEvent True to prevent the button's change event from firing (defaults to false) */ - modified : null, + setActiveItem : function(item, suppressEvent){ + if(!Ext.isObject(item)){ + item = this.menu.getComponent(item); + } + if(item){ + if(!this.rendered){ + this.text = this.getItemText(item); + this.iconCls = item.iconCls; + }else{ + var t = this.getItemText(item); + if(t){ + this.setText(t); + } + this.setIconClass(item.iconCls); + } + this.activeItem = item; + if(!item.checked){ + item.setChecked(true, false); + } + if(this.forceIcon){ + this.setIconClass(this.forceIcon); + } + if(!suppressEvent){ + this.fireEvent('change', this, item); + } + } + }, + /** - * true when the record does not yet exist in a server-side database (see - * {@link #markDirty}). Any record which has a real database pk set as its id property - * is NOT a phantom -- it's real. - * @property phantom - * @type {Boolean} + * Gets the currently active menu item. + * @return {Ext.menu.CheckItem} The active item */ - phantom : false, + getActiveItem : function(){ + return this.activeItem; + }, // private - join : function(store){ - /** - * The {@link Ext.data.Store} to which this Record belongs. - * @property store - * @type {Ext.data.Store} - */ - this.store = store; - }, + initComponent : function(){ + this.addEvents( + /** + * @event change + * Fires after the button's active menu item has changed. Note that if a {@link #changeHandler} function + * is set on this CycleButton, it will be called instead on active item change and this change event will + * not be fired. + * @param {Ext.CycleButton} this + * @param {Ext.menu.CheckItem} item The menu item that was selected + */ + "change" + ); - /** - * Set the {@link Ext.data.Field#name named field} to the specified value. For example: - * -// record has a field named 'firstname' -var Employee = Ext.data.Record.{@link #create}([ - {name: 'firstname'}, - ... -]); + if(this.changeHandler){ + this.on('change', this.changeHandler, this.scope||this); + delete this.changeHandler; + } -// update the 2nd record in the store: -var rec = myStore.{@link Ext.data.Store#getAt getAt}(1); + this.itemCount = this.items.length; -// set the value (shows dirty flag): -rec.set('firstname', 'Betty'); + this.menu = {cls:'x-cycle-menu', items:[]}; + var checked = 0; + Ext.each(this.items, function(item, i){ + Ext.apply(item, { + group: item.group || this.id, + itemIndex: i, + checkHandler: this.checkHandler, + scope: this, + checked: item.checked || false + }); + this.menu.items.push(item); + if(item.checked){ + checked = i; + } + }, this); + Ext.CycleButton.superclass.initComponent.call(this); + this.on('click', this.toggleSelected, this); + this.setActiveItem(checked, true); + }, -// commit the change (removes dirty flag): -rec.{@link #commit}(); + // private + checkHandler : function(item, pressed){ + if(pressed){ + this.setActiveItem(item); + } + }, -// update the record in the store, bypass setting dirty flag, -// and do not store the change in the {@link Ext.data.Store#getModifiedRecords modified records} -rec.{@link #data}['firstname'] = 'Wilma'; // updates record, but not the view -rec.{@link #commit}(); // updates the view - * - * Notes: - * If the store has a writer and autoSave=true, each set() - * will execute an XHR to the server. - * Use {@link #beginEdit} to prevent the store's update - * event firing while using set(). - * Use {@link #endEdit} to have the store's update - * event fire. - * - * @param {String} name The {@link Ext.data.Field#name name of the field} to set. - * @param {String/Object/Array} value The value to set the field to. + /** + * This is normally called internally on button click, but can be called externally to advance the button's + * active item programmatically to the next one in the menu. If the current item is the last one in the menu + * the active item will be set to the first item in the menu. */ - set : function(name, value){ - var encode = Ext.isPrimitive(value) ? String : Ext.encode; - if(encode(this.data[name]) == encode(value)) { - return; - } - this.dirty = true; - if(!this.modified){ - this.modified = {}; + toggleSelected : function(){ + var m = this.menu; + m.render(); + // layout if we haven't before so the items are active + if(!m.hasLayout){ + m.doLayout(); } - if(this.modified[name] === undefined){ - this.modified[name] = this.data[name]; + + var nextIdx, checkItem; + for (var i = 1; i < this.itemCount; i++) { + nextIdx = (this.activeItem.itemIndex + i) % this.itemCount; + // check the potential item + checkItem = m.items.itemAt(nextIdx); + // if its not disabled then check it. + if (!checkItem.disabled) { + checkItem.setChecked(true); + break; + } } - this.data[name] = value; - if(!this.editing){ - this.afterEdit(); + } +}); +Ext.reg('cycle', Ext.CycleButton);/** + * @class Ext.Toolbar + * @extends Ext.Container + * Basic Toolbar class. Although the {@link Ext.Container#defaultType defaultType} for Toolbar + * is {@link Ext.Button button}, Toolbar elements (child items for the Toolbar container) may + * be virtually any type of Component. Toolbar elements can be created explicitly via their constructors, + * or implicitly via their xtypes, and can be {@link #add}ed dynamically. + * Some items have shortcut strings for creation: + * +Shortcut xtype Class Description +'->' 'tbfill' {@link Ext.Toolbar.Fill} begin using the right-justified button container +'-' 'tbseparator' {@link Ext.Toolbar.Separator} add a vertical separator bar between toolbar items +' ' 'tbspacer' {@link Ext.Toolbar.Spacer} add horiztonal space between elements + * + * + * Example usage of various elements: + * +var tb = new Ext.Toolbar({ + renderTo: document.body, + width: 600, + height: 100, + items: [ + { + // xtype: 'button', // default for Toolbars, same as 'tbbutton' + text: 'Button' + }, + { + xtype: 'splitbutton', // same as 'tbsplitbutton' + text: 'Split Button' + }, + // begin using the right-justified button container + '->', // same as {xtype: 'tbfill'}, // Ext.Toolbar.Fill + { + xtype: 'textfield', + name: 'field1', + emptyText: 'enter search term' + }, + // add a vertical separator bar between toolbar items + '-', // same as {xtype: 'tbseparator'} to create Ext.Toolbar.Separator + 'text 1', // same as {xtype: 'tbtext', text: 'text1'} to create Ext.Toolbar.TextItem + {xtype: 'tbspacer'},// same as ' ' to create Ext.Toolbar.Spacer + 'text 2', + {xtype: 'tbspacer', width: 50}, // add a 50px space + 'text 3' + ] +}); + * + * Example adding a ComboBox within a menu of a button: + * +// ComboBox creation +var combo = new Ext.form.ComboBox({ + store: new Ext.data.ArrayStore({ + autoDestroy: true, + fields: ['initials', 'fullname'], + data : [ + ['FF', 'Fred Flintstone'], + ['BR', 'Barney Rubble'] + ] + }), + displayField: 'fullname', + typeAhead: true, + mode: 'local', + forceSelection: true, + triggerAction: 'all', + emptyText: 'Select a name...', + selectOnFocus: true, + width: 135, + getListParent: function() { + return this.el.up('.x-menu'); + }, + iconCls: 'no-icon' //use iconCls if placing within menu to shift to right side of menu +}); + +// put ComboBox in a Menu +var menu = new Ext.menu.Menu({ + id: 'mainMenu', + items: [ + combo // A Field in a Menu + ] +}); + +// add a Button with the menu +tb.add({ + text:'Button w/ Menu', + menu: menu // assign menu by instance + }); +tb.doLayout(); + * + * @constructor + * Creates a new Toolbar + * @param {Object/Array} config A config object or an array of buttons to {@link #add} + * @xtype toolbar + */ +Ext.Toolbar = function(config){ + if(Ext.isArray(config)){ + config = {items: config, layout: 'toolbar'}; + } else { + config = Ext.apply({ + layout: 'toolbar' + }, config); + if(config.buttons) { + config.items = config.buttons; } + } + Ext.Toolbar.superclass.constructor.call(this, config); +}; + +(function(){ + +var T = Ext.Toolbar; + +Ext.extend(T, Ext.Container, { + + defaultType: 'button', + + /** + * @cfg {String/Object} layout + * This class assigns a default layout (layout:'toolbar'). + * Developers may override this configuration option if another layout + * is required (the constructor must be passed a configuration object in this + * case instead of an array). + * See {@link Ext.Container#layout} for additional information. + */ + + enableOverflow : false, + + /** + * @cfg {Boolean} enableOverflow + * Defaults to false. Configure true to make the toolbar provide a button + * which activates a dropdown Menu to show items which overflow the Toolbar's width. + */ + /** + * @cfg {String} buttonAlign + * The default position at which to align child items. Defaults to "left" + * May be specified as "center" to cause items added before a Fill (A "->") item + * to be centered in the Toolbar. Items added after a Fill are still right-aligned. + * Specify as "right" to right align all child items. + */ + + trackMenus : true, + internalDefaults: {removeMode: 'container', hideParent: true}, + toolbarCls: 'x-toolbar', + + initComponent : function(){ + T.superclass.initComponent.call(this); + + /** + * @event overflowchange + * Fires after the overflow state has changed. + * @param {Object} c The Container + * @param {Boolean} lastOverflow overflow state + */ + this.addEvents('overflowchange'); }, // private - afterEdit : function(){ - if(this.store){ - this.store.afterEdit(this); + onRender : function(ct, position){ + if(!this.el){ + if(!this.autoCreate){ + this.autoCreate = { + cls: this.toolbarCls + ' x-small-editor' + }; + } + this.el = ct.createChild(Ext.apply({ id: this.id },this.autoCreate), position); + Ext.Toolbar.superclass.onRender.apply(this, arguments); } }, + /** + * Adds element(s) to the toolbar -- this function takes a variable number of + * arguments of mixed type and adds them to the toolbar. + * Note: See the notes within {@link Ext.Container#add}. + * @param {Mixed} arg1 The following types of arguments are all valid: + * + * {@link Ext.Button} config: A valid button config object (equivalent to {@link #addButton}) + * HtmlElement: Any standard HTML element (equivalent to {@link #addElement}) + * Field: Any form field (equivalent to {@link #addField}) + * Item: Any subclass of {@link Ext.Toolbar.Item} (equivalent to {@link #addItem}) + * String: Any generic string (gets wrapped in a {@link Ext.Toolbar.TextItem}, equivalent to {@link #addText}). + * Note that there are a few special strings that are treated differently as explained next. + * '-': Creates a separator element (equivalent to {@link #addSeparator}) + * ' ': Creates a spacer element (equivalent to {@link #addSpacer}) + * '->': Creates a fill element (equivalent to {@link #addFill}) + * + * @param {Mixed} arg2 + * @param {Mixed} etc. + * @method add + */ + // private - afterReject : function(){ - if(this.store){ - this.store.afterReject(this); + lookupComponent : function(c){ + if(Ext.isString(c)){ + if(c == '-'){ + c = new T.Separator(); + }else if(c == ' '){ + c = new T.Spacer(); + }else if(c == '->'){ + c = new T.Fill(); + }else{ + c = new T.TextItem(c); + } + this.applyDefaults(c); + }else{ + if(c.isFormField || c.render){ // some kind of form field, some kind of Toolbar.Item + c = this.createComponent(c); + }else if(c.tag){ // DomHelper spec + c = new T.Item({autoEl: c}); + }else if(c.tagName){ // element + c = new T.Item({el:c}); + }else if(Ext.isObject(c)){ // must be button config? + c = c.xtype ? this.createComponent(c) : this.constructButton(c); + } } + return c; }, // private - afterCommit : function(){ - if(this.store){ - this.store.afterCommit(this); + applyDefaults : function(c){ + if(!Ext.isString(c)){ + c = Ext.Toolbar.superclass.applyDefaults.call(this, c); + var d = this.internalDefaults; + if(c.events){ + Ext.applyIf(c.initialConfig, d); + Ext.apply(c, d); + }else{ + Ext.applyIf(c, d); + } + } + return c; + }, + + /** + * Adds a separator + * Note: See the notes within {@link Ext.Container#add}. + * @return {Ext.Toolbar.Item} The separator {@link Ext.Toolbar.Item item} + */ + addSeparator : function(){ + return this.add(new T.Separator()); + }, + + /** + * Adds a spacer element + * Note: See the notes within {@link Ext.Container#add}. + * @return {Ext.Toolbar.Spacer} The spacer item + */ + addSpacer : function(){ + return this.add(new T.Spacer()); + }, + + /** + * Forces subsequent additions into the float:right toolbar + * Note: See the notes within {@link Ext.Container#add}. + */ + addFill : function(){ + this.add(new T.Fill()); + }, + + /** + * Adds any standard HTML element to the toolbar + * Note: See the notes within {@link Ext.Container#add}. + * @param {Mixed} el The element or id of the element to add + * @return {Ext.Toolbar.Item} The element's item + */ + addElement : function(el){ + return this.addItem(new T.Item({el:el})); + }, + + /** + * Adds any Toolbar.Item or subclass + * Note: See the notes within {@link Ext.Container#add}. + * @param {Ext.Toolbar.Item} item + * @return {Ext.Toolbar.Item} The item + */ + addItem : function(item){ + return this.add.apply(this, arguments); + }, + + /** + * Adds a button (or buttons). See {@link Ext.Button} for more info on the config. + * Note: See the notes within {@link Ext.Container#add}. + * @param {Object/Array} config A button config or array of configs + * @return {Ext.Button/Array} + */ + addButton : function(config){ + if(Ext.isArray(config)){ + var buttons = []; + for(var i = 0, len = config.length; i < len; i++) { + buttons.push(this.addButton(config[i])); + } + return buttons; } + return this.add(this.constructButton(config)); }, /** - * Get the value of the {@link Ext.data.Field#name named field}. - * @param {String} name The {@link Ext.data.Field#name name of the field} to get the value of. - * @return {Object} The value of the field. + * Adds text to the toolbar + * Note: See the notes within {@link Ext.Container#add}. + * @param {String} text The text to add + * @return {Ext.Toolbar.Item} The element's item */ - get : function(name){ - return this.data[name]; + addText : function(text){ + return this.addItem(new T.TextItem(text)); }, /** - * Begin an edit. While in edit mode, no events (e.g.. the update event) - * are relayed to the containing store. - * See also: {@link #endEdit} and {@link #cancelEdit}. + * Adds a new element to the toolbar from the passed {@link Ext.DomHelper} config + * Note: See the notes within {@link Ext.Container#add}. + * @param {Object} config + * @return {Ext.Toolbar.Item} The element's item */ - beginEdit : function(){ - this.editing = true; - this.modified = this.modified || {}; + addDom : function(config){ + return this.add(new T.Item({autoEl: config})); }, /** - * Cancels all changes made in the current edit operation. + * Adds a dynamically rendered Ext.form field (TextField, ComboBox, etc). Note: the field should not have + * been rendered yet. For a field that has already been rendered, use {@link #addElement}. + * Note: See the notes within {@link Ext.Container#add}. + * @param {Ext.form.Field} field + * @return {Ext.Toolbar.Item} */ - cancelEdit : function(){ - this.editing = false; - delete this.modified; + addField : function(field){ + return this.add(field); }, /** - * End an edit. If any data was modified, the containing store is notified - * (ie, the store's update event will fire). + * Inserts any {@link Ext.Toolbar.Item}/{@link Ext.Button} at the specified index. + * Note: See the notes within {@link Ext.Container#add}. + * @param {Number} index The index where the item is to be inserted + * @param {Object/Ext.Toolbar.Item/Ext.Button/Array} item The button, or button config object to be + * inserted, or an array of buttons/configs. + * @return {Ext.Button/Item} */ - endEdit : function(){ - this.editing = false; - if(this.dirty){ - this.afterEdit(); + insertButton : function(index, item){ + if(Ext.isArray(item)){ + var buttons = []; + for(var i = 0, len = item.length; i < len; i++) { + buttons.push(this.insertButton(index + i, item[i])); + } + return buttons; } + return Ext.Toolbar.superclass.insert.call(this, index, item); }, - /** - * Usually called by the {@link Ext.data.Store} which owns the Record. - * Rejects all changes made to the Record since either creation, or the last commit operation. - * Modified fields are reverted to their original values. - * Developers should subscribe to the {@link Ext.data.Store#update} event - * to have their code notified of reject operations. - * @param {Boolean} silent (optional) True to skip notification of the owning - * store of the change (defaults to false) - */ - reject : function(silent){ - var m = this.modified; - for(var n in m){ - if(typeof m[n] != "function"){ - this.data[n] = m[n]; - } - } - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterReject(); + // private + trackMenu : function(item, remove){ + if(this.trackMenus && item.menu){ + var method = remove ? 'mun' : 'mon'; + this[method](item, 'menutriggerover', this.onButtonTriggerOver, this); + this[method](item, 'menushow', this.onButtonMenuShow, this); + this[method](item, 'menuhide', this.onButtonMenuHide, this); } }, - /** - * Usually called by the {@link Ext.data.Store} which owns the Record. - * Commits all changes made to the Record since either creation, or the last commit operation. - * Developers should subscribe to the {@link Ext.data.Store#update} event - * to have their code notified of commit operations. - * @param {Boolean} silent (optional) True to skip notification of the owning - * store of the change (defaults to false) - */ - commit : function(silent){ - this.dirty = false; - delete this.modified; - this.editing = false; - if(silent !== true){ - this.afterCommit(); - } + // private + constructButton : function(item){ + var b = item.events ? item : this.createComponent(item, item.split ? 'splitbutton' : this.defaultType); + return b; }, - /** - * Gets a hash of only the fields that have been modified since this Record was created or commited. - * @return Object - */ - getChanges : function(){ - var m = this.modified, cs = {}; - for(var n in m){ - if(m.hasOwnProperty(n)){ - cs[n] = this.data[n]; - } + // private + onAdd : function(c){ + Ext.Toolbar.superclass.onAdd.call(this); + this.trackMenu(c); + if(this.disabled){ + c.disable(); } - return cs; }, // private - hasError : function(){ - return this.error !== null; + onRemove : function(c){ + Ext.Toolbar.superclass.onRemove.call(this); + this.trackMenu(c, true); }, // private - clearError : function(){ - this.error = null; + onDisable : function(){ + this.items.each(function(item){ + if(item.disable){ + item.disable(); + } + }); }, - /** - * Creates a copy (clone) of this Record. - * @param {String} id (optional) A new Record id, defaults to the id - * of the record being copied. See {@link #id}. - * To generate a phantom record with a new id use: -var rec = record.copy(); // clone the record -Ext.data.Record.id(rec); // automatically generate a unique sequential id - * - * @return {Record} - */ - copy : function(newId) { - return new this.constructor(Ext.apply({}, this.data), newId || this.id); + // private + onEnable : function(){ + this.items.each(function(item){ + if(item.enable){ + item.enable(); + } + }); }, - /** - * Returns true if the passed field name has been {@link #modified} - * since the load or last commit. - * @param {String} fieldName {@link Ext.data.Field.{@link Ext.data.Field#name} - * @return {Boolean} - */ - isModified : function(fieldName){ - return !!(this.modified && this.modified.hasOwnProperty(fieldName)); + // private + onButtonTriggerOver : function(btn){ + if(this.activeMenuBtn && this.activeMenuBtn != btn){ + this.activeMenuBtn.hideMenu(); + btn.showMenu(); + this.activeMenuBtn = btn; + } }, - /** - * By default returns false if any {@link Ext.data.Field field} within the - * record configured with {@link Ext.data.Field#allowBlank} = false returns - * true from an {@link Ext}.{@link Ext#isEmpty isempty} test. - * @return {Boolean} - */ - isValid : function() { - return this.fields.find(function(f) { - return (f.allowBlank === false && Ext.isEmpty(this.data[f.name])) ? true : false; - },this) ? false : true; + // private + onButtonMenuShow : function(btn){ + this.activeMenuBtn = btn; }, + // private + onButtonMenuHide : function(btn){ + delete this.activeMenuBtn; + } +}); +Ext.reg('toolbar', Ext.Toolbar); + +/** + * @class Ext.Toolbar.Item + * @extends Ext.BoxComponent + * The base class that other non-interacting Toolbar Item classes should extend in order to + * get some basic common toolbar item functionality. + * @constructor + * Creates a new Item + * @param {HTMLElement} el + * @xtype tbitem + */ +T.Item = Ext.extend(Ext.BoxComponent, { + hideParent: true, // Hiding a Toolbar.Item hides its containing TD + enable:Ext.emptyFn, + disable:Ext.emptyFn, + focus:Ext.emptyFn /** - * Marks this Record as {@link #dirty}. This method - * is used interally when adding {@link #phantom} records to a - * {@link Ext.data.Store#writer writer enabled store}. - * Marking a record {@link #dirty} causes the phantom to - * be returned by {@link Ext.data.Store#getModifiedRecords} where it will - * have a create action composed for it during {@link Ext.data.Store#save store save} - * operations. + * @cfg {String} overflowText Text to be used for the menu if the item is overflowed. */ - markDirty : function(){ - this.dirty = true; - if(!this.modified){ - this.modified = {}; - } - this.fields.each(function(f) { - this.modified[f.name] = this.data[f.name]; - },this); +}); +Ext.reg('tbitem', T.Item); + +/** + * @class Ext.Toolbar.Separator + * @extends Ext.Toolbar.Item + * A simple class that adds a vertical separator bar between toolbar items + * (css class:'xtb-sep'). Example usage: + * +new Ext.Panel({ + tbar : [ + 'Item 1', + {xtype: 'tbseparator'}, // or '-' + 'Item 2' + ] +}); + + * @constructor + * Creates a new Separator + * @xtype tbseparator + */ +T.Separator = Ext.extend(T.Item, { + onRender : function(ct, position){ + this.el = ct.createChild({tag:'span', cls:'xtb-sep'}, position); } -}; +}); +Ext.reg('tbseparator', T.Separator); + /** - * @class Ext.StoreMgr - * @extends Ext.util.MixedCollection - * The default global group of stores. - * @singleton + * @class Ext.Toolbar.Spacer + * @extends Ext.Toolbar.Item + * A simple element that adds extra horizontal space between items in a toolbar. + * By default a 2px wide space is added via css specification: +.x-toolbar .xtb-spacer { + width:2px; +} + * + * Example usage: + * +new Ext.Panel({ + tbar : [ + 'Item 1', + {xtype: 'tbspacer'}, // or ' ' + 'Item 2', + // space width is also configurable via javascript + {xtype: 'tbspacer', width: 50}, // add a 50px space + 'Item 3' + ] +}); + + * @constructor + * Creates a new Spacer + * @xtype tbspacer */ -Ext.StoreMgr = Ext.apply(new Ext.util.MixedCollection(), { +T.Spacer = Ext.extend(T.Item, { /** - * @cfg {Object} listeners @hide + * @cfg {Number} width + * The width of the spacer in pixels (defaults to 2px via css style .x-toolbar .xtb-spacer). */ + onRender : function(ct, position){ + this.el = ct.createChild({tag:'div', cls:'xtb-spacer', style: this.width?'width:'+this.width+'px':''}, position); + } +}); +Ext.reg('tbspacer', T.Spacer); + +/** + * @class Ext.Toolbar.Fill + * @extends Ext.Toolbar.Spacer + * A non-rendering placeholder item which instructs the Toolbar's Layout to begin using + * the right-justified button container. + * +new Ext.Panel({ + tbar : [ + 'Item 1', + {xtype: 'tbfill'}, // or '->' + 'Item 2' + ] +}); + + * @constructor + * Creates a new Fill + * @xtype tbfill + */ +T.Fill = Ext.extend(T.Item, { + // private + render : Ext.emptyFn, + isFill : true +}); +Ext.reg('tbfill', T.Fill); + +/** + * @class Ext.Toolbar.TextItem + * @extends Ext.Toolbar.Item + * A simple class that renders text directly into a toolbar + * (with css class:'xtb-text'). Example usage: + * +new Ext.Panel({ + tbar : [ + {xtype: 'tbtext', text: 'Item 1'} // or simply 'Item 1' + ] +}); + + * @constructor + * Creates a new TextItem + * @param {String/Object} text A text string, or a config object containing a text property + * @xtype tbtext + */ +T.TextItem = Ext.extend(T.Item, { /** - * Registers one or more Stores with the StoreMgr. You do not normally need to register stores - * manually. Any store initialized with a {@link Ext.data.Store#storeId} will be auto-registered. - * @param {Ext.data.Store} store1 A Store instance - * @param {Ext.data.Store} store2 (optional) - * @param {Ext.data.Store} etc... (optional) + * @cfg {String} text The text to be used as innerHTML (html tags are accepted) */ - register : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.add(s); - } + + constructor: function(config){ + T.TextItem.superclass.constructor.call(this, Ext.isString(config) ? {text: config} : config); + }, + + // private + onRender : function(ct, position) { + this.autoEl = {cls: 'xtb-text', html: this.text || ''}; + T.TextItem.superclass.onRender.call(this, ct, position); }, /** - * Unregisters one or more Stores with the StoreMgr - * @param {String/Object} id1 The id of the Store, or a Store instance - * @param {String/Object} id2 (optional) - * @param {String/Object} etc... (optional) + * Updates this item's text, setting the text to be used as innerHTML. + * @param {String} t The text to display (html accepted). */ - unregister : function(){ - for(var i = 0, s; (s = arguments[i]); i++){ - this.remove(this.lookup(s)); + setText : function(t) { + if(this.rendered){ + this.el.update(t); + }else{ + this.text = t; } - }, + } +}); +Ext.reg('tbtext', T.TextItem); + +// backwards compat +T.Button = Ext.extend(Ext.Button, {}); +T.SplitButton = Ext.extend(Ext.SplitButton, {}); +Ext.reg('tbbutton', T.Button); +Ext.reg('tbsplit', T.SplitButton); +})(); +/** + * @class Ext.ButtonGroup + * @extends Ext.Panel + * Container for a group of buttons. Example usage: + * +var p = new Ext.Panel({ + title: 'Panel with Button Group', + width: 300, + height:200, + renderTo: document.body, + html: 'whatever', + tbar: [{ + xtype: 'buttongroup', + {@link #columns}: 3, + title: 'Clipboard', + items: [{ + text: 'Paste', + scale: 'large', + rowspan: 3, iconCls: 'add', + iconAlign: 'top', + cls: 'x-btn-as-arrow' + },{ + xtype:'splitbutton', + text: 'Menu Button', + scale: 'large', + rowspan: 3, + iconCls: 'add', + iconAlign: 'top', + arrowAlign:'bottom', + menu: [{text: 'Menu Item 1'}] + },{ + xtype:'splitbutton', text: 'Cut', iconCls: 'add16', menu: [{text: 'Cut Menu Item'}] + },{ + text: 'Copy', iconCls: 'add16' + },{ + text: 'Format', iconCls: 'add16' + }] + }] +}); + * + * @constructor + * Create a new ButtonGroup. + * @param {Object} config The config object + * @xtype buttongroup + */ +Ext.ButtonGroup = Ext.extend(Ext.Panel, { /** - * Gets a registered Store by id - * @param {String/Object} id The id of the Store, or a Store instance - * @return {Ext.data.Store} + * @cfg {Number} columns The columns configuration property passed to the + * {@link #layout configured layout manager}. See {@link Ext.layout.TableLayout#columns}. */ - lookup : function(id){ - if(Ext.isArray(id)){ - var fields = ['field1'], expand = !Ext.isArray(id[0]); - if(!expand){ - for(var i = 2, len = id[0].length; i <= len; ++i){ - fields.push('field' + i); - } - } - return new Ext.data.ArrayStore({ - fields: fields, - data: id, - expandData: expand, - autoDestroy: true, - autoCreated: true + /** + * @cfg {String} baseCls Defaults to 'x-btn-group'. See {@link Ext.Panel#baseCls}. + */ + baseCls: 'x-btn-group', + /** + * @cfg {String} layout Defaults to 'table'. See {@link Ext.Container#layout}. + */ + layout:'table', + defaultType: 'button', + /** + * @cfg {Boolean} frame Defaults to true. See {@link Ext.Panel#frame}. + */ + frame: true, + internalDefaults: {removeMode: 'container', hideParent: true}, - }); + initComponent : function(){ + this.layoutConfig = this.layoutConfig || {}; + Ext.applyIf(this.layoutConfig, { + columns : this.columns + }); + if(!this.title){ + this.addClass('x-btn-group-notitle'); } - return Ext.isObject(id) ? (id.events ? id : Ext.create(id, 'store')) : this.get(id); + this.on('afterlayout', this.onAfterLayout, this); + Ext.ButtonGroup.superclass.initComponent.call(this); }, - // getKey implementation for MixedCollection - getKey : function(o){ - return o.storeId; + applyDefaults : function(c){ + c = Ext.ButtonGroup.superclass.applyDefaults.call(this, c); + var d = this.internalDefaults; + if(c.events){ + Ext.applyIf(c.initialConfig, d); + Ext.apply(c, d); + }else{ + Ext.applyIf(c, d); + } + return c; + }, + + onAfterLayout : function(){ + var bodyWidth = this.body.getFrameWidth('lr') + this.body.dom.firstChild.offsetWidth; + this.body.setWidth(bodyWidth); + this.el.setWidth(bodyWidth + this.getFrameWidth()); } -});/** - * @class Ext.data.Store - * @extends Ext.util.Observable - * The Store class encapsulates a client side cache of {@link Ext.data.Record Record} - * objects which provide input data for Components such as the {@link Ext.grid.GridPanel GridPanel}, - * the {@link Ext.form.ComboBox ComboBox}, or the {@link Ext.DataView DataView}. - * Retrieving Data - * A Store object may access a data object using: - * {@link #proxy configured implementation} of {@link Ext.data.DataProxy DataProxy} - * {@link #data} to automatically pass in data - * {@link #loadData} to manually pass in data - * - * Reading Data - * A Store object has no inherent knowledge of the format of the data object (it could be - * an Array, XML, or JSON). A Store object uses an appropriate {@link #reader configured implementation} - * of a {@link Ext.data.DataReader DataReader} to create {@link Ext.data.Record Record} instances from the data - * object. - * Store Types - * There are several implementations of Store available which are customized for use with - * a specific DataReader implementation. Here is an example using an ArrayStore which implicitly - * creates a reader commensurate to an Array data object. - * -var myStore = new Ext.data.ArrayStore({ - fields: ['fullname', 'first'], - idIndex: 0 // id for each record will be the first element + /** + * @cfg {Array} tools @hide + */ }); - * - * For custom implementations create a basic {@link Ext.data.Store} configured as needed: + +Ext.reg('buttongroup', Ext.ButtonGroup); +/** + * @class Ext.PagingToolbar + * @extends Ext.Toolbar + * As the amount of records increases, the time required for the browser to render + * them increases. Paging is used to reduce the amount of data exchanged with the client. + * Note: if there are more records/rows than can be viewed in the available screen area, vertical + * scrollbars will be added. + * Paging is typically handled on the server side (see exception below). The client sends + * parameters to the server side, which the server needs to interpret and then respond with the + * approprate data. + * Ext.PagingToolbar is a specialized toolbar that is bound to a {@link Ext.data.Store} + * and provides automatic paging control. This Component {@link Ext.data.Store#load load}s blocks + * of data into the {@link #store} by passing {@link Ext.data.Store#paramNames paramNames} used for + * paging criteria. + * PagingToolbar is typically used as one of the Grid's toolbars: * -// create a {@link Ext.data.Record Record} constructor: -var rt = Ext.data.Record.create([ - {name: 'fullname'}, - {name: 'first'} -]); +Ext.QuickTips.init(); // to display button quicktips + var myStore = new Ext.data.Store({ - // explicitly create reader - reader: new Ext.data.ArrayReader( - { - idIndex: 0 // id for each record will be the first element - }, - rt // recordType - ) + reader: new Ext.data.JsonReader({ + {@link Ext.data.JsonReader#totalProperty totalProperty}: 'results', + ... + }), + ... +}); + +var myPageSize = 25; // server script should only send back 25 items at a time + +var grid = new Ext.grid.GridPanel({ + ... + store: myStore, + bbar: new Ext.PagingToolbar({ + {@link #store}: myStore, // grid and PagingToolbar using same store + {@link #displayInfo}: true, + {@link #pageSize}: myPageSize, + {@link #prependButtons}: true, + items: [ + 'text 1' + ] + }) +}); + * + * + * To use paging, pass the paging requirements to the server when the store is first loaded. + * +store.load({ + params: { + // specify params for the first page load if using paging + start: 0, + limit: myPageSize, + // other params + foo: 'bar' + } }); * - * Load some data into store (note the data object is an array which corresponds to the reader): + * + * If using {@link Ext.data.Store#autoLoad store's autoLoad} configuration: * -var myData = [ - [1, 'Fred Flintstone', 'Fred'], // note that id for the record is the first element - [2, 'Barney Rubble', 'Barney'] -]; -myStore.loadData(myData); +var myStore = new Ext.data.Store({ + {@link Ext.data.Store#autoLoad autoLoad}: {params:{start: 0, limit: 25}}, + ... +}); * - * Records are cached and made available through accessor functions. An example of adding - * a record to the store: + * + * The packet sent back from the server would have this form: * -var defaultData = { - fullname: 'Full Name', - first: 'First Name' -}; -var recId = 100; // provide unique id for the record -var r = new myStore.recordType(defaultData, ++recId); // create new record -myStore.{@link #insert}(0, r); // insert a new record into the store (also see {@link #add}) +{ + "success": true, + "results": 2000, + "rows": [ // *Note: this must be an Array + { "id": 1, "name": "Bill", "occupation": "Gardener" }, + { "id": 2, "name": "Ben", "occupation": "Horticulturalist" }, + ... + { "id": 25, "name": "Sue", "occupation": "Botanist" } + ] +} * - * Writing Data - * And new in Ext version 3, use the new {@link Ext.data.DataWriter DataWriter} to create an automated, Writable Store - * along with RESTful features. - * @constructor - * Creates a new Store. - * @param {Object} config A config object containing the objects needed for the Store to access data, - * and read the data into Records. - * @xtype store + * Paging with Local Data + * Paging can also be accomplished with local data using extensions: + * + * Ext.ux.data.PagingStore + * Paging Memory Proxy (examples/ux/PagingMemoryProxy.js) + * + * @constructor Create a new PagingToolbar + * @param {Object} config The config object + * @xtype paging */ -Ext.data.Store = Ext.extend(Ext.util.Observable, { - /** - * @cfg {String} storeId If passed, the id to use to register with the {@link Ext.StoreMgr StoreMgr}. - * Note: if a (deprecated) {@link #id} is specified it will supersede the storeId - * assignment. - */ - /** - * @cfg {String} url If a {@link #proxy} is not specified the url will be used to - * implicitly configure a {@link Ext.data.HttpProxy HttpProxy} if an url is specified. - * Typically this option, or the {@link #data} option will be specified. - */ - /** - * @cfg {Boolean/Object} autoLoad If {@link #data} is not specified, and if autoLoad - * is true or an Object, this store's {@link #load} method is automatically called - * after creation. If the value of autoLoad is an Object, this Object will - * be passed to the store's {@link #load} method. - */ - /** - * @cfg {Ext.data.DataProxy} proxy The {@link Ext.data.DataProxy DataProxy} object which provides - * access to a data object. See {@link #url}. - */ +(function() { + +var T = Ext.Toolbar; + +Ext.PagingToolbar = Ext.extend(Ext.Toolbar, { /** - * @cfg {Array} data An inline data object readable by the {@link #reader}. - * Typically this option, or the {@link #url} option will be specified. + * @cfg {Ext.data.Store} store + * The {@link Ext.data.Store} the paging toolbar should use as its data source (required). */ /** - * @cfg {Ext.data.DataReader} reader The {@link Ext.data.DataReader Reader} object which processes the - * data object and returns an Array of {@link Ext.data.Record} objects which are cached keyed by their - * {@link Ext.data.Record#id id} property. + * @cfg {Boolean} displayInfo + * true to display the displayMsg (defaults to false) */ /** - * @cfg {Ext.data.DataWriter} writer - * The {@link Ext.data.DataWriter Writer} object which processes a record object for being written - * to the server-side database. - * When a writer is installed into a Store the {@link #add}, {@link #remove}, and {@link #update} - * events on the store are monitored in order to remotely {@link #createRecords create records}, - * {@link #destroyRecord destroy records}, or {@link #updateRecord update records}. - * The proxy for this store will relay any {@link #writexception} events to this store. - * Sample implementation: - * -var writer = new {@link Ext.data.JsonWriter}({ - encode: true, - writeAllFields: true // write all fields, not just those that changed -}); - -// Typical Store collecting the Proxy, Reader and Writer together. -var store = new Ext.data.Store({ - storeId: 'user', - root: 'records', - proxy: proxy, - reader: reader, - writer: writer, // <-- plug a DataWriter into the store just as you would a Reader - paramsAsHash: true, - autoSave: false // <-- false to delay executing create, update, destroy requests - // until specifically told to do so. -}); - * + * @cfg {Number} pageSize + * The number of records to display per page (defaults to 20) */ - writer : undefined, + pageSize : 20, /** - * @cfg {Object} baseParams - * An object containing properties which are to be sent as parameters - * for every HTTP request. - * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. - * Note: baseParams may be superseded by any params - * specified in a {@link #load} request, see {@link #load} - * for more details. - * This property may be modified after creation using the {@link #setBaseParam} - * method. - * @property + * @cfg {Boolean} prependButtons + * true to insert any configured items before the paging buttons. + * Defaults to false. */ /** - * @cfg {Object} sortInfo A config object to specify the sort order in the request of a Store's - * {@link #load} operation. Note that for local sorting, the direction property is - * case-sensitive. See also {@link #remoteSort} and {@link #paramNames}. - * For example: -sortInfo: { - field: 'fieldName', - direction: 'ASC' // or 'DESC' (case sensitive for local sorting) -} - + * @cfg {String} displayMsg + * The paging status message to display (defaults to 'Displaying {0} - {1} of {2}'). + * Note that this string is formatted using the braced numbers {0}-{2} as tokens + * that are replaced by the values for start, end and total respectively. These tokens should + * be preserved when overriding this string if showing those values is desired. */ + displayMsg : 'Displaying {0} - {1} of {2}', /** - * @cfg {boolean} remoteSort true if sorting is to be handled by requesting the {@link #proxy Proxy} - * to provide a refreshed version of the data object in sorted order, as opposed to sorting the Record cache - * in place (defaults to false). - * If remoteSort is true, then clicking on a {@link Ext.grid.Column Grid Column}'s - * {@link Ext.grid.Column#header header} causes the current page to be requested from the server appending - * the following two parameters to the {@link #load params}: - * sort : StringThe name (as specified in the Record's - * {@link Ext.data.Field Field definition}) of the field to sort on. - * dir : StringThe direction of the sort, 'ASC' or 'DESC' (case-sensitive). - * + * @cfg {String} emptyMsg + * The message to display when no records are found (defaults to 'No data to display') */ - remoteSort : false, - + emptyMsg : 'No data to display', /** - * @cfg {Boolean} autoDestroy true to destroy the store when the component the store is bound - * to is destroyed (defaults to false). - * Note: this should be set to true when using stores that are bound to only 1 component. + * @cfg {String} beforePageText + * The text displayed before the input item (defaults to 'Page'). */ - autoDestroy : false, - + beforePageText : 'Page', /** - * @cfg {Boolean} pruneModifiedRecords true to clear all modified record information each time - * the store is loaded or when a record is removed (defaults to false). See {@link #getModifiedRecords} - * for the accessor method to retrieve the modified records. + * @cfg {String} afterPageText + * Customizable piece of the default paging text (defaults to 'of {0}'). Note that + * this string is formatted using {0} as a token that is replaced by the number of + * total pages. This token should be preserved when overriding this string if showing the + * total page count is desired. */ - pruneModifiedRecords : false, - + afterPageText : 'of {0}', /** - * Contains the last options object used as the parameter to the {@link #load} method. See {@link #load} - * for the details of what this may contain. This may be useful for accessing any params which were used - * to load the current Record cache. - * @property + * @cfg {String} firstText + * The quicktip text displayed for the first page button (defaults to 'First Page'). + * Note: quick tips must be initialized for the quicktip to show. */ - lastOptions : null, - + firstText : 'First Page', /** - * @cfg {Boolean} autoSave - * Defaults to true causing the store to automatically {@link #save} records to - * the server when a record is modified (ie: becomes 'dirty'). Specify false to manually call {@link #save} - * to send all modifiedRecords to the server. - * Note: each CRUD action will be sent as a separate request. + * @cfg {String} prevText + * The quicktip text displayed for the previous page button (defaults to 'Previous Page'). + * Note: quick tips must be initialized for the quicktip to show. */ - autoSave : true, - + prevText : 'Previous Page', /** - * @cfg {Boolean} batch - * Defaults to true (unless {@link #restful}:true). Multiple - * requests for each CRUD action (CREATE, READ, UPDATE and DESTROY) will be combined - * and sent as one transaction. Only applies when {@link #autoSave} is set - * to false. - * If Store is RESTful, the DataProxy is also RESTful, and a unique transaction is - * generated for each record. + * @cfg {String} nextText + * The quicktip text displayed for the next page button (defaults to 'Next Page'). + * Note: quick tips must be initialized for the quicktip to show. */ - batch : true, - + nextText : 'Next Page', /** - * @cfg {Boolean} restful - * Defaults to false. Set to true to have the Store and the set - * Proxy operate in a RESTful manner. The store will automatically generate GET, POST, - * PUT and DELETE requests to the server. The HTTP method used for any given CRUD - * action is described in {@link Ext.data.Api#restActions}. For additional information - * see {@link Ext.data.DataProxy#restful}. - * Note: if {@link #restful}:true batch will - * internally be set to false. + * @cfg {String} lastText + * The quicktip text displayed for the last page button (defaults to 'Last Page'). + * Note: quick tips must be initialized for the quicktip to show. */ - restful: false, - + lastText : 'Last Page', /** - * @cfg {Object} paramNames - * An object containing properties which specify the names of the paging and - * sorting parameters passed to remote servers when loading blocks of data. By default, this - * object takes the following form: -{ - start : 'start', // The parameter name which specifies the start row - limit : 'limit', // The parameter name which specifies number of rows to return - sort : 'sort', // The parameter name which specifies the column to sort on - dir : 'dir' // The parameter name which specifies the sort direction -} - - * The server must produce the requested data block upon receipt of these parameter names. - * If different parameter names are required, this property can be overriden using a configuration - * property. - * A {@link Ext.PagingToolbar PagingToolbar} bound to this Store uses this property to determine - * the parameter names to use in its {@link #load requests}. + * @cfg {String} refreshText + * The quicktip text displayed for the Refresh button (defaults to 'Refresh'). + * Note: quick tips must be initialized for the quicktip to show. */ - paramNames : undefined, + refreshText : 'Refresh', /** - * @cfg {Object} defaultParamNames - * Provides the default values for the {@link #paramNames} property. To globally modify the parameters - * for all stores, this object should be changed on the store prototype. + * Deprecated. paramNames should be set in the data store + * (see {@link Ext.data.Store#paramNames}). + * Object mapping of parameter names used for load calls, initially set to: + * {start: 'start', limit: 'limit'} + * @type Object + * @property paramNames + * @deprecated */ - defaultParamNames : { - start : 'start', - limit : 'limit', - sort : 'sort', - dir : 'dir' - }, - - // private - batchKey : '_ext_batch_', - - constructor : function(config){ - this.data = new Ext.util.MixedCollection(false); - this.data.getKey = function(o){ - return o.id; - }; - - - // temporary removed-records cache - this.removed = []; - - if(config && config.data){ - this.inlineData = config.data; - delete config.data; - } - - Ext.apply(this, config); - - /** - * See the {@link #baseParams corresponding configuration option} - * for a description of this property. - * To modify this property see {@link #setBaseParam}. - * @property - */ - this.baseParams = Ext.isObject(this.baseParams) ? this.baseParams : {}; - - this.paramNames = Ext.applyIf(this.paramNames || {}, this.defaultParamNames); - - if((this.url || this.api) && !this.proxy){ - this.proxy = new Ext.data.HttpProxy({url: this.url, api: this.api}); - } - // If Store is RESTful, so too is the DataProxy - if (this.restful === true && this.proxy) { - // When operating RESTfully, a unique transaction is generated for each record. - // TODO might want to allow implemention of faux REST where batch is possible using RESTful routes only. - this.batch = false; - Ext.data.Api.restify(this.proxy); - } - - if(this.reader){ // reader passed - if(!this.recordType){ - this.recordType = this.reader.recordType; - } - if(this.reader.onMetaChange){ - this.reader.onMetaChange = this.reader.onMetaChange.createSequence(this.onMetaChange, this); - } - if (this.writer) { // writer passed - if (this.writer instanceof(Ext.data.DataWriter) === false) { // <-- config-object instead of instance. - this.writer = this.buildWriter(this.writer); - } - this.writer.meta = this.reader.meta; - this.pruneModifiedRecords = true; - } - } - - /** - * The {@link Ext.data.Record Record} constructor as supplied to (or created by) the - * {@link Ext.data.DataReader Reader}. Read-only. - * If the Reader was constructed by passing in an Array of {@link Ext.data.Field} definition objects, - * instead of a Record constructor, it will implicitly create a Record constructor from that Array (see - * {@link Ext.data.Record}.{@link Ext.data.Record#create create} for additional details). - * This property may be used to create new Records of the type held in this Store, for example: - // create the data store - var store = new Ext.data.ArrayStore({ - autoDestroy: true, - fields: [ - {name: 'company'}, - {name: 'price', type: 'float'}, - {name: 'change', type: 'float'}, - {name: 'pctChange', type: 'float'}, - {name: 'lastChange', type: 'date', dateFormat: 'n/j h:ia'} - ] - }); - store.loadData(myData); - - // create the Grid - var grid = new Ext.grid.EditorGridPanel({ - store: store, - colModel: new Ext.grid.ColumnModel({ - columns: [ - {id:'company', header: 'Company', width: 160, dataIndex: 'company'}, - {header: 'Price', renderer: 'usMoney', dataIndex: 'price'}, - {header: 'Change', renderer: change, dataIndex: 'change'}, - {header: '% Change', renderer: pctChange, dataIndex: 'pctChange'}, - {header: 'Last Updated', width: 85, - renderer: Ext.util.Format.dateRenderer('m/d/Y'), - dataIndex: 'lastChange'} - ], - defaults: { - sortable: true, - width: 75 - } - }), - autoExpandColumn: 'company', // match the id specified in the column model - height:350, - width:600, - title:'Array Grid', - tbar: [{ - text: 'Add Record', - handler : function(){ - var defaultData = { - change: 0, - company: 'New Company', - lastChange: (new Date()).clearTime(), - pctChange: 0, - price: 10 - }; - var recId = 3; // provide unique id - var p = new store.recordType(defaultData, recId); // create new record - grid.stopEditing(); - store.{@link #insert}(0, p); // insert a new record into the store (also see {@link #add}) - grid.startEditing(0, 0); - } - }] - }); - * - * @property recordType - * @type Function - */ - - if(this.recordType){ - /** - * A {@link Ext.util.MixedCollection MixedCollection} containing the defined {@link Ext.data.Field Field}s - * for the {@link Ext.data.Record Records} stored in this Store. Read-only. - * @property fields - * @type Ext.util.MixedCollection - */ - this.fields = this.recordType.prototype.fields; - } - this.modified = []; - this.addEvents( - /** - * @event datachanged - * Fires when the data cache has changed in a bulk manner (e.g., it has been sorted, filtered, etc.) and a - * widget that is using this Store as a Record cache should refresh its view. - * @param {Store} this - */ - 'datachanged', - /** - * @event metachange - * Fires when this store's reader provides new metadata (fields). This is currently only supported for JsonReaders. - * @param {Store} this - * @param {Object} meta The JSON metadata - */ - 'metachange', - /** - * @event add - * Fires when Records have been {@link #add}ed to the Store - * @param {Store} this - * @param {Ext.data.Record[]} records The array of Records added - * @param {Number} index The index at which the record(s) were added - */ - 'add', - /** - * @event remove - * Fires when a Record has been {@link #remove}d from the Store - * @param {Store} this - * @param {Ext.data.Record} record The Record that was removed - * @param {Number} index The index at which the record was removed - */ - 'remove', - /** - * @event update - * Fires when a Record has been updated - * @param {Store} this - * @param {Ext.data.Record} record The Record that was updated - * @param {String} operation The update operation being performed. Value may be one of: - * - Ext.data.Record.EDIT - Ext.data.Record.REJECT - Ext.data.Record.COMMIT - * - */ - 'update', - /** - * @event clear - * Fires when the data cache has been cleared. - * @param {Store} this - * @param {Record[]} The records that were cleared. - */ - 'clear', - /** - * @event exception - * Fires if an exception occurs in the Proxy during a remote request. - * This event is relayed through the corresponding {@link Ext.data.DataProxy}. - * See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception} - * for additional details. - * @param {misc} misc See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception} - * for description. - */ - 'exception', - /** - * @event beforeload - * Fires before a request is made for a new data object. If the beforeload handler returns - * false the {@link #load} action will be canceled. - * @param {Store} this - * @param {Object} options The loading options that were specified (see {@link #load} for details) - */ - 'beforeload', - /** - * @event load - * Fires after a new set of Records has been loaded. - * @param {Store} this - * @param {Ext.data.Record[]} records The Records that were loaded - * @param {Object} options The loading options that were specified (see {@link #load} for details) - */ - 'load', - /** - * @event loadexception - * This event is deprecated in favor of the catch-all {@link #exception} - * event instead. - * This event is relayed through the corresponding {@link Ext.data.DataProxy}. - * See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#loadexception loadexception} - * for additional details. - * @param {misc} misc See {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#loadexception loadexception} - * for description. - */ - 'loadexception', - /** - * @event beforewrite - * @param {Ext.data.Store} store - * @param {String} action [Ext.data.Api.actions.create|update|destroy] - * @param {Record/Array[Record]} rs - * @param {Object} options The loading options that were specified. Edit options.params to add Http parameters to the request. (see {@link #save} for details) - * @param {Object} arg The callback's arg object passed to the {@link #request} function - */ - 'beforewrite', - /** - * @event write - * Fires if the server returns 200 after an Ext.data.Api.actions CRUD action. - * Success of the action is determined in the result['successProperty']property (NOTE for RESTful stores, - * a simple 20x response is sufficient for the actions "destroy" and "update". The "create" action should should return 200 along with a database pk). - * @param {Ext.data.Store} store - * @param {String} action [Ext.data.Api.actions.create|update|destroy] - * @param {Object} result The 'data' picked-out out of the response for convenience. - * @param {Ext.Direct.Transaction} res - * @param {Record/Record[]} rs Store's records, the subject(s) of the write-action - */ - 'write', + /** + * The number of records to display per page. See also {@link #cursor}. + * @type Number + * @property pageSize + */ + + /** + * Indicator for the record position. This property might be used to get the active page + * number for example: + * // t is reference to the paging toolbar instance + * var activePage = Math.ceil((t.cursor + t.pageSize) / t.pageSize); + * + * @type Number + * @property cursor + */ + + initComponent : function(){ + var pagingItems = [this.first = new T.Button({ + tooltip: this.firstText, + overflowText: this.firstText, + iconCls: 'x-tbar-page-first', + disabled: true, + handler: this.moveFirst, + scope: this + }), this.prev = new T.Button({ + tooltip: this.prevText, + overflowText: this.prevText, + iconCls: 'x-tbar-page-prev', + disabled: true, + handler: this.movePrevious, + scope: this + }), '-', this.beforePageText, + this.inputItem = new Ext.form.NumberField({ + cls: 'x-tbar-page-number', + allowDecimals: false, + allowNegative: false, + enableKeyEvents: true, + selectOnFocus: true, + submitValue: false, + listeners: { + scope: this, + keydown: this.onPagingKeyDown, + blur: this.onPagingBlur + } + }), this.afterTextItem = new T.TextItem({ + text: String.format(this.afterPageText, 1) + }), '-', this.next = new T.Button({ + tooltip: this.nextText, + overflowText: this.nextText, + iconCls: 'x-tbar-page-next', + disabled: true, + handler: this.moveNext, + scope: this + }), this.last = new T.Button({ + tooltip: this.lastText, + overflowText: this.lastText, + iconCls: 'x-tbar-page-last', + disabled: true, + handler: this.moveLast, + scope: this + }), '-', this.refresh = new T.Button({ + tooltip: this.refreshText, + overflowText: this.refreshText, + iconCls: 'x-tbar-loading', + handler: this.doRefresh, + scope: this + })]; + + + var userItems = this.items || this.buttons || []; + if (this.prependButtons) { + this.items = userItems.concat(pagingItems); + }else{ + this.items = pagingItems.concat(userItems); + } + delete this.buttons; + if(this.displayInfo){ + this.items.push('->'); + this.items.push(this.displayItem = new T.TextItem({})); + } + Ext.PagingToolbar.superclass.initComponent.call(this); + this.addEvents( /** - * @event beforesave - * Fires before a save action is called. A save encompasses destroying records, updating records and creating records. - * @param {Ext.data.Store} store - * @param {Object} data An object containing the data that is to be saved. The object will contain a key for each appropriate action, - * with an array of records for each action. + * @event change + * Fires after the active page has been changed. + * @param {Ext.PagingToolbar} this + * @param {Object} pageData An object that has these properties: + * total : Number The total number of records in the dataset as + * returned by the server + * activePage : Number The current page number + * pages : Number The total number of pages (calculated from + * the total number of records in the dataset as returned by the server and the current {@link #pageSize}) + * */ - 'beforesave', + 'change', /** - * @event save - * Fires after a save is completed. A save encompasses destroying records, updating records and creating records. - * @param {Ext.data.Store} store - * @param {Number} batch The identifier for the batch that was saved. - * @param {Object} data An object containing the data that is to be saved. The object will contain a key for each appropriate action, - * with an array of records for each action. + * @event beforechange + * Fires just before the active page is changed. + * Return false to prevent the active page from being changed. + * @param {Ext.PagingToolbar} this + * @param {Object} params An object hash of the parameters which the PagingToolbar will send when + * loading the required page. This will contain: + * start : Number The starting row number for the next page of records to + * be retrieved from the server + * limit : Number The number of records to be retrieved from the server + * + * (note: the names of the start and limit properties are determined + * by the store's {@link Ext.data.Store#paramNames paramNames} property.) + * Parameters may be added as required in the event handler. */ - 'save' - + 'beforechange' ); + this.on('afterlayout', this.onFirstLayout, this, {single: true}); + this.cursor = 0; + this.bindStore(this.store, true); + }, - if(this.proxy){ - // TODO remove deprecated loadexception with ext-3.0.1 - this.relayEvents(this.proxy, ['loadexception', 'exception']); + // private + onFirstLayout : function(){ + if(this.dsLoaded){ + this.onLoad.apply(this, this.dsLoaded); } - // With a writer set for the Store, we want to listen to add/remove events to remotely create/destroy records. - if (this.writer) { - this.on({ - scope: this, - add: this.createRecords, - remove: this.destroyRecord, - update: this.updateRecord, - clear: this.onClear - }); + }, + + // private + updateInfo : function(){ + if(this.displayItem){ + var count = this.store.getCount(); + var msg = count == 0 ? + this.emptyMsg : + String.format( + this.displayMsg, + this.cursor+1, this.cursor+count, this.store.getTotalCount() + ); + this.displayItem.setText(msg); } + }, - this.sortToggle = {}; - if(this.sortField){ - this.setDefaultSort(this.sortField, this.sortDir); - }else if(this.sortInfo){ - this.setDefaultSort(this.sortInfo.field, this.sortInfo.direction); + // private + onLoad : function(store, r, o){ + if(!this.rendered){ + this.dsLoaded = [store, r, o]; + return; } + var p = this.getParams(); + this.cursor = (o.params && o.params[p.start]) ? o.params[p.start] : 0; + var d = this.getPageData(), ap = d.activePage, ps = d.pages; - Ext.data.Store.superclass.constructor.call(this); + this.afterTextItem.setText(String.format(this.afterPageText, d.pages)); + this.inputItem.setValue(ap); + this.first.setDisabled(ap == 1); + this.prev.setDisabled(ap == 1); + this.next.setDisabled(ap == ps); + this.last.setDisabled(ap == ps); + this.refresh.enable(); + this.updateInfo(); + this.fireEvent('change', this, d); + }, - if(this.id){ - this.storeId = this.id; - delete this.id; + // private + getPageData : function(){ + var total = this.store.getTotalCount(); + return { + total : total, + activePage : Math.ceil((this.cursor+this.pageSize)/this.pageSize), + pages : total < this.pageSize ? 1 : Math.ceil(total/this.pageSize) + }; + }, + + /** + * Change the active page + * @param {Integer} page The page to display + */ + changePage : function(page){ + this.doLoad(((page-1) * this.pageSize).constrain(0, this.store.getTotalCount())); + }, + + // private + onLoadError : function(){ + if(!this.rendered){ + return; } - if(this.storeId){ - Ext.StoreMgr.register(this); + this.refresh.enable(); + }, + + // private + readPage : function(d){ + var v = this.inputItem.getValue(), pageNum; + if (!v || isNaN(pageNum = parseInt(v, 10))) { + this.inputItem.setValue(d.activePage); + return false; } - if(this.inlineData){ - this.loadData(this.inlineData); - delete this.inlineData; - }else if(this.autoLoad){ - this.load.defer(10, this, [ - typeof this.autoLoad == 'object' ? - this.autoLoad : undefined]); + return pageNum; + }, + + onPagingFocus : function(){ + this.inputItem.select(); + }, + + //private + onPagingBlur : function(e){ + this.inputItem.setValue(this.getPageData().activePage); + }, + + // private + onPagingKeyDown : function(field, e){ + var k = e.getKey(), d = this.getPageData(), pageNum; + if (k == e.RETURN) { + e.stopEvent(); + pageNum = this.readPage(d); + if(pageNum !== false){ + pageNum = Math.min(Math.max(1, pageNum), d.pages) - 1; + this.doLoad(pageNum * this.pageSize); + } + }else if (k == e.HOME || k == e.END){ + e.stopEvent(); + pageNum = k == e.HOME ? 1 : d.pages; + field.setValue(pageNum); + }else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN){ + e.stopEvent(); + if((pageNum = this.readPage(d))){ + var increment = e.shiftKey ? 10 : 1; + if(k == e.DOWN || k == e.PAGEDOWN){ + increment *= -1; + } + pageNum += increment; + if(pageNum >= 1 & pageNum <= d.pages){ + field.setValue(pageNum); + } + } + } + }, + + // private + getParams : function(){ + //retain backwards compat, allow params on the toolbar itself, if they exist. + return this.paramNames || this.store.paramNames; + }, + + // private + beforeLoad : function(){ + if(this.rendered && this.refresh){ + this.refresh.disable(); + } + }, + + // private + doLoad : function(start){ + var o = {}, pn = this.getParams(); + o[pn.start] = start; + o[pn.limit] = this.pageSize; + if(this.fireEvent('beforechange', this, o) !== false){ + this.store.load({params:o}); } - // used internally to uniquely identify a batch - this.batchCounter = 0; - this.batches = {}; }, /** - * builds a DataWriter instance when Store constructor is provided with a writer config-object instead of an instace. - * @param {Object} config Writer configuration - * @return {Ext.data.DataWriter} - * @private + * Move to the first page, has the same effect as clicking the 'first' button. */ - buildWriter : function(config) { - var klass = undefined, - type = (config.format || 'json').toLowerCase(); - switch (type) { - case 'json': - klass = Ext.data.JsonWriter; - break; - case 'xml': - klass = Ext.data.XmlWriter; - break; - default: - klass = Ext.data.JsonWriter; - } - return new klass(config); + moveFirst : function(){ + this.doLoad(0); }, /** - * Destroys the store. + * Move to the previous page, has the same effect as clicking the 'previous' button. */ - destroy : function(){ - if(!this.isDestroyed){ - if(this.storeId){ - Ext.StoreMgr.unregister(this); - } - this.clearData(); - this.data = null; - Ext.destroy(this.proxy); - this.reader = this.writer = null; - this.purgeListeners(); - this.isDestroyed = true; - } + movePrevious : function(){ + this.doLoad(Math.max(0, this.cursor-this.pageSize)); }, /** - * Add Records to the Store and fires the {@link #add} event. To add Records - * to the store from a remote source use {@link #load}({add:true}). - * See also {@link #recordType} and {@link #insert}. - * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects - * to add to the cache. See {@link #recordType}. + * Move to the next page, has the same effect as clicking the 'next' button. */ - add : function(records){ - records = [].concat(records); - if(records.length < 1){ - return; - } - for(var i = 0, len = records.length; i < len; i++){ - records[i].join(this); - } - var index = this.data.length; - this.data.addAll(records); - if(this.snapshot){ - this.snapshot.addAll(records); - } - this.fireEvent('add', this, records, index); + moveNext : function(){ + this.doLoad(this.cursor+this.pageSize); }, /** - * (Local sort only) Inserts the passed Record into the Store at the index where it - * should go based on the current sort information. - * @param {Ext.data.Record} record + * Move to the last page, has the same effect as clicking the 'last' button. */ - addSorted : function(record){ - var index = this.findInsertIndex(record); - this.insert(index, record); + moveLast : function(){ + var total = this.store.getTotalCount(), + extra = total % this.pageSize; + + this.doLoad(extra ? (total - extra) : total - this.pageSize); }, /** - * Remove Records from the Store and fires the {@link #remove} event. - * @param {Ext.data.Record/Ext.data.Record[]} record The record object or array of records to remove from the cache. + * Refresh the current page, has the same effect as clicking the 'refresh' button. */ - remove : function(record){ - if(Ext.isArray(record)){ - Ext.each(record, function(r){ - this.remove(r); - }, this); - } - var index = this.data.indexOf(record); - if(index > -1){ - record.join(null); - this.data.removeAt(index); - } - if(this.pruneModifiedRecords){ - this.modified.remove(record); + doRefresh : function(){ + this.doLoad(this.cursor); + }, + + /** + * Binds the paging toolbar to the specified {@link Ext.data.Store} + * @param {Store} store The store to bind to this toolbar + * @param {Boolean} initial (Optional) true to not remove listeners + */ + bindStore : function(store, initial){ + var doLoad; + if(!initial && this.store){ + if(store !== this.store && this.store.autoDestroy){ + this.store.destroy(); + }else{ + this.store.un('beforeload', this.beforeLoad, this); + this.store.un('load', this.onLoad, this); + this.store.un('exception', this.onLoadError, this); + } + if(!store){ + this.store = null; + } } - if(this.snapshot){ - this.snapshot.remove(record); + if(store){ + store = Ext.StoreMgr.lookup(store); + store.on({ + scope: this, + beforeload: this.beforeLoad, + load: this.onLoad, + exception: this.onLoadError + }); + doLoad = true; } - if(index > -1){ - this.fireEvent('remove', this, record, index); + this.store = store; + if(doLoad){ + this.onLoad(store, null, {}); } }, /** - * Remove a Record from the Store at the specified index. Fires the {@link #remove} event. - * @param {Number} index The index of the record to remove. + * Unbinds the paging toolbar from the specified {@link Ext.data.Store} (deprecated) + * @param {Ext.data.Store} store The data store to unbind */ - removeAt : function(index){ - this.remove(this.getAt(index)); + unbind : function(store){ + this.bindStore(null); }, /** - * Remove all Records from the Store and fires the {@link #clear} event. - * @param {Boolean} silent [false] Defaults to false. Set true to not fire clear event. + * Binds the paging toolbar to the specified {@link Ext.data.Store} (deprecated) + * @param {Ext.data.Store} store The data store to bind */ - removeAll : function(silent){ - var items = []; - this.each(function(rec){ - items.push(rec); - }); - this.clearData(); - if(this.snapshot){ - this.snapshot.clear(); + bind : function(store){ + this.bindStore(store); + }, + + // private + onDestroy : function(){ + this.bindStore(null); + Ext.PagingToolbar.superclass.onDestroy.call(this); + } +}); + +})(); +Ext.reg('paging', Ext.PagingToolbar);/** + * @class Ext.History + * @extends Ext.util.Observable + * History management component that allows you to register arbitrary tokens that signify application + * history state on navigation actions. You can then handle the history {@link #change} event in order + * to reset your application UI to the appropriate state when the user navigates forward or backward through + * the browser history stack. + * @singleton + */ +Ext.History = (function () { + var iframe, hiddenField; + var ready = false; + var currentToken; + + function getHash() { + var href = top.location.href, i = href.indexOf("#"); + return i >= 0 ? href.substr(i + 1) : null; + } + + function doSave() { + hiddenField.value = currentToken; + } + + function handleStateChange(token) { + currentToken = token; + Ext.History.fireEvent('change', token); + } + + function updateIFrame (token) { + var html = ['',Ext.util.Format.htmlEncode(token),''].join(''); + try { + var doc = iframe.contentWindow.document; + doc.open(); + doc.write(html); + doc.close(); + return true; + } catch (e) { + return false; } - if(this.pruneModifiedRecords){ - this.modified = []; + } + + function checkIFrame() { + if (!iframe.contentWindow || !iframe.contentWindow.document) { + setTimeout(checkIFrame, 10); + return; } - if (silent !== true) { // <-- prevents write-actions when we just want to clear a store. - this.fireEvent('clear', this, items); + + var doc = iframe.contentWindow.document; + var elem = doc.getElementById("state"); + var token = elem ? elem.innerText : null; + + var hash = getHash(); + + setInterval(function () { + + doc = iframe.contentWindow.document; + elem = doc.getElementById("state"); + + var newtoken = elem ? elem.innerText : null; + + var newHash = getHash(); + + if (newtoken !== token) { + token = newtoken; + handleStateChange(token); + top.location.hash = token; + hash = token; + doSave(); + } else if (newHash !== hash) { + hash = newHash; + updateIFrame(newHash); + } + + }, 50); + + ready = true; + + Ext.History.fireEvent('ready', Ext.History); + } + + function startUp() { + currentToken = hiddenField.value ? hiddenField.value : getHash(); + + if (Ext.isIE) { + checkIFrame(); + } else { + var hash = getHash(); + setInterval(function () { + var newHash = getHash(); + if (newHash !== hash) { + hash = newHash; + handleStateChange(hash); + doSave(); + } + }, 50); + ready = true; + Ext.History.fireEvent('ready', Ext.History); } - }, + } + + return { + /** + * The id of the hidden field required for storing the current history token. + * @type String + * @property + */ + fieldId: 'x-history-field', + /** + * The id of the iframe required by IE to manage the history stack. + * @type String + * @property + */ + iframeId: 'x-history-frame', + + events:{}, + + /** + * Initialize the global History instance. + * @param {Boolean} onReady (optional) A callback function that will be called once the history + * component is fully initialized. + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser window. + */ + init: function (onReady, scope) { + if(ready) { + Ext.callback(onReady, scope, [this]); + return; + } + if(!Ext.isReady){ + Ext.onReady(function(){ + Ext.History.init(onReady, scope); + }); + return; + } + hiddenField = Ext.getDom(Ext.History.fieldId); + if (Ext.isIE) { + iframe = Ext.getDom(Ext.History.iframeId); + } + this.addEvents( + /** + * @event ready + * Fires when the Ext.History singleton has been initialized and is ready for use. + * @param {Ext.History} The Ext.History singleton. + */ + 'ready', + /** + * @event change + * Fires when navigation back or forwards within the local page's history occurs. + * @param {String} token An identifier associated with the page state at that point in its history. + */ + 'change' + ); + if(onReady){ + this.on('ready', onReady, scope, {single:true}); + } + startUp(); + }, + + /** + * Add a new token to the history stack. This can be any arbitrary value, although it would + * commonly be the concatenation of a component id and another id marking the specifc history + * state of that component. Example usage: + * +// Handle tab changes on a TabPanel +tabPanel.on('tabchange', function(tabPanel, tab){ + Ext.History.add(tabPanel.id + ':' + tab.id); +}); + + * @param {String} token The value that defines a particular application-specific history state + * @param {Boolean} preventDuplicates When true, if the passed token matches the current token + * it will not save a new history step. Set to false if the same state can be saved more than once + * at the same history stack location (defaults to true). + */ + add: function (token, preventDup) { + if(preventDup !== false){ + if(this.getToken() == token){ + return true; + } + } + if (Ext.isIE) { + return updateIFrame(token); + } else { + top.location.hash = token; + return true; + } + }, - // private - onClear: function(store, records){ - Ext.each(records, function(rec, index){ - this.destroyRecord(this, rec, index); - }, this); - }, + /** + * Programmatically steps back one step in browser history (equivalent to the user pressing the Back button). + */ + back: function(){ + history.go(-1); + }, + + /** + * Programmatically steps forward one step in browser history (equivalent to the user pressing the Forward button). + */ + forward: function(){ + history.go(1); + }, + /** + * Retrieves the currently-active history token. + * @return {String} The token + */ + getToken: function() { + return ready ? currentToken : getHash(); + } + }; +})(); +Ext.apply(Ext.History, new Ext.util.Observable());/** + * @class Ext.Tip + * @extends Ext.Panel + * @xtype tip + * This is the base class for {@link Ext.QuickTip} and {@link Ext.Tooltip} that provides the basic layout and + * positioning that all tip-based classes require. This class can be used directly for simple, statically-positioned + * tips that are displayed programmatically, or it can be extended to provide custom tip implementations. + * @constructor + * Create a new Tip + * @param {Object} config The configuration options + */ +Ext.Tip = Ext.extend(Ext.Panel, { /** - * Inserts Records into the Store at the given index and fires the {@link #add} event. - * See also {@link #add} and {@link #addSorted}. - * @param {Number} index The start index at which to insert the passed Records. - * @param {Ext.data.Record[]} records An Array of Ext.data.Record objects to add to the cache. + * @cfg {Boolean} closable True to render a close tool button into the tooltip header (defaults to false). */ - insert : function(index, records){ - records = [].concat(records); - for(var i = 0, len = records.length; i < len; i++){ - this.data.insert(index, records[i]); - records[i].join(this); - } - if(this.snapshot){ - this.snapshot.addAll(records); - } - this.fireEvent('add', this, records, index); - }, - /** - * Get the index within the cache of the passed Record. - * @param {Ext.data.Record} record The Ext.data.Record object to find. - * @return {Number} The index of the passed Record. Returns -1 if not found. + * @cfg {Number} width + * Width in pixels of the tip (defaults to auto). Width will be ignored if it exceeds the bounds of + * {@link #minWidth} or {@link #maxWidth}. The maximum supported value is 500. */ - indexOf : function(record){ - return this.data.indexOf(record); - }, - /** - * Get the index within the cache of the Record with the passed id. - * @param {String} id The id of the Record to find. - * @return {Number} The index of the Record. Returns -1 if not found. + * @cfg {Number} minWidth The minimum width of the tip in pixels (defaults to 40). */ - indexOfId : function(id){ - return this.data.indexOfKey(id); - }, - + minWidth : 40, /** - * Get the Record with the specified id. - * @param {String} id The id of the Record to find. - * @return {Ext.data.Record} The Record with the passed id. Returns undefined if not found. + * @cfg {Number} maxWidth The maximum width of the tip in pixels (defaults to 300). The maximum supported value is 500. */ - getById : function(id){ - return (this.snapshot || this.data).key(id); - }, - + maxWidth : 300, /** - * Get the Record at the specified index. - * @param {Number} index The index of the Record to find. - * @return {Ext.data.Record} The Record at the passed index. Returns undefined if not found. + * @cfg {Boolean/String} shadow True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" + * for bottom-right shadow (defaults to "sides"). */ - getAt : function(index){ - return this.data.itemAt(index); - }, - + shadow : "sides", /** - * Returns a range of Records between specified indices. - * @param {Number} startIndex (optional) The starting index (defaults to 0) - * @param {Number} endIndex (optional) The ending index (defaults to the last Record in the Store) - * @return {Ext.data.Record[]} An array of Records + * @cfg {String} defaultAlign Experimental. The default {@link Ext.Element#alignTo} anchor position value + * for this tip relative to its element of origin (defaults to "tl-bl?"). */ - getRange : function(start, end){ - return this.data.getRange(start, end); - }, + defaultAlign : "tl-bl?", + autoRender: true, + quickShowInterval : 250, + + // private panel overrides + frame:true, + hidden:true, + baseCls: 'x-tip', + floating:{shadow:true,shim:true,useDisplay:true,constrain:false}, + autoHeight:true, + + closeAction: 'hide', // private - storeOptions : function(o){ - o = Ext.apply({}, o); - delete o.callback; - delete o.scope; - this.lastOptions = o; + initComponent : function(){ + Ext.Tip.superclass.initComponent.call(this); + if(this.closable && !this.title){ + this.elements += ',header'; + } }, // private - clearData: function(){ - this.data.each(function(rec) { - rec.join(null); - }); - this.data.clear(); + afterRender : function(){ + Ext.Tip.superclass.afterRender.call(this); + if(this.closable){ + this.addTool({ + id: 'close', + handler: this[this.closeAction], + scope: this + }); + } }, /** - * Loads the Record cache from the configured {@link #proxy} using the configured {@link #reader}. - * Notes: - * Important: loading is asynchronous! This call will return before the new data has been - * loaded. To perform any post-processing where information from the load call is required, specify - * the callback function to be called, or use a {@link Ext.util.Observable#listeners a 'load' event handler}. - * If using {@link Ext.PagingToolbar remote paging}, the first load call must specify the start and limit - * properties in the options.params property to establish the initial position within the - * dataset, and the number of Records to cache on each read from the Proxy. - * If using {@link #remoteSort remote sorting}, the configured {@link #sortInfo} - * will be automatically included with the posted parameters according to the specified - * {@link #paramNames}. - * - * @param {Object} options An object containing properties which control loading options: - * params :ObjectAn object containing properties to pass as HTTP - * parameters to a remote data source. Note: params will override any - * {@link #baseParams} of the same name. - * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. - * callback : FunctionA function to be called after the Records - * have been loaded. The callback is called after the load event is fired, and is passed the following arguments: - * r : Ext.data.Record[] An Array of Records loaded. - * options : Options object from the load call. - * success : Boolean success indicator. - * scope : ObjectScope with which to call the callback (defaults - * to the Store object) - * add : BooleanIndicator to append loaded records rather than - * replace the current cache. Note: see note for {@link #loadData} - * - * @return {Boolean} If the developer provided {@link #beforeload} event handler returns - * false, the load call will abort and will return false; otherwise will return true. + * Shows this tip at the specified XY position. Example usage: + * +// Show the tip at x:50 and y:100 +tip.showAt([50,100]); + + * @param {Array} xy An array containing the x and y coordinates */ - load : function(options) { - options = options || {}; - this.storeOptions(options); - if(this.sortInfo && this.remoteSort){ - var pn = this.paramNames; - options.params = options.params || {}; - options.params[pn.sort] = this.sortInfo.field; - options.params[pn.dir] = this.sortInfo.direction; + showAt : function(xy){ + Ext.Tip.superclass.show.call(this); + if(this.measureWidth !== false && (!this.initialConfig || typeof this.initialConfig.width != 'number')){ + this.doAutoWidth(); } - try { - return this.execute('read', null, options); // <-- null represents rs. No rs for load actions. - } catch(e) { - this.handleException(e); - return false; + if(this.constrainPosition){ + xy = this.el.adjustForConstraints(xy); } + this.setPagePosition(xy[0], xy[1]); }, - /** - * updateRecord Should not be used directly. This method will be called automatically if a Writer is set. - * Listens to 'update' event. - * @param {Object} store - * @param {Object} record - * @param {Object} action - * @private - */ - updateRecord : function(store, record, action) { - if (action == Ext.data.Record.EDIT && this.autoSave === true && (!record.phantom || (record.phantom && record.isValid()))) { - this.save(); + // protected + doAutoWidth : function(adjust){ + adjust = adjust || 0; + var bw = this.body.getTextWidth(); + if(this.title){ + bw = Math.max(bw, this.header.child('span').getTextWidth(this.title)); + } + bw += this.getFrameWidth() + (this.closable ? 20 : 0) + this.body.getPadding("lr") + adjust; + this.setWidth(bw.constrain(this.minWidth, this.maxWidth)); + + // IE7 repaint bug on initial show + if(Ext.isIE7 && !this.repainted){ + this.el.repaint(); + this.repainted = true; } }, /** - * Should not be used directly. Store#add will call this automatically if a Writer is set - * @param {Object} store - * @param {Object} rs - * @param {Object} index - * @private + * Experimental. Shows this tip at a position relative to another element using a standard {@link Ext.Element#alignTo} + * anchor position value. Example usage: + * +// Show the tip at the default position ('tl-br?') +tip.showBy('my-el'); + +// Show the tip's top-left corner anchored to the element's top-right corner +tip.showBy('my-el', 'tl-tr'); + + * @param {Mixed} el An HTMLElement, Ext.Element or string id of the target element to align to + * @param {String} position (optional) A valid {@link Ext.Element#alignTo} anchor position (defaults to 'tl-br?' or + * {@link #defaultAlign} if specified). */ - createRecords : function(store, rs, index) { - for (var i = 0, len = rs.length; i < len; i++) { - if (rs[i].phantom && rs[i].isValid()) { - rs[i].markDirty(); // <-- Mark new records dirty - this.modified.push(rs[i]); // <-- add to modified - } - } - if (this.autoSave === true) { - this.save(); + showBy : function(el, pos){ + if(!this.rendered){ + this.render(Ext.getBody()); } + this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign)); }, + initDraggable : function(){ + this.dd = new Ext.Tip.DD(this, typeof this.draggable == 'boolean' ? null : this.draggable); + this.header.addClass('x-tip-draggable'); + } +}); + +Ext.reg('tip', Ext.Tip); + +// private - custom Tip DD implementation +Ext.Tip.DD = function(tip, config){ + Ext.apply(this, config); + this.tip = tip; + Ext.Tip.DD.superclass.constructor.call(this, tip.el.id, 'WindowDD-'+tip.id); + this.setHandleElId(tip.header.id); + this.scroll = false; +}; + +Ext.extend(Ext.Tip.DD, Ext.dd.DD, { + moveOnly:true, + scroll:false, + headerOffsets:[100, 25], + startDrag : function(){ + this.tip.el.disableShadow(); + }, + endDrag : function(e){ + this.tip.el.enableShadow(true); + } +});/** + * @class Ext.ToolTip + * @extends Ext.Tip + * A standard tooltip implementation for providing additional information when hovering over a target element. + * @xtype tooltip + * @constructor + * Create a new Tooltip + * @param {Object} config The configuration options + */ +Ext.ToolTip = Ext.extend(Ext.Tip, { /** - * Destroys a record or records. Should not be used directly. It's called by Store#remove if a Writer is set. - * @param {Store} this - * @param {Ext.data.Record/Ext.data.Record[]} - * @param {Number} index - * @private + * When a Tooltip is configured with the {@link #delegate} + * option to cause selected child elements of the {@link #target} + * Element to each trigger a seperate show event, this property is set to + * the DOM element which triggered the show. + * @type DOMElement + * @property triggerElement */ - destroyRecord : function(store, record, index) { - if (this.modified.indexOf(record) != -1) { // <-- handled already if @cfg pruneModifiedRecords == true - this.modified.remove(record); + /** + * @cfg {Mixed} target The target HTMLElement, Ext.Element or id to monitor + * for mouseover events to trigger showing this ToolTip. + */ + /** + * @cfg {Boolean} autoHide True to automatically hide the tooltip after the + * mouse exits the target element or after the {@link #dismissDelay} + * has expired if set (defaults to true). If {@link closable} = true + * a close tool button will be rendered into the tooltip header. + */ + /** + * @cfg {Number} showDelay Delay in milliseconds before the tooltip displays + * after the mouse enters the target element (defaults to 500) + */ + showDelay : 500, + /** + * @cfg {Number} hideDelay Delay in milliseconds after the mouse exits the + * target element but before the tooltip actually hides (defaults to 200). + * Set to 0 for the tooltip to hide immediately. + */ + hideDelay : 200, + /** + * @cfg {Number} dismissDelay Delay in milliseconds before the tooltip + * automatically hides (defaults to 5000). To disable automatic hiding, set + * dismissDelay = 0. + */ + dismissDelay : 5000, + /** + * @cfg {Array} mouseOffset An XY offset from the mouse position where the + * tooltip should be shown (defaults to [15,18]). + */ + /** + * @cfg {Boolean} trackMouse True to have the tooltip follow the mouse as it + * moves over the target element (defaults to false). + */ + trackMouse : false, + /** + * @cfg {Boolean} anchorToTarget True to anchor the tooltip to the target + * element, false to anchor it relative to the mouse coordinates (defaults + * to true). When anchorToTarget is true, use + * {@link #defaultAlign} to control tooltip alignment to the + * target element. When anchorToTarget is false, use + * {@link #anchorPosition} instead to control alignment. + */ + anchorToTarget : true, + /** + * @cfg {Number} anchorOffset A numeric pixel value used to offset the + * default position of the anchor arrow (defaults to 0). When the anchor + * position is on the top or bottom of the tooltip, anchorOffset + * will be used as a horizontal offset. Likewise, when the anchor position + * is on the left or right side, anchorOffset will be used as + * a vertical offset. + */ + anchorOffset : 0, + /** + * @cfg {String} delegate Optional. A {@link Ext.DomQuery DomQuery} + * selector which allows selection of individual elements within the + * {@link #target} element to trigger showing and hiding the + * ToolTip as the mouse moves within the target. + * When specified, the child element of the target which caused a show + * event is placed into the {@link #triggerElement} property + * before the ToolTip is shown. + * This may be useful when a Component has regular, repeating elements + * in it, each of which need a Tooltip which contains information specific + * to that element. For example: +var myGrid = new Ext.grid.gridPanel(gridConfig); +myGrid.on('render', function(grid) { + var store = grid.getStore(); // Capture the Store. + var view = grid.getView(); // Capture the GridView. + myGrid.tip = new Ext.ToolTip({ + target: view.mainBody, // The overall target element. + delegate: '.x-grid3-row', // Each grid row causes its own seperate show and hide. + trackMouse: true, // Moving within the row should not hide the tip. + renderTo: document.body, // Render immediately so that tip.body can be + // referenced prior to the first show. + listeners: { // Change content dynamically depending on which element + // triggered the show. + beforeshow: function updateTipBody(tip) { + var rowIndex = view.findRowIndex(tip.triggerElement); + tip.body.dom.innerHTML = 'Over Record ID ' + store.getAt(rowIndex).id; + } } - if (!record.phantom) { - this.removed.push(record); + }); +}); + * + */ - // since the record has already been removed from the store but the server request has not yet been executed, - // must keep track of the last known index this record existed. If a server error occurs, the record can be - // put back into the store. @see Store#createCallback where the record is returned when response status === false - record.lastIndex = index; + // private + targetCounter : 0, - if (this.autoSave === true) { - this.save(); - } - } + constrainPosition : false, + + // private + initComponent : function(){ + Ext.ToolTip.superclass.initComponent.call(this); + this.lastActive = new Date(); + this.initTarget(this.target); + this.origAnchor = this.anchor; }, - /** - * This method should generally not be used directly. This method is called internally - * by {@link #load}, or if a Writer is set will be called automatically when {@link #add}, - * {@link #remove}, or {@link #update} events fire. - * @param {String} action Action name ('read', 'create', 'update', or 'destroy') - * @param {Record/Record[]} rs - * @param {Object} options - * @throws Error - * @private - */ - execute : function(action, rs, options, /* private */ batch) { - // blow up if action not Ext.data.CREATE, READ, UPDATE, DESTROY - if (!Ext.data.Api.isAction(action)) { - throw new Ext.data.Api.Error('execute', action); - } - // make sure options has a fresh, new params hash - options = Ext.applyIf(options||{}, { - params: {} + // private + onRender : function(ct, position){ + Ext.ToolTip.superclass.onRender.call(this, ct, position); + this.anchorCls = 'x-tip-anchor-' + this.getAnchorPosition(); + this.anchorEl = this.el.createChild({ + cls: 'x-tip-anchor ' + this.anchorCls }); - if(batch !== undefined){ - this.addToBatch(batch); - } - // have to separate before-events since load has a different signature than create,destroy and save events since load does not - // include the rs (record resultset) parameter. Capture return values from the beforeaction into doRequest flag. - var doRequest = true; + }, - if (action === 'read') { - doRequest = this.fireEvent('beforeload', this, options); - Ext.applyIf(options.params, this.baseParams); - } - else { - // if Writer is configured as listful, force single-record rs to be [{}] instead of {} - // TODO Move listful rendering into DataWriter where the @cfg is defined. Should be easy now. - if (this.writer.listful === true && this.restful !== true) { - rs = (Ext.isArray(rs)) ? rs : [rs]; - } - // if rs has just a single record, shift it off so that Writer writes data as '{}' rather than '[{}]' - else if (Ext.isArray(rs) && rs.length == 1) { - rs = rs.shift(); - } - // Write the action to options.params - if ((doRequest = this.fireEvent('beforewrite', this, action, rs, options)) !== false) { - this.writer.apply(options.params, this.baseParams, action, rs); + // private + afterRender : function(){ + Ext.ToolTip.superclass.afterRender.call(this); + this.anchorEl.setStyle('z-index', this.el.getZIndex() + 1); + }, + + /** + * Binds this ToolTip to the specified element. The tooltip will be displayed when the mouse moves over the element. + * @param {Mixed} t The Element, HtmlElement, or ID of an element to bind to + */ + initTarget : function(target){ + var t; + if((t = Ext.get(target))){ + if(this.target){ + var tg = Ext.get(this.target); + this.mun(tg, 'mouseover', this.onTargetOver, this); + this.mun(tg, 'mouseout', this.onTargetOut, this); + this.mun(tg, 'mousemove', this.onMouseMove, this); } + this.mon(t, { + mouseover: this.onTargetOver, + mouseout: this.onTargetOut, + mousemove: this.onMouseMove, + scope: this + }); + this.target = t; } - if (doRequest !== false) { - // Send request to proxy. - if (this.writer && this.proxy.url && !this.proxy.restful && !Ext.data.Api.hasUniqueUrl(this.proxy, action)) { - options.params.xaction = action; // <-- really old, probaby unecessary. - } - // Note: Up until this point we've been dealing with 'action' as a key from Ext.data.Api.actions. - // We'll flip it now and send the value into DataProxy#request, since it's the value which maps to - // the user's configured DataProxy#api - // TODO Refactor all Proxies to accept an instance of Ext.data.Request (not yet defined) instead of this looooooong list - // of params. This method is an artifact from Ext2. - this.proxy.request(Ext.data.Api.actions[action], rs, options.params, this.reader, this.createCallback(action, rs, batch), this, options); + if(this.anchor){ + this.anchorTarget = this.target; } - return doRequest; }, - /** - * Saves all pending changes to the store. If the commensurate Ext.data.Api.actions action is not configured, then - * the configured {@link #url} will be used. - * - * change url - * --------------- -------------------- - * removed records Ext.data.Api.actions.destroy - * phantom records Ext.data.Api.actions.create - * {@link #getModifiedRecords modified records} Ext.data.Api.actions.update - * - * @TODO: Create extensions of Error class and send associated Record with thrown exceptions. - * e.g.: Ext.data.DataReader.Error or Ext.data.Error or Ext.data.DataProxy.Error, etc. - * @return {Number} batch Returns a number to uniquely identify the "batch" of saves occurring. -1 will be returned - * if there are no items to save or the save was cancelled. - */ - save : function() { - if (!this.writer) { - throw new Ext.data.Store.Error('writer-undefined'); + // private + onMouseMove : function(e){ + var t = this.delegate ? e.getTarget(this.delegate) : this.triggerElement = true; + if (t) { + this.targetXY = e.getXY(); + if (t === this.triggerElement) { + if(!this.hidden && this.trackMouse){ + this.setPagePosition(this.getTargetXY()); + } + } else { + this.hide(); + this.lastActive = new Date(0); + this.onTargetOver(e); + } + } else if (!this.closable && this.isVisible()) { + this.hide(); } + }, - var queue = [], - len, - trans, - batch, - data = {}; - // DESTROY: First check for removed records. Records in this.removed are guaranteed non-phantoms. @see Store#remove - if(this.removed.length){ - queue.push(['destroy', this.removed]); + // private + getTargetXY : function(){ + if(this.delegate){ + this.anchorTarget = this.triggerElement; } + if(this.anchor){ + this.targetCounter++; + var offsets = this.getOffsets(), + xy = (this.anchorToTarget && !this.trackMouse) ? this.el.getAlignToXY(this.anchorTarget, this.getAnchorAlign()) : this.targetXY, + dw = Ext.lib.Dom.getViewWidth() - 5, + dh = Ext.lib.Dom.getViewHeight() - 5, + de = document.documentElement, + bd = document.body, + scrollX = (de.scrollLeft || bd.scrollLeft || 0) + 5, + scrollY = (de.scrollTop || bd.scrollTop || 0) + 5, + axy = [xy[0] + offsets[0], xy[1] + offsets[1]], + sz = this.getSize(); + + this.anchorEl.removeClass(this.anchorCls); - // Check for modified records. Use a copy so Store#rejectChanges will work if server returns error. - var rs = [].concat(this.getModifiedRecords()); - if(rs.length){ - // CREATE: Next check for phantoms within rs. splice-off and execute create. - var phantoms = []; - for(var i = rs.length-1; i >= 0; i--){ - if(rs[i].phantom === true){ - var rec = rs.splice(i, 1).shift(); - if(rec.isValid()){ - phantoms.push(rec); + if(this.targetCounter < 2){ + if(axy[0] < scrollX){ + if(this.anchorToTarget){ + this.defaultAlign = 'l-r'; + if(this.mouseOffset){this.mouseOffset[0] *= -1;} } - }else if(!rs[i].isValid()){ // <-- while we're here, splice-off any !isValid real records - rs.splice(i,1); + this.anchor = 'left'; + return this.getTargetXY(); + } + if(axy[0]+sz.width > dw){ + if(this.anchorToTarget){ + this.defaultAlign = 'r-l'; + if(this.mouseOffset){this.mouseOffset[0] *= -1;} + } + this.anchor = 'right'; + return this.getTargetXY(); + } + if(axy[1] < scrollY){ + if(this.anchorToTarget){ + this.defaultAlign = 't-b'; + if(this.mouseOffset){this.mouseOffset[1] *= -1;} + } + this.anchor = 'top'; + return this.getTargetXY(); + } + if(axy[1]+sz.height > dh){ + if(this.anchorToTarget){ + this.defaultAlign = 'b-t'; + if(this.mouseOffset){this.mouseOffset[1] *= -1;} + } + this.anchor = 'bottom'; + return this.getTargetXY(); } - } - // If we have valid phantoms, create them... - if(phantoms.length){ - queue.push(['create', phantoms]); } - // UPDATE: And finally, if we're still here after splicing-off phantoms and !isValid real records, update the rest... - if(rs.length){ - queue.push(['update', rs]); - } + this.anchorCls = 'x-tip-anchor-'+this.getAnchorPosition(); + this.anchorEl.addClass(this.anchorCls); + this.targetCounter = 0; + return axy; + }else{ + var mouseOffset = this.getMouseOffset(); + return [this.targetXY[0]+mouseOffset[0], this.targetXY[1]+mouseOffset[1]]; } - len = queue.length; - if(len){ - batch = ++this.batchCounter; - for(var i = 0; i < len; ++i){ - trans = queue[i]; - data[trans[0]] = trans[1]; - } - if(this.fireEvent('beforesave', this, data) !== false){ - for(var i = 0; i < len; ++i){ - trans = queue[i]; - this.doTransaction(trans[0], trans[1], batch); - } - return batch; - } + }, + + getMouseOffset : function(){ + var offset = this.anchor ? [0,0] : [15,18]; + if(this.mouseOffset){ + offset[0] += this.mouseOffset[0]; + offset[1] += this.mouseOffset[1]; } - return -1; + return offset; }, - // private. Simply wraps call to Store#execute in try/catch. Defers to Store#handleException on error. Loops if batch: false - doTransaction : function(action, rs, batch) { - function transaction(records) { - try{ - this.execute(action, records, undefined, batch); - }catch (e){ - this.handleException(e); + // private + getAnchorPosition : function(){ + if(this.anchor){ + this.tipAnchor = this.anchor.charAt(0); + }else{ + var m = this.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/); + if(!m){ + throw 'AnchorTip.defaultAlign is invalid'; } + this.tipAnchor = m[1].charAt(0); } - if(this.batch === false){ - for(var i = 0, len = rs.length; i < len; i++){ - transaction.call(this, rs[i]); - } - }else{ - transaction.call(this, rs); + + switch(this.tipAnchor){ + case 't': return 'top'; + case 'b': return 'bottom'; + case 'r': return 'right'; } + return 'left'; }, // private - addToBatch : function(batch){ - var b = this.batches, - key = this.batchKey + batch, - o = b[key]; - - if(!o){ - b[key] = o = { - id: batch, - count: 0, - data: {} - } + getAnchorAlign : function(){ + switch(this.anchor){ + case 'top' : return 'tl-bl'; + case 'left' : return 'tl-tr'; + case 'right': return 'tr-tl'; + default : return 'bl-tl'; } - ++o.count; }, - removeFromBatch : function(batch, action, data){ - var b = this.batches, - key = this.batchKey + batch, - o = b[key], - data, - arr; + // private + getOffsets : function(){ + var offsets, + ap = this.getAnchorPosition().charAt(0); + if(this.anchorToTarget && !this.trackMouse){ + switch(ap){ + case 't': + offsets = [0, 9]; + break; + case 'b': + offsets = [0, -13]; + break; + case 'r': + offsets = [-13, 0]; + break; + default: + offsets = [9, 0]; + break; + } + }else{ + switch(ap){ + case 't': + offsets = [-15-this.anchorOffset, 30]; + break; + case 'b': + offsets = [-19-this.anchorOffset, -13-this.el.dom.offsetHeight]; + break; + case 'r': + offsets = [-15-this.el.dom.offsetWidth, -13-this.anchorOffset]; + break; + default: + offsets = [25, -13-this.anchorOffset]; + break; + } + } + var mouseOffset = this.getMouseOffset(); + offsets[0] += mouseOffset[0]; + offsets[1] += mouseOffset[1]; + return offsets; + }, - if(o){ - arr = o.data[action] || []; - o.data[action] = arr.concat(data); - if(o.count === 1){ - data = o.data; - delete b[key]; - this.fireEvent('save', this, batch, data); - }else{ - --o.count; - } + // private + onTargetOver : function(e){ + if(this.disabled || e.within(this.target.dom, true)){ + return; + } + var t = e.getTarget(this.delegate); + if (t) { + this.triggerElement = t; + this.clearTimer('hide'); + this.targetXY = e.getXY(); + this.delayShow(); } }, - // @private callback-handler for remote CRUD actions - // Do not override -- override loadRecords, onCreateRecords, onDestroyRecords and onUpdateRecords instead. - createCallback : function(action, rs, batch) { - var actions = Ext.data.Api.actions; - return (action == 'read') ? this.loadRecords : function(data, response, success) { - // calls: onCreateRecords | onUpdateRecords | onDestroyRecords - this['on' + Ext.util.Format.capitalize(action) + 'Records'](success, rs, [].concat(data)); - // If success === false here, exception will have been called in DataProxy - if (success === true) { - this.fireEvent('write', this, action, data, response, rs); + // private + delayShow : function(){ + if(this.hidden && !this.showTimer){ + if(this.lastActive.getElapsed() < this.quickShowInterval){ + this.show(); + }else{ + this.showTimer = this.show.defer(this.showDelay, this); } - this.removeFromBatch(batch, action, data); - }; + }else if(!this.hidden && this.autoHide !== false){ + this.show(); + } }, - // Clears records from modified array after an exception event. - // NOTE: records are left marked dirty. Do we want to commit them even though they were not updated/realized? - // TODO remove this method? - clearModified : function(rs) { - if (Ext.isArray(rs)) { - for (var n=rs.length-1;n>=0;n--) { - this.modified.splice(this.modified.indexOf(rs[n]), 1); - } - } else { - this.modified.splice(this.modified.indexOf(rs), 1); + // private + onTargetOut : function(e){ + if(this.disabled || e.within(this.target.dom, true)){ + return; + } + this.clearTimer('show'); + if(this.autoHide !== false){ + this.delayHide(); } }, - // remap record ids in MixedCollection after records have been realized. @see Store#onCreateRecords, @see DataReader#realize - reMap : function(record) { - if (Ext.isArray(record)) { - for (var i = 0, len = record.length; i < len; i++) { - this.reMap(record[i]); - } - } else { - delete this.data.map[record._phid]; - this.data.map[record.id] = record; - var index = this.data.keys.indexOf(record._phid); - this.data.keys.splice(index, 1, record.id); - delete record._phid; + // private + delayHide : function(){ + if(!this.hidden && !this.hideTimer){ + this.hideTimer = this.hide.defer(this.hideDelay, this); } }, - // @protected onCreateRecord proxy callback for create action - onCreateRecords : function(success, rs, data) { - if (success === true) { - try { - this.reader.realize(rs, data); - this.reMap(rs); - } - catch (e) { - this.handleException(e); - if (Ext.isArray(rs)) { - // Recurse to run back into the try {}. DataReader#realize splices-off the rs until empty. - this.onCreateRecords(success, rs, data); - } - } + /** + * Hides this tooltip if visible. + */ + hide: function(){ + this.clearTimer('dismiss'); + this.lastActive = new Date(); + if(this.anchorEl){ + this.anchorEl.hide(); } + Ext.ToolTip.superclass.hide.call(this); + delete this.triggerElement; }, - // @protected, onUpdateRecords proxy callback for update action - onUpdateRecords : function(success, rs, data) { - if (success === true) { - try { - this.reader.update(rs, data); - } catch (e) { - this.handleException(e); - if (Ext.isArray(rs)) { - // Recurse to run back into the try {}. DataReader#update splices-off the rs until empty. - this.onUpdateRecords(success, rs, data); - } - } + /** + * Shows this tooltip at the current event target XY position. + */ + show : function(){ + if(this.anchor){ + // pre-show it off screen so that the el will have dimensions + // for positioning calcs when getting xy next + this.showAt([-1000,-1000]); + this.origConstrainPosition = this.constrainPosition; + this.constrainPosition = false; + this.anchor = this.origAnchor; + } + this.showAt(this.getTargetXY()); + + if(this.anchor){ + this.syncAnchor(); + this.anchorEl.show(); + this.constrainPosition = this.origConstrainPosition; + }else{ + this.anchorEl.hide(); } }, - // @protected onDestroyRecords proxy callback for destroy action - onDestroyRecords : function(success, rs, data) { - // splice each rec out of this.removed - rs = (rs instanceof Ext.data.Record) ? [rs] : [].concat(rs); - for (var i=0,len=rs.length;i=0;i--) { - this.insert(rs[i].lastIndex, rs[i]); // <-- lastIndex set in Store#destroyRecord - } + if(this.anchor && !this.anchorEl.isVisible()){ + this.syncAnchor(); + this.anchorEl.show(); } }, - // protected handleException. Possibly temporary until Ext framework has an exception-handler. - handleException : function(e) { - // @see core/Error.js - Ext.handleError(e); + // private + syncAnchor : function(){ + var anchorPos, targetPos, offset; + switch(this.tipAnchor.charAt(0)){ + case 't': + anchorPos = 'b'; + targetPos = 'tl'; + offset = [20+this.anchorOffset, 2]; + break; + case 'r': + anchorPos = 'l'; + targetPos = 'tr'; + offset = [-2, 11+this.anchorOffset]; + break; + case 'b': + anchorPos = 't'; + targetPos = 'bl'; + offset = [20+this.anchorOffset, -2]; + break; + default: + anchorPos = 'r'; + targetPos = 'tl'; + offset = [2, 11+this.anchorOffset]; + break; + } + this.anchorEl.alignTo(this.el, anchorPos+'-'+targetPos, offset); }, - /** - * Reloads the Record cache from the configured Proxy using the configured - * {@link Ext.data.Reader Reader} and the options from the last load operation - * performed. - * Note: see the Important note in {@link #load}. - * @param {Object} options (optional) An Object containing - * {@link #load loading options} which may override the {@link #lastOptions options} - * used in the last {@link #load} operation. See {@link #load} for details - * (defaults to null, in which case the {@link #lastOptions} are - * used). - * To add new params to the existing params: -lastOptions = myStore.lastOptions; -Ext.apply(lastOptions.params, { - myNewParam: true -}); -myStore.reload(lastOptions); - * - */ - reload : function(options){ - this.load(Ext.applyIf(options||{}, this.lastOptions)); + // private + setPagePosition : function(x, y){ + Ext.ToolTip.superclass.setPagePosition.call(this, x, y); + if(this.anchor){ + this.syncAnchor(); + } }, // private - // Called as a callback by the Reader during a load operation. - loadRecords : function(o, options, success){ - if (this.isDestroyed === true) { - return; + clearTimer : function(name){ + name = name + 'Timer'; + clearTimeout(this[name]); + delete this[name]; + }, + + // private + clearTimers : function(){ + this.clearTimer('show'); + this.clearTimer('dismiss'); + this.clearTimer('hide'); + }, + + // private + onShow : function(){ + Ext.ToolTip.superclass.onShow.call(this); + Ext.getDoc().on('mousedown', this.onDocMouseDown, this); + }, + + // private + onHide : function(){ + Ext.ToolTip.superclass.onHide.call(this); + Ext.getDoc().un('mousedown', this.onDocMouseDown, this); + }, + + // private + onDocMouseDown : function(e){ + if(this.autoHide !== true && !this.closable && !e.within(this.el.dom)){ + this.disable(); + this.doEnable.defer(100, this); } - if(!o || success === false){ - if(success !== false){ - this.fireEvent('load', this, [], options); - } - if(options.callback){ - options.callback.call(options.scope || this, [], options, false, o); - } - return; + }, + + // private + doEnable : function(){ + if(!this.isDestroyed){ + this.enable(); } - var r = o.records, t = o.totalRecords || r.length; - if(!options || options.add !== true){ - if(this.pruneModifiedRecords){ - this.modified = []; - } - for(var i = 0, len = r.length; i < len; i++){ - r[i].join(this); - } - if(this.snapshot){ - this.data = this.snapshot; - delete this.snapshot; + }, + + // private + onDisable : function(){ + this.clearTimers(); + this.hide(); + }, + + // private + adjustPosition : function(x, y){ + if(this.contstrainPosition){ + var ay = this.targetXY[1], h = this.getSize().height; + if(y <= ay && (y+h) >= ay){ + y = ay-h-5; } - this.clearData(); - this.data.addAll(r); - this.totalLength = t; - this.applySort(); - this.fireEvent('datachanged', this); - }else{ - this.totalLength = Math.max(t, this.data.length+r.length); - this.add(r); - } - this.fireEvent('load', this, r, options); - if(options.callback){ - options.callback.call(options.scope || this, r, options, true); } + return {x : x, y: y}; + }, + + beforeDestroy : function(){ + this.clearTimers(); + Ext.destroy(this.anchorEl); + delete this.anchorEl; + delete this.target; + delete this.anchorTarget; + delete this.triggerElement; + Ext.ToolTip.superclass.beforeDestroy.call(this); }, + // private + onDestroy : function(){ + Ext.getDoc().un('mousedown', this.onDocMouseDown, this); + Ext.ToolTip.superclass.onDestroy.call(this); + } +}); + +Ext.reg('tooltip', Ext.ToolTip);/** + * @class Ext.QuickTip + * @extends Ext.ToolTip + * @xtype quicktip + * A specialized tooltip class for tooltips that can be specified in markup and automatically managed by the global + * {@link Ext.QuickTips} instance. See the QuickTips class header for additional usage details and examples. + * @constructor + * Create a new Tip + * @param {Object} config The configuration options + */ +Ext.QuickTip = Ext.extend(Ext.ToolTip, { /** - * Loads data from a passed data block and fires the {@link #load} event. A {@link Ext.data.Reader Reader} - * which understands the format of the data must have been configured in the constructor. - * @param {Object} data The data block from which to read the Records. The format of the data expected - * is dependent on the type of {@link Ext.data.Reader Reader} that is configured and should correspond to - * that {@link Ext.data.Reader Reader}'s {@link Ext.data.Reader#readRecords} parameter. - * @param {Boolean} append (Optional) true to append the new Records rather the default to replace - * the existing cache. - * Note: that Records in a Store are keyed by their {@link Ext.data.Record#id id}, so added Records - * with ids which are already present in the Store will replace existing Records. Only Records with - * new, unique ids will be added. + * @cfg {Mixed} target The target HTMLElement, Ext.Element or id to associate with this quicktip (defaults to the document). */ - loadData : function(o, append){ - var r = this.reader.readRecords(o); - this.loadRecords(r, {add: append}, true); + /** + * @cfg {Boolean} interceptTitles True to automatically use the element's DOM title value if available (defaults to false). + */ + interceptTitles : false, + + // private + tagConfig : { + namespace : "ext", + attribute : "qtip", + width : "qwidth", + target : "target", + title : "qtitle", + hide : "hide", + cls : "qclass", + align : "qalign", + anchor : "anchor" + }, + + // private + initComponent : function(){ + this.target = this.target || Ext.getDoc(); + this.targets = this.targets || {}; + Ext.QuickTip.superclass.initComponent.call(this); }, /** - * Gets the number of cached records. - * If using paging, this may not be the total size of the dataset. If the data object - * used by the Reader contains the dataset size, then the {@link #getTotalCount} function returns - * the dataset size. Note: see the Important note in {@link #load}. - * @return {Number} The number of Records in the Store's cache. - */ - getCount : function(){ - return this.data.length || 0; + * Configures a new quick tip instance and assigns it to a target element. The following config values are + * supported (for example usage, see the {@link Ext.QuickTips} class header): + * + * autoHide + * cls + * dismissDelay (overrides the singleton value) + * target (required) + * text (required) + * title + * width + * @param {Object} config The config object + */ + register : function(config){ + var cs = Ext.isArray(config) ? config : arguments; + for(var i = 0, len = cs.length; i < len; i++){ + var c = cs[i]; + var target = c.target; + if(target){ + if(Ext.isArray(target)){ + for(var j = 0, jlen = target.length; j < jlen; j++){ + this.targets[Ext.id(target[j])] = c; + } + } else{ + this.targets[Ext.id(target)] = c; + } + } + } }, /** - * Gets the total number of records in the dataset as returned by the server. - * If using paging, for this to be accurate, the data object used by the {@link #reader Reader} - * must contain the dataset size. For remote data sources, the value for this property - * (totalProperty for {@link Ext.data.JsonReader JsonReader}, - * totalRecords for {@link Ext.data.XmlReader XmlReader}) shall be returned by a query on the server. - * Note: see the Important note in {@link #load}. - * @return {Number} The number of Records as specified in the data object passed to the Reader - * by the Proxy. - * Note: this value is not updated when changing the contents of the Store locally. + * Removes this quick tip from its element and destroys it. + * @param {String/HTMLElement/Element} el The element from which the quick tip is to be removed. */ - getTotalCount : function(){ - return this.totalLength || 0; + unregister : function(el){ + delete this.targets[Ext.id(el)]; }, - + /** - * Returns an object describing the current sort state of this Store. - * @return {Object} The sort state of the Store. An object with two properties: - * field : StringThe name of the field by which the Records are sorted. - * direction : StringThe sort order, 'ASC' or 'DESC' (case-sensitive). - * - * See {@link #sortInfo} for additional details. + * Hides a visible tip or cancels an impending show for a particular element. + * @param {String/HTMLElement/Element} el The element that is the target of the tip. */ - getSortState : function(){ - return this.sortInfo; + cancelShow: function(el){ + var at = this.activeTarget; + el = Ext.get(el).dom; + if(this.isVisible()){ + if(at && at.el == el){ + this.hide(); + } + }else if(at && at.el == el){ + this.clearTimer('show'); + } + }, + + getTipCfg: function(e) { + var t = e.getTarget(), + ttp, + cfg; + if(this.interceptTitles && t.title && Ext.isString(t.title)){ + ttp = t.title; + t.qtip = ttp; + t.removeAttribute("title"); + e.preventDefault(); + }else{ + cfg = this.tagConfig; + ttp = t.qtip || Ext.fly(t).getAttribute(cfg.attribute, cfg.namespace); + } + return ttp; }, // private - applySort : function(){ - if(this.sortInfo && !this.remoteSort){ - var s = this.sortInfo, f = s.field; - this.sortData(f, s.direction); + onTargetOver : function(e){ + if(this.disabled){ + return; + } + this.targetXY = e.getXY(); + var t = e.getTarget(); + if(!t || t.nodeType !== 1 || t == document || t == document.body){ + return; + } + if(this.activeTarget && ((t == this.activeTarget.el) || Ext.fly(this.activeTarget.el).contains(t))){ + this.clearTimer('hide'); + this.show(); + return; + } + if(t && this.targets[t.id]){ + this.activeTarget = this.targets[t.id]; + this.activeTarget.el = t; + this.anchor = this.activeTarget.anchor; + if(this.anchor){ + this.anchorTarget = t; + } + this.delayShow(); + return; + } + var ttp, et = Ext.fly(t), cfg = this.tagConfig, ns = cfg.namespace; + if(ttp = this.getTipCfg(e)){ + var autoHide = et.getAttribute(cfg.hide, ns); + this.activeTarget = { + el: t, + text: ttp, + width: et.getAttribute(cfg.width, ns), + autoHide: autoHide != "user" && autoHide !== 'false', + title: et.getAttribute(cfg.title, ns), + cls: et.getAttribute(cfg.cls, ns), + align: et.getAttribute(cfg.align, ns) + + }; + this.anchor = et.getAttribute(cfg.anchor, ns); + if(this.anchor){ + this.anchorTarget = t; + } + this.delayShow(); } }, // private - sortData : function(f, direction){ - direction = direction || 'ASC'; - var st = this.fields.get(f).sortType; - var fn = function(r1, r2){ - var v1 = st(r1.data[f]), v2 = st(r2.data[f]); - return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0); - }; - this.data.sort(direction, fn); - if(this.snapshot && this.snapshot != this.data){ - this.snapshot.sort(direction, fn); + onTargetOut : function(e){ + + // If moving within the current target, and it does not have a new tip, ignore the mouseout + if (this.activeTarget && e.within(this.activeTarget.el) && !this.getTipCfg(e)) { + return; } - }, - /** - * Sets the default sort column and order to be used by the next {@link #load} operation. - * @param {String} fieldName The name of the field to sort by. - * @param {String} dir (optional) The sort order, 'ASC' or 'DESC' (case-sensitive, defaults to 'ASC') - */ - setDefaultSort : function(field, dir){ - dir = dir ? dir.toUpperCase() : 'ASC'; - this.sortInfo = {field: field, direction: dir}; - this.sortToggle[field] = dir; + this.clearTimer('show'); + if(this.autoHide !== false){ + this.delayHide(); + } }, - /** - * Sort the Records. - * If remote sorting is used, the sort is performed on the server, and the cache is reloaded. If local - * sorting is used, the cache is sorted internally. See also {@link #remoteSort} and {@link #paramNames}. - * @param {String} fieldName The name of the field to sort by. - * @param {String} dir (optional) The sort order, 'ASC' or 'DESC' (case-sensitive, defaults to 'ASC') - */ - sort : function(fieldName, dir){ - var f = this.fields.get(fieldName); - if(!f){ - return false; - } - if(!dir){ - if(this.sortInfo && this.sortInfo.field == f.name){ // toggle sort dir - dir = (this.sortToggle[f.name] || 'ASC').toggle('ASC', 'DESC'); + // inherit docs + showAt : function(xy){ + var t = this.activeTarget; + if(t){ + if(!this.rendered){ + this.render(Ext.getBody()); + this.activeTarget = t; + } + if(t.width){ + this.setWidth(t.width); + this.body.setWidth(this.adjustBodyWidth(t.width - this.getFrameWidth())); + this.measureWidth = false; + } else{ + this.measureWidth = true; + } + this.setTitle(t.title || ''); + this.body.update(t.text); + this.autoHide = t.autoHide; + this.dismissDelay = t.dismissDelay || this.dismissDelay; + if(this.lastCls){ + this.el.removeClass(this.lastCls); + delete this.lastCls; + } + if(t.cls){ + this.el.addClass(t.cls); + this.lastCls = t.cls; + } + if(this.anchor){ + this.constrainPosition = false; + }else if(t.align){ // TODO: this doesn't seem to work consistently + xy = this.el.getAlignToXY(t.el, t.align); + this.constrainPosition = false; }else{ - dir = f.sortDir; + this.constrainPosition = true; } } - var st = (this.sortToggle) ? this.sortToggle[f.name] : null; - var si = (this.sortInfo) ? this.sortInfo : null; + Ext.QuickTip.superclass.showAt.call(this, xy); + }, - this.sortToggle[f.name] = dir; - this.sortInfo = {field: f.name, direction: dir}; - if(!this.remoteSort){ - this.applySort(); - this.fireEvent('datachanged', this); - }else{ - if (!this.load(this.lastOptions)) { - if (st) { - this.sortToggle[f.name] = st; + // inherit docs + hide: function(){ + delete this.activeTarget; + Ext.QuickTip.superclass.hide.call(this); + } +}); +Ext.reg('quicktip', Ext.QuickTip);/** + * @class Ext.QuickTips + * Provides attractive and customizable tooltips for any element. The QuickTips + * singleton is used to configure and manage tooltips globally for multiple elements + * in a generic manner. To create individual tooltips with maximum customizability, + * you should consider either {@link Ext.Tip} or {@link Ext.ToolTip}. + * Quicktips can be configured via tag attributes directly in markup, or by + * registering quick tips programmatically via the {@link #register} method. + * The singleton's instance of {@link Ext.QuickTip} is available via + * {@link #getQuickTip}, and supports all the methods, and all the all the + * configuration properties of Ext.QuickTip. These settings will apply to all + * tooltips shown by the singleton. + * Below is the summary of the configuration properties which can be used. + * For detailed descriptions see {@link #getQuickTip} + * QuickTips singleton configs (all are optional) + * dismissDelay + * hideDelay + * maxWidth + * minWidth + * showDelay + * trackMouse + * Target element configs (optional unless otherwise noted) + * autoHide + * cls + * dismissDelay (overrides singleton value) + * target (required) + * text (required) + * title + * width + * Here is an example showing how some of these config options could be used: + * +// Init the singleton. Any tag-based quick tips will start working. +Ext.QuickTips.init(); + +// Apply a set of config properties to the singleton +Ext.apply(Ext.QuickTips.getQuickTip(), { + maxWidth: 200, + minWidth: 100, + showDelay: 50, + trackMouse: true +}); + +// Manually register a quick tip for a specific element +Ext.QuickTips.register({ + target: 'my-div', + title: 'My Tooltip', + text: 'This tooltip was added in code', + width: 100, + dismissDelay: 20 +}); + + * To register a quick tip in markup, you simply add one or more of the valid QuickTip attributes prefixed with + * the ext: namespace. The HTML element itself is automatically set as the quick tip target. Here is the summary + * of supported attributes (optional unless otherwise noted): + * hide: Specifying "user" is equivalent to setting autoHide = false. Any other value will be the + * same as autoHide = true. + * qclass: A CSS class to be applied to the quick tip (equivalent to the 'cls' target element config). + * qtip (required): The quick tip text (equivalent to the 'text' target element config). + * qtitle: The quick tip title (equivalent to the 'title' target element config). + * qwidth: The quick tip width (equivalent to the 'width' target element config). + * Here is an example of configuring an HTML element to display a tooltip from markup: + * +// Add a quick tip to an HTML button +<input type="button" value="OK" ext:qtitle="OK Button" ext:qwidth="100" + ext:qtip="This is a quick tip from markup!"></input> + + * @singleton + */ +Ext.QuickTips = function(){ + var tip, locks = []; + return { + /** + * Initialize the global QuickTips instance and prepare any quick tips. + * @param {Boolean} autoRender True to render the QuickTips container immediately to preload images. (Defaults to true) + */ + init : function(autoRender){ + if(!tip){ + if(!Ext.isReady){ + Ext.onReady(function(){ + Ext.QuickTips.init(autoRender); + }); + return; } - if (si) { - this.sortInfo = si; + tip = new Ext.QuickTip({elements:'header,body'}); + if(autoRender !== false){ + tip.render(Ext.getBody()); + } + } + }, + + /** + * Enable quick tips globally. + */ + enable : function(){ + if(tip){ + locks.pop(); + if(locks.length < 1){ + tip.enable(); } } + }, + + /** + * Disable quick tips globally. + */ + disable : function(){ + if(tip){ + tip.disable(); + } + locks.push(1); + }, + + /** + * Returns true if quick tips are enabled, else false. + * @return {Boolean} + */ + isEnabled : function(){ + return tip !== undefined && !tip.disabled; + }, + + /** + * Gets the global QuickTips instance. + */ + getQuickTip : function(){ + return tip; + }, + + /** + * Configures a new quick tip instance and assigns it to a target element. See + * {@link Ext.QuickTip#register} for details. + * @param {Object} config The config object + */ + register : function(){ + tip.register.apply(tip, arguments); + }, + + /** + * Removes any registered quick tip from the target element and destroys it. + * @param {String/HTMLElement/Element} el The element from which the quick tip is to be removed. + */ + unregister : function(){ + tip.unregister.apply(tip, arguments); + }, + + /** + * Alias of {@link #register}. + * @param {Object} config The config object + */ + tips :function(){ + tip.register.apply(tip, arguments); } + } +}();/** + * @class Ext.slider.Tip + * @extends Ext.Tip + * Simple plugin for using an Ext.Tip with a slider to show the slider value. Example usage: ++new Ext.Slider({ + width: 214, + minValue: 0, + maxValue: 100, + plugins: new Ext.slider.Tip() +}); + + * Optionally provide your own tip text by overriding getText: + + new Ext.Slider({ + width: 214, + minValue: 0, + maxValue: 100, + plugins: new Ext.slider.Tip({ + getText: function(thumb){ + return String.format('{0}% complete', thumb.value); + } + }) + }); + + */ +Ext.slider.Tip = Ext.extend(Ext.Tip, { + minWidth: 10, + offsets : [0, -10], + + init: function(slider) { + slider.on({ + scope : this, + dragstart: this.onSlide, + drag : this.onSlide, + dragend : this.hide, + destroy : this.destroy + }); }, - + /** - * Calls the specified function for each of the {@link Ext.data.Record Records} in the cache. - * @param {Function} fn The function to call. The {@link Ext.data.Record Record} is passed as the first parameter. - * Returning false aborts and exits the iteration. - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. - * Defaults to the current {@link Ext.data.Record Record} in the iteration. + * @private + * Called whenever a dragstart or drag event is received on the associated Thumb. + * Aligns the Tip with the Thumb's new position. + * @param {Ext.slider.MultiSlider} slider The slider + * @param {Ext.EventObject} e The Event object + * @param {Ext.slider.Thumb} thumb The thumb that the Tip is attached to */ - each : function(fn, scope){ - this.data.each(fn, scope); + onSlide : function(slider, e, thumb) { + this.show(); + this.body.update(this.getText(thumb)); + this.doAutoWidth(); + this.el.alignTo(thumb.el, 'b-t?', this.offsets); }, /** - * Gets all {@link Ext.data.Record records} modified since the last commit. Modified records are - * persisted across load operations (e.g., during paging). Note: deleted records are not - * included. See also {@link #pruneModifiedRecords} and - * {@link Ext.data.Record}{@link Ext.data.Record#markDirty markDirty}.. - * @return {Ext.data.Record[]} An array of {@link Ext.data.Record Records} containing outstanding - * modifications. To obtain modified fields within a modified record see - *{@link Ext.data.Record}{@link Ext.data.Record#modified modified}.. + * Used to create the text that appears in the Tip's body. By default this just returns + * the value of the Slider Thumb that the Tip is attached to. Override to customize. + * @param {Ext.slider.Thumb} thumb The Thumb that the Tip is attached to + * @return {String} The text to display in the tip */ - getModifiedRecords : function(){ - return this.modified; - }, + getText : function(thumb) { + return String(thumb.value); + } +}); - // private - createFilterFn : function(property, value, anyMatch, caseSensitive){ - if(Ext.isEmpty(value, false)){ - return false; +//backwards compatibility - SliderTip used to be a ux before 3.2 +Ext.ux.SliderTip = Ext.slider.Tip;/** + * @class Ext.tree.TreePanel + * @extends Ext.Panel + * The TreePanel provides tree-structured UI representation of tree-structured data. + * {@link Ext.tree.TreeNode TreeNode}s added to the TreePanel may each contain metadata + * used by your application in their {@link Ext.tree.TreeNode#attributes attributes} property. + * A TreePanel must have a {@link #root} node before it is rendered. This may either be + * specified using the {@link #root} config option, or using the {@link #setRootNode} method. + * An example of tree rendered to an existing div: +var tree = new Ext.tree.TreePanel({ + renderTo: 'tree-div', + useArrows: true, + autoScroll: true, + animate: true, + enableDD: true, + containerScroll: true, + border: false, + // auto create TreeLoader + dataUrl: 'get-nodes.php', + + root: { + nodeType: 'async', + text: 'Ext JS', + draggable: false, + id: 'source' + } +}); + +tree.getRootNode().expand(); + * + * The example above would work with a data packet similar to this: +[{ + "text": "adapter", + "id": "source\/adapter", + "cls": "folder" +}, { + "text": "dd", + "id": "source\/dd", + "cls": "folder" +}, { + "text": "debug.js", + "id": "source\/debug.js", + "leaf": true, + "cls": "file" +}] + * + * An example of tree within a Viewport: +new Ext.Viewport({ + layout: 'border', + items: [{ + region: 'west', + collapsible: true, + title: 'Navigation', + xtype: 'treepanel', + width: 200, + autoScroll: true, + split: true, + loader: new Ext.tree.TreeLoader(), + root: new Ext.tree.AsyncTreeNode({ + expanded: true, + children: [{ + text: 'Menu Option 1', + leaf: true + }, { + text: 'Menu Option 2', + leaf: true + }, { + text: 'Menu Option 3', + leaf: true + }] + }), + rootVisible: false, + listeners: { + click: function(n) { + Ext.Msg.alert('Navigation Tree Click', 'You clicked: "' + n.attributes.text + '"'); + } } - value = this.data.createValueMatcher(value, anyMatch, caseSensitive); - return function(r){ - return value.test(r.data[property]); - }; - }, + }, { + region: 'center', + xtype: 'tabpanel', + // remaining code not shown ... + }] +}); + + * + * @cfg {Ext.tree.TreeNode} root The root node for the tree. + * @cfg {Boolean} rootVisible false to hide the root node (defaults to true) + * @cfg {Boolean} lines false to disable tree lines (defaults to true) + * @cfg {Boolean} enableDD true to enable drag and drop + * @cfg {Boolean} enableDrag true to enable just drag + * @cfg {Boolean} enableDrop true to enable just drop + * @cfg {Object} dragConfig Custom config to pass to the {@link Ext.tree.TreeDragZone} instance + * @cfg {Object} dropConfig Custom config to pass to the {@link Ext.tree.TreeDropZone} instance + * @cfg {String} ddGroup The DD group this TreePanel belongs to + * @cfg {Boolean} ddAppendOnly true if the tree should only allow append drops (use for trees which are sorted) + * @cfg {Boolean} ddScroll true to enable body scrolling + * @cfg {Boolean} containerScroll true to register this container with ScrollManager + * @cfg {Boolean} hlDrop false to disable node highlight on drop (defaults to the value of {@link Ext#enableFx}) + * @cfg {String} hlColor The color of the node highlight (defaults to 'C3DAF9') + * @cfg {Boolean} animate true to enable animated expand/collapse (defaults to the value of {@link Ext#enableFx}) + * @cfg {Boolean} singleExpand true if only 1 node per branch may be expanded + * @cfg {Object} selModel A tree selection model to use with this TreePanel (defaults to an {@link Ext.tree.DefaultSelectionModel}) + * @cfg {Boolean} trackMouseOver false to disable mouse over highlighting + * @cfg {Ext.tree.TreeLoader} loader A {@link Ext.tree.TreeLoader} for use with this TreePanel + * @cfg {String} pathSeparator The token used to separate sub-paths in path strings (defaults to '/') + * @cfg {Boolean} useArrows true to use Vista-style arrows in the tree (defaults to false) + * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}). + * + * @constructor + * @param {Object} config + * @xtype treepanel + */ +Ext.tree.TreePanel = Ext.extend(Ext.Panel, { + rootVisible : true, + animate : Ext.enableFx, + lines : true, + enableDD : false, + hlDrop : Ext.enableFx, + pathSeparator : '/', /** - * Sums the value of property for each {@link Ext.data.Record record} between start - * and end and returns the result. - * @param {String} property A field in each record - * @param {Number} start (optional) The record index to start at (defaults to 0) - * @param {Number} end (optional) The last record index to include (defaults to length - 1) - * @return {Number} The sum + * @cfg {Array} bubbleEvents + * An array of events that, when fired, should be bubbled to any parent container. + * See {@link Ext.util.Observable#enableBubble}. + * Defaults to []. */ - sum : function(property, start, end){ - var rs = this.data.items, v = 0; - start = start || 0; - end = (end || end === 0) ? end : rs.length-1; + bubbleEvents : [], - for(var i = start; i <= end; i++){ - v += (rs[i].data[property] || 0); + initComponent : function(){ + Ext.tree.TreePanel.superclass.initComponent.call(this); + + if(!this.eventModel){ + this.eventModel = new Ext.tree.TreeEventModel(this); } - return v; - }, - /** - * Filter the {@link Ext.data.Record records} by a specified property. - * @param {String} field A field on your records - * @param {String/RegExp} value Either a string that the field should begin with, or a RegExp to test - * against the field. - * @param {Boolean} anyMatch (optional) true to match any part not just the beginning - * @param {Boolean} caseSensitive (optional) true for case sensitive comparison - */ - filter : function(property, value, anyMatch, caseSensitive){ - var fn = this.createFilterFn(property, value, anyMatch, caseSensitive); - return fn ? this.filterBy(fn) : this.clearFilter(); - }, + // initialize the loader + var l = this.loader; + if(!l){ + l = new Ext.tree.TreeLoader({ + dataUrl: this.dataUrl, + requestMethod: this.requestMethod + }); + }else if(Ext.isObject(l) && !l.load){ + l = new Ext.tree.TreeLoader(l); + } + this.loader = l; - /** - * Filter by a function. The specified function will be called for each - * Record in this Store. If the function returns true the Record is included, - * otherwise it is filtered out. - * @param {Function} fn The function to be called. It will be passed the following parameters: - * record : Ext.data.RecordThe {@link Ext.data.Record record} - * to test for filtering. Access field values using {@link Ext.data.Record#get}. - * id : ObjectThe ID of the Record passed. - * - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store. - */ - filterBy : function(fn, scope){ - this.snapshot = this.snapshot || this.data; - this.data = this.queryBy(fn, scope||this); - this.fireEvent('datachanged', this); - }, + this.nodeHash = {}; - /** - * Query the records by a specified property. - * @param {String} field A field on your records - * @param {String/RegExp} value Either a string that the field - * should begin with, or a RegExp to test against the field. - * @param {Boolean} anyMatch (optional) True to match any part not just the beginning - * @param {Boolean} caseSensitive (optional) True for case sensitive comparison - * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records - */ - query : function(property, value, anyMatch, caseSensitive){ - var fn = this.createFilterFn(property, value, anyMatch, caseSensitive); - return fn ? this.queryBy(fn) : this.data.clone(); + /** + * The root node of this tree. + * @type Ext.tree.TreeNode + * @property root + */ + if(this.root){ + var r = this.root; + delete this.root; + this.setRootNode(r); + } + + + this.addEvents( + + /** + * @event append + * Fires when a new child node is appended to a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The newly appended node + * @param {Number} index The index of the newly appended node + */ + 'append', + /** + * @event remove + * Fires when a child node is removed from a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node removed + */ + 'remove', + /** + * @event movenode + * Fires when a node is moved to a new location in the tree + * @param {Tree} tree The owner tree + * @param {Node} node The node moved + * @param {Node} oldParent The old parent of this node + * @param {Node} newParent The new parent of this node + * @param {Number} index The index it was moved to + */ + 'movenode', + /** + * @event insert + * Fires when a new child node is inserted in a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node inserted + * @param {Node} refNode The child node the node was inserted before + */ + 'insert', + /** + * @event beforeappend + * Fires before a new child is appended to a node in this tree, return false to cancel the append. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be appended + */ + 'beforeappend', + /** + * @event beforeremove + * Fires before a child is removed from a node in this tree, return false to cancel the remove. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be removed + */ + 'beforeremove', + /** + * @event beforemovenode + * Fires before a node is moved to a new location in the tree. Return false to cancel the move. + * @param {Tree} tree The owner tree + * @param {Node} node The node being moved + * @param {Node} oldParent The parent of the node + * @param {Node} newParent The new parent the node is moving to + * @param {Number} index The index it is being moved to + */ + 'beforemovenode', + /** + * @event beforeinsert + * Fires before a new child is inserted in a node in this tree, return false to cancel the insert. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be inserted + * @param {Node} refNode The child node the node is being inserted before + */ + 'beforeinsert', + + /** + * @event beforeload + * Fires before a node is loaded, return false to cancel + * @param {Node} node The node being loaded + */ + 'beforeload', + /** + * @event load + * Fires when a node is loaded + * @param {Node} node The node that was loaded + */ + 'load', + /** + * @event textchange + * Fires when the text for a node is changed + * @param {Node} node The node + * @param {String} text The new text + * @param {String} oldText The old text + */ + 'textchange', + /** + * @event beforeexpandnode + * Fires before a node is expanded, return false to cancel. + * @param {Node} node The node + * @param {Boolean} deep + * @param {Boolean} anim + */ + 'beforeexpandnode', + /** + * @event beforecollapsenode + * Fires before a node is collapsed, return false to cancel. + * @param {Node} node The node + * @param {Boolean} deep + * @param {Boolean} anim + */ + 'beforecollapsenode', + /** + * @event expandnode + * Fires when a node is expanded + * @param {Node} node The node + */ + 'expandnode', + /** + * @event disabledchange + * Fires when the disabled status of a node changes + * @param {Node} node The node + * @param {Boolean} disabled + */ + 'disabledchange', + /** + * @event collapsenode + * Fires when a node is collapsed + * @param {Node} node The node + */ + 'collapsenode', + /** + * @event beforeclick + * Fires before click processing on a node. Return false to cancel the default action. + * @param {Node} node The node + * @param {Ext.EventObject} e The event object + */ + 'beforeclick', + /** + * @event click + * Fires when a node is clicked + * @param {Node} node The node + * @param {Ext.EventObject} e The event object + */ + 'click', + /** + * @event containerclick + * Fires when the tree container is clicked + * @param {Tree} this + * @param {Ext.EventObject} e The event object + */ + 'containerclick', + /** + * @event checkchange + * Fires when a node with a checkbox's checked property changes + * @param {Node} this This node + * @param {Boolean} checked + */ + 'checkchange', + /** + * @event beforedblclick + * Fires before double click processing on a node. Return false to cancel the default action. + * @param {Node} node The node + * @param {Ext.EventObject} e The event object + */ + 'beforedblclick', + /** + * @event dblclick + * Fires when a node is double clicked + * @param {Node} node The node + * @param {Ext.EventObject} e The event object + */ + 'dblclick', + /** + * @event containerdblclick + * Fires when the tree container is double clicked + * @param {Tree} this + * @param {Ext.EventObject} e The event object + */ + 'containerdblclick', + /** + * @event contextmenu + * Fires when a node is right clicked. To display a context menu in response to this + * event, first create a Menu object (see {@link Ext.menu.Menu} for details), then add + * a handler for this event: +new Ext.tree.TreePanel({ + title: 'My TreePanel', + root: new Ext.tree.AsyncTreeNode({ + text: 'The Root', + children: [ + { text: 'Child node 1', leaf: true }, + { text: 'Child node 2', leaf: true } + ] + }), + contextMenu: new Ext.menu.Menu({ + items: [{ + id: 'delete-node', + text: 'Delete Node' + }], + listeners: { + itemclick: function(item) { + switch (item.id) { + case 'delete-node': + var n = item.parentMenu.contextNode; + if (n.parentNode) { + n.remove(); + } + break; + } + } + } + }), + listeners: { + contextmenu: function(node, e) { +// Register the context node with the menu so that a Menu Item's handler function can access +// it via its {@link Ext.menu.BaseItem#parentMenu parentMenu} property. + node.select(); + var c = node.getOwnerTree().contextMenu; + c.contextNode = node; + c.showAt(e.getXY()); + } + } +}); + + * @param {Node} node The node + * @param {Ext.EventObject} e The event object + */ + 'contextmenu', + /** + * @event containercontextmenu + * Fires when the tree container is right clicked + * @param {Tree} this + * @param {Ext.EventObject} e The event object + */ + 'containercontextmenu', + /** + * @event beforechildrenrendered + * Fires right before the child nodes for a node are rendered + * @param {Node} node The node + */ + 'beforechildrenrendered', + /** + * @event startdrag + * Fires when a node starts being dragged + * @param {Ext.tree.TreePanel} this + * @param {Ext.tree.TreeNode} node + * @param {event} e The raw browser event + */ + 'startdrag', + /** + * @event enddrag + * Fires when a drag operation is complete + * @param {Ext.tree.TreePanel} this + * @param {Ext.tree.TreeNode} node + * @param {event} e The raw browser event + */ + 'enddrag', + /** + * @event dragdrop + * Fires when a dragged node is dropped on a valid DD target + * @param {Ext.tree.TreePanel} this + * @param {Ext.tree.TreeNode} node + * @param {DD} dd The dd it was dropped on + * @param {event} e The raw browser event + */ + 'dragdrop', + /** + * @event beforenodedrop + * Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent + * passed to handlers has the following properties: + * + * tree - The TreePanel + * target - The node being targeted for the drop + * data - The drag data from the drag source + * point - The point of the drop - append, above or below + * source - The drag source + * rawEvent - Raw mouse event + * dropNode - Drop node(s) provided by the source OR you can supply node(s) + * to be inserted by setting them on this object. + * cancel - Set this to true to cancel the drop. + * dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true + * will prevent the animated 'repair' from appearing. + * + * @param {Object} dropEvent + */ + 'beforenodedrop', + /** + * @event nodedrop + * Fires after a DD object is dropped on a node in this tree. The dropEvent + * passed to handlers has the following properties: + * + * tree - The TreePanel + * target - The node being targeted for the drop + * data - The drag data from the drag source + * point - The point of the drop - append, above or below + * source - The drag source + * rawEvent - Raw mouse event + * dropNode - Dropped node(s). + * + * @param {Object} dropEvent + */ + 'nodedrop', + /** + * @event nodedragover + * Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent + * passed to handlers has the following properties: + * + * tree - The TreePanel + * target - The node being targeted for the drop + * data - The drag data from the drag source + * point - The point of the drop - append, above or below + * source - The drag source + * rawEvent - Raw mouse event + * dropNode - Drop node(s) provided by the source. + * cancel - Set this to true to signal drop not allowed. + * + * @param {Object} dragOverEvent + */ + 'nodedragover' + ); + if(this.singleExpand){ + this.on('beforeexpandnode', this.restrictExpand, this); + } }, - /** - * Query the cached records in this Store using a filtering function. The specified function - * will be called with each record in this Store. If the function returns true the record is - * included in the results. - * @param {Function} fn The function to be called. It will be passed the following parameters: - * record : Ext.data.RecordThe {@link Ext.data.Record record} - * to test for filtering. Access field values using {@link Ext.data.Record#get}. - * id : ObjectThe ID of the Record passed. - * - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store. - * @return {MixedCollection} Returns an Ext.util.MixedCollection of the matched records - **/ - queryBy : function(fn, scope){ - var data = this.snapshot || this.data; - return data.filterBy(fn, scope||this); + // private + proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){ + if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){ + ename = ename+'node'; + } + // args inline for performance while bubbling events + return this.fireEvent(ename, a1, a2, a3, a4, a5, a6); }, - /** - * Finds the index of the first matching Record in this store by a specific field value. - * @param {String} fieldName The name of the Record field to test. - * @param {String/RegExp} value Either a string that the field value - * should begin with, or a RegExp to test against the field. - * @param {Number} startIndex (optional) The index to start searching at - * @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 - */ - find : function(property, value, start, anyMatch, caseSensitive){ - var fn = this.createFilterFn(property, value, anyMatch, caseSensitive); - return fn ? this.data.findIndexBy(fn, null, start) : -1; - }, /** - * Finds the index of the first matching Record in this store by a specific field value. - * @param {String} fieldName The name of the Record field to test. - * @param {Mixed} value The value to match the field against. - * @param {Number} startIndex (optional) The index to start searching at - * @return {Number} The matched index or -1 + * Returns this root node for this tree + * @return {Node} */ - findExact: function(property, value, start){ - return this.data.findIndexBy(function(rec){ - return rec.get(property) === value; - }, this, start); + getRootNode : function(){ + return this.root; }, /** - * Find the index of the first matching Record in this Store by a function. - * If the function returns true it is considered a match. - * @param {Function} fn The function to be called. It will be passed the following parameters: - * record : Ext.data.RecordThe {@link Ext.data.Record record} - * to test for filtering. Access field values using {@link Ext.data.Record#get}. - * id : ObjectThe ID of the Record passed. - * - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to this Store. - * @param {Number} startIndex (optional) The index to start searching at - * @return {Number} The matched index or -1 + * Sets the root node for this tree. If the TreePanel has already rendered a root node, the + * previous root node (and all of its descendants) are destroyed before the new root node is rendered. + * @param {Node} node + * @return {Node} */ - findBy : function(fn, scope, start){ - return this.data.findIndexBy(fn, scope, start); - }, - - /** - * Collects unique values for a particular dataIndex from this store. - * @param {String} dataIndex The property to collect - * @param {Boolean} allowNull (optional) Pass true to allow null, undefined or empty string values - * @param {Boolean} bypassFilter (optional) Pass true to collect from all records, even ones which are filtered - * @return {Array} An array of the unique values - **/ - collect : function(dataIndex, allowNull, bypassFilter){ - var d = (bypassFilter === true && this.snapshot) ? - this.snapshot.items : this.data.items; - var v, sv, r = [], l = {}; - for(var i = 0, len = d.length; i < len; i++){ - v = d[i].data[dataIndex]; - sv = String(v); - if((allowNull || !Ext.isEmpty(v)) && !l[sv]){ - l[sv] = true; - r[r.length] = v; - } + setRootNode : function(node){ + this.destroyRoot(); + if(!node.render){ // attributes passed + node = this.loader.createNode(node); } - return r; + this.root = node; + node.ownerTree = this; + node.isRoot = true; + this.registerNode(node); + if(!this.rootVisible){ + var uiP = node.attributes.uiProvider; + node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node); + } + if(this.innerCt){ + this.clearInnerCt(); + this.renderRoot(); + } + return node; }, - - /** - * Revert to a view of the Record cache with no filtering applied. - * @param {Boolean} suppressEvent If true the filter is cleared silently without firing the - * {@link #datachanged} event. - */ - clearFilter : function(suppressEvent){ - if(this.isFiltered()){ - this.data = this.snapshot; - delete this.snapshot; - if(suppressEvent !== true){ - this.fireEvent('datachanged', this); - } + + clearInnerCt : function(){ + this.innerCt.update(''); + }, + + // private + renderRoot : function(){ + this.root.render(); + if(!this.rootVisible){ + this.root.renderChildren(); } }, /** - * Returns true if this store is currently filtered - * @return {Boolean} + * Gets a node in this tree by its id + * @param {String} id + * @return {Node} */ - isFiltered : function(){ - return this.snapshot && this.snapshot != this.data; + getNodeById : function(id){ + return this.nodeHash[id]; }, // private - afterEdit : function(record){ - if(this.modified.indexOf(record) == -1){ - this.modified.push(record); - } - this.fireEvent('update', this, record, Ext.data.Record.EDIT); + registerNode : function(node){ + this.nodeHash[node.id] = node; }, // private - afterReject : function(record){ - this.modified.remove(record); - this.fireEvent('update', this, record, Ext.data.Record.REJECT); + unregisterNode : function(node){ + delete this.nodeHash[node.id]; }, // private - afterCommit : function(record){ - this.modified.remove(record); - this.fireEvent('update', this, record, Ext.data.Record.COMMIT); + toString : function(){ + return '[Tree'+(this.id?' '+this.id:'')+']'; }, - /** - * Commit all Records with {@link #getModifiedRecords outstanding changes}. To handle updates for changes, - * subscribe to the Store's {@link #update update event}, and perform updating when the third parameter is - * Ext.data.Record.COMMIT. - */ - commitChanges : function(){ - var m = this.modified.slice(0); - this.modified = []; - for(var i = 0, len = m.length; i < len; i++){ - m[i].commit(); + // private + restrictExpand : function(node){ + var p = node.parentNode; + if(p){ + if(p.expandedChild && p.expandedChild.parentNode == p){ + p.expandedChild.collapse(); + } + p.expandedChild = node; } }, /** - * {@link Ext.data.Record#reject Reject} outstanding changes on all {@link #getModifiedRecords modified records}. + * Retrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. 'id') + * @param {String} attribute (optional) Defaults to null (return the actual nodes) + * @param {TreeNode} startNode (optional) The node to start from, defaults to the root + * @return {Array} */ - rejectChanges : function(){ - var m = this.modified.slice(0); - this.modified = []; - for(var i = 0, len = m.length; i < len; i++){ - m[i].reject(); - } - var m = this.removed.slice(0).reverse(); - this.removed = []; - for(var i = 0, len = m.length; i < len; i++){ - this.insert(m[i].lastIndex||0, m[i]); - m[i].reject(); - } - }, - - // private - onMetaChange : function(meta){ - this.recordType = this.reader.recordType; - this.fields = this.recordType.prototype.fields; - delete this.snapshot; - if(this.reader.meta.sortInfo){ - this.sortInfo = this.reader.meta.sortInfo; - }else if(this.sortInfo && !this.fields.get(this.sortInfo.field)){ - delete this.sortInfo; - } - if(this.writer){ - this.writer.meta = this.reader.meta; - } - this.modified = []; - this.fireEvent('metachange', this, this.reader.meta); - }, - - // private - findInsertIndex : function(record){ - this.suspendEvents(); - var data = this.data.clone(); - this.data.add(record); - this.applySort(); - var index = this.data.indexOf(record); - this.data = data; - this.resumeEvents(); - return index; + getChecked : function(a, startNode){ + startNode = startNode || this.root; + var r = []; + var f = function(){ + if(this.attributes.checked){ + r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a])); + } + }; + startNode.cascade(f); + return r; }, /** - * Set the value for a property name in this store's {@link #baseParams}. Usage: -myStore.setBaseParam('foo', {bar:3}); - - * @param {String} name Name of the property to assign - * @param {Mixed} value Value to assign the named property - **/ - setBaseParam : function (name, value){ - this.baseParams = this.baseParams || {}; - this.baseParams[name] = value; - } -}); - -Ext.reg('store', Ext.data.Store); - -/** - * @class Ext.data.Store.Error - * @extends Ext.Error - * Store Error extension. - * @param {String} name - */ -Ext.data.Store.Error = Ext.extend(Ext.Error, { - name: 'Ext.data.Store' -}); -Ext.apply(Ext.data.Store.Error.prototype, { - lang: { - 'writer-undefined' : 'Attempted to execute a write-action without a DataWriter installed.' - } -}); -/** - * @class Ext.data.Field - * This class encapsulates the field definition information specified in the field definition objects - * passed to {@link Ext.data.Record#create}. - * Developers do not need to instantiate this class. Instances are created by {@link Ext.data.Record.create} - * and cached in the {@link Ext.data.Record#fields fields} property of the created Record constructor's prototype. - */ -Ext.data.Field = function(config){ - if(typeof config == "string"){ - config = {name: config}; - } - Ext.apply(this, config); - - if(!this.type){ - this.type = "auto"; - } - - var st = Ext.data.SortTypes; - // named sortTypes are supported, here we look them up - if(typeof this.sortType == "string"){ - this.sortType = st[this.sortType]; - } - - // set default sortType for strings and dates - if(!this.sortType){ - switch(this.type){ - case "string": - this.sortType = st.asUCString; - break; - case "date": - this.sortType = st.asDate; - break; - default: - this.sortType = st.none; - } - } - - // define once - var stripRe = /[\$,%]/g; - - // prebuilt conversion function for this field, instead of - // switching every time we're reading a value - if(!this.convert){ - var cv, dateFormat = this.dateFormat; - switch(this.type){ - case "": - case "auto": - case undefined: - cv = function(v){ return v; }; - break; - case "string": - cv = function(v){ return (v === undefined || v === null) ? '' : String(v); }; - break; - case "int": - cv = function(v){ - return v !== undefined && v !== null && v !== '' ? - parseInt(String(v).replace(stripRe, ""), 10) : ''; - }; - break; - case "float": - cv = function(v){ - return v !== undefined && v !== null && v !== '' ? - parseFloat(String(v).replace(stripRe, ""), 10) : ''; - }; - break; - case "bool": - cv = function(v){ return v === true || v === "true" || v == 1; }; - break; - case "date": - cv = function(v){ - if(!v){ - return ''; - } - if(Ext.isDate(v)){ - return v; - } - if(dateFormat){ - if(dateFormat == "timestamp"){ - return new Date(v*1000); - } - if(dateFormat == "time"){ - return new Date(parseInt(v, 10)); - } - return Date.parseDate(v, dateFormat); - } - var parsed = Date.parse(v); - return parsed ? new Date(parsed) : null; - }; - break; - default: - cv = function(v){ return v; }; - break; - - } - this.convert = cv; - } -}; - -Ext.data.Field.prototype = { - /** - * @cfg {String} name - * The name by which the field is referenced within the Record. This is referenced by, for example, - * the dataIndex property in column definition objects passed to {@link Ext.grid.ColumnModel}. - * Note: In the simplest case, if no properties other than name are required, a field - * definition may consist of just a String for the field name. - */ - /** - * @cfg {String} type - * (Optional) The data type for conversion to displayable value if {@link Ext.data.Field#convert convert} - * has not been specified. Possible values are - * - * auto (Default, implies no conversion) - * string - * int - * float - * boolean - * date + * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel. + * @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel. */ - /** - * @cfg {Function} convert - * (Optional) A function which converts the value provided by the Reader into an object that will be stored - * in the Record. It is passed the following parameters: - * v : MixedThe data value as read by the Reader, if undefined will use - * the configured {@link Ext.data.Field#defaultValue defaultValue}. - * rec : MixedThe data object containing the row as read by the Reader. - * Depending on the Reader type, this could be an Array ({@link Ext.data.ArrayReader ArrayReader}), an object - * ({@link Ext.data.JsonReader JsonReader}), or an XML element ({@link Ext.data.XMLReader XMLReader}). - * - * -// example of convert function -function fullName(v, record){ - return record.name.last + ', ' + record.name.first; -} - -function location(v, record){ - return !record.city ? '' : (record.city + ', ' + record.state); -} - -var Dude = Ext.data.Record.create([ - {name: 'fullname', convert: fullName}, - {name: 'firstname', mapping: 'name.first'}, - {name: 'lastname', mapping: 'name.last'}, - {name: 'city', defaultValue: 'homeless'}, - 'state', - {name: 'location', convert: location} -]); - -// create the data store -var store = new Ext.data.Store({ - reader: new Ext.data.JsonReader( - { - idProperty: 'key', - root: 'daRoot', - totalProperty: 'total' - }, - Dude // recordType - ) -}); - -var myData = [ - { key: 1, - name: { first: 'Fat', last: 'Albert' } - // notice no city, state provided in data object - }, - { key: 2, - name: { first: 'Barney', last: 'Rubble' }, - city: 'Bedrock', state: 'Stoneridge' + getLoader : function(){ + return this.loader; }, - { key: 3, - name: { first: 'Cliff', last: 'Claven' }, - city: 'Boston', state: 'MA' - } -]; - * - */ - /** - * @cfg {String} dateFormat - * (Optional) A format string for the {@link Date#parseDate Date.parseDate} function, or "timestamp" if the - * value provided by the Reader is a UNIX timestamp, or "time" if the value provided by the Reader is a - * javascript millisecond timestamp. - */ - dateFormat: null, - /** - * @cfg {Mixed} defaultValue - * (Optional) The default value used when a Record is being created by a {@link Ext.data.Reader Reader} - * when the item referenced by the {@link Ext.data.Field#mapping mapping} does not exist in the data - * object (i.e. undefined). (defaults to "") - */ - defaultValue: "", - /** - * @cfg {String/Number} mapping - * (Optional) A path expression for use by the {@link Ext.data.DataReader} implementation - * that is creating the {@link Ext.data.Record Record} to extract the Field value from the data object. - * If the path expression is the same as the field name, the mapping may be omitted. - * The form of the mapping expression depends on the Reader being used. - * - * {@link Ext.data.JsonReader}The mapping is a string containing the javascript - * expression to reference the data from an element of the data item's {@link Ext.data.JsonReader#root root} Array. Defaults to the field name. - * {@link Ext.data.XmlReader}The mapping is an {@link Ext.DomQuery} path to the data - * item relative to the DOM element that represents the {@link Ext.data.XmlReader#record record}. Defaults to the field name. - * {@link Ext.data.ArrayReader}The mapping is a number indicating the Array index - * of the field's value. Defaults to the field specification's Array position. - * - * If a more complex value extraction strategy is required, then configure the Field with a {@link #convert} - * function. This is passed the whole row object, and may interrogate it in whatever way is necessary in order to - * return the desired data. - */ - mapping: null, - /** - * @cfg {Function} sortType - * (Optional) A function which converts a Field's value to a comparable value in order to ensure - * correct sort ordering. Predefined functions are provided in {@link Ext.data.SortTypes}. A custom - * sort example: -// current sort after sort we want -// +-+------+ +-+------+ -// |1|First | |1|First | -// |2|Last | |3|Second| -// |3|Second| |2|Last | -// +-+------+ +-+------+ -sortType: function(value) { - switch (value.toLowerCase()) // native toLowerCase(): - { - case 'first': return 1; - case 'second': return 2; - default: return 3; - } -} - * - */ - sortType : null, - /** - * @cfg {String} sortDir - * (Optional) Initial direction to sort ("ASC" or "DESC"). Defaults to - * "ASC". - */ - sortDir : "ASC", /** - * @cfg {Boolean} allowBlank - * (Optional) Used for validating a {@link Ext.data.Record record}, defaults to true. - * An empty value here will cause {@link Ext.data.Record}.{@link Ext.data.Record#isValid isValid} - * to evaluate to false. + * Expand all nodes */ - allowBlank : true -};/** - * @class Ext.data.DataReader - * Abstract base class for reading structured data from a data source and converting - * it into an object containing {@link Ext.data.Record} objects and metadata for use - * by an {@link Ext.data.Store}. This class is intended to be extended and should not - * be created directly. For existing implementations, see {@link Ext.data.ArrayReader}, - * {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader}. - * @constructor Create a new DataReader - * @param {Object} meta Metadata configuration options (implementation-specific). - * @param {Array/Object} recordType - * Either an Array of {@link Ext.data.Field Field} definition objects (which - * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record} - * constructor created using {@link Ext.data.Record#create}. - */ -Ext.data.DataReader = function(meta, recordType){ - /** - * This DataReader's configured metadata as passed to the constructor. - * @type Mixed - * @property meta - */ - this.meta = meta; - /** - * @cfg {Array/Object} fields - * Either an Array of {@link Ext.data.Field Field} definition objects (which - * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record} - * constructor created from {@link Ext.data.Record#create}. - */ - this.recordType = Ext.isArray(recordType) ? - Ext.data.Record.create(recordType) : recordType; - - // if recordType defined make sure extraction functions are defined - if (this.recordType){ - this.buildExtractors(); - } -}; - -Ext.data.DataReader.prototype = { - /** - * @cfg {String} messageProperty [undefined] Optional name of a property within a server-response that represents a user-feedback message. - */ - /** - * Abstract method created in extension's buildExtractors impl. - */ - getTotal: Ext.emptyFn, - /** - * Abstract method created in extension's buildExtractors impl. - */ - getRoot: Ext.emptyFn, - /** - * Abstract method created in extension's buildExtractors impl. - */ - getMessage: Ext.emptyFn, - /** - * Abstract method created in extension's buildExtractors impl. - */ - getSuccess: Ext.emptyFn, - /** - * Abstract method created in extension's buildExtractors impl. - */ - getId: Ext.emptyFn, - /** - * Abstract method, overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader} - */ - buildExtractors : Ext.emptyFn, - /** - * Abstract method overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader} - */ - extractData : Ext.emptyFn, - /** - * Abstract method overridden in DataReader extensions such as {@link Ext.data.JsonReader} and {@link Ext.data.XmlReader} - */ - extractValues : Ext.emptyFn, - - /** - * Used for un-phantoming a record after a successful database insert. Sets the records pk along with new data from server. - * You must return at least the database pk using the idProperty defined in your DataReader configuration. The incoming - * data from server will be merged with the data in the local record. - * In addition, you must return record-data from the server in the same order received. - * Will perform a commit as well, un-marking dirty-fields. Store's "update" event will be suppressed. - * @param {Record/Record[]} record The phantom record to be realized. - * @param {Object/Object[]} data The new record data to apply. Must include the primary-key from database defined in idProperty field. - */ - realize: function(rs, data){ - if (Ext.isArray(rs)) { - for (var i = rs.length - 1; i >= 0; i--) { - // recurse - if (Ext.isArray(data)) { - this.realize(rs.splice(i,1).shift(), data.splice(i,1).shift()); - } - else { - // weird...rs is an array but data isn't?? recurse but just send in the whole invalid data object. - // the else clause below will detect !this.isData and throw exception. - this.realize(rs.splice(i,1).shift(), data); - } - } - } - else { - // If rs is NOT an array but data IS, see if data contains just 1 record. If so extract it and carry on. - if (Ext.isArray(data) && data.length == 1) { - data = data.shift(); - } - if (!this.isData(data)) { - // TODO: Let exception-handler choose to commit or not rather than blindly rs.commit() here. - //rs.commit(); - throw new Ext.data.DataReader.Error('realize', rs); - } - rs.phantom = false; // <-- That's what it's all about - rs._phid = rs.id; // <-- copy phantom-id -> _phid, so we can remap in Store#onCreateRecords - rs.id = this.getId(data); - - rs.fields.each(function(f) { - if (data[f.name] !== f.defaultValue) { - rs.data[f.name] = data[f.name]; - } - }); - rs.commit(); - } - }, - - /** - * Used for updating a non-phantom or "real" record's data with fresh data from server after remote-save. - * If returning data from multiple-records after a batch-update, you must return record-data from the server in - * the same order received. Will perform a commit as well, un-marking dirty-fields. Store's "update" event will be - * suppressed as the record receives fresh new data-hash - * @param {Record/Record[]} rs - * @param {Object/Object[]} data - */ - update : function(rs, data) { - if (Ext.isArray(rs)) { - for (var i=rs.length-1; i >= 0; i--) { - if (Ext.isArray(data)) { - this.update(rs.splice(i,1).shift(), data.splice(i,1).shift()); - } - else { - // weird...rs is an array but data isn't?? recurse but just send in the whole data object. - // the else clause below will detect !this.isData and throw exception. - this.update(rs.splice(i,1).shift(), data); - } - } - } - else { - // If rs is NOT an array but data IS, see if data contains just 1 record. If so extract it and carry on. - if (Ext.isArray(data) && data.length == 1) { - data = data.shift(); - } - if (this.isData(data)) { - rs.fields.each(function(f) { - if (data[f.name] !== f.defaultValue) { - rs.data[f.name] = data[f.name]; - } - }); - } - rs.commit(); - } - }, - - /** - * returns extracted, type-cast rows of data. Iterates to call #extractValues for each row - * @param {Object[]/Object} data-root from server response - * @param {Boolean} returnRecords [false] Set true to return instances of Ext.data.Record - * @private - */ - extractData : function(root, returnRecords) { - // A bit ugly this, too bad the Record's raw data couldn't be saved in a common property named "raw" or something. - var rawName = (this instanceof Ext.data.JsonReader) ? 'json' : 'node'; - - var rs = []; - - // Had to add Check for XmlReader, #isData returns true if root is an Xml-object. Want to check in order to re-factor - // #extractData into DataReader base, since the implementations are almost identical for JsonReader, XmlReader - if (this.isData(root) && !(this instanceof Ext.data.XmlReader)) { - root = [root]; - } - var f = this.recordType.prototype.fields, - fi = f.items, - fl = f.length, - rs = []; - if (returnRecords === true) { - var Record = this.recordType; - for (var i = 0; i < root.length; i++) { - var n = root[i]; - var record = new Record(this.extractValues(n, fi, fl), this.getId(n)); - record[rawName] = n; // <-- There's implementation of ugly bit, setting the raw record-data. - rs.push(record); - } - } - else { - for (var i = 0; i < root.length; i++) { - var data = this.extractValues(root[i], fi, fl); - data[this.meta.idProperty] = this.getId(root[i]); - rs.push(data); - } - } - return rs; - }, - - /** - * Returns true if the supplied data-hash looks and quacks like data. Checks to see if it has a key - * corresponding to idProperty defined in your DataReader config containing non-empty pk. - * @param {Object} data - * @return {Boolean} - */ - isData : function(data) { - return (data && Ext.isObject(data) && !Ext.isEmpty(this.getId(data))) ? true : false; - }, - - // private function a store will createSequence upon - onMetaChange : function(meta){ - delete this.ef; - this.meta = meta; - this.recordType = Ext.data.Record.create(meta.fields); - this.buildExtractors(); - } -}; - -/** - * @class Ext.data.DataReader.Error - * @extends Ext.Error - * General error class for Ext.data.DataReader - */ -Ext.data.DataReader.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); - }, - name: 'Ext.data.DataReader' -}); -Ext.apply(Ext.data.DataReader.Error.prototype, { - lang : { - 'update': "#update received invalid data from server. Please see docs for DataReader#update and review your DataReader configuration.", - 'realize': "#realize was called with invalid remote-data. Please see the docs for DataReader#realize and review your DataReader configuration.", - 'invalid-response': "#readResponse received an invalid response from the server." - } -}); -/** - * @class Ext.data.DataWriter - * Ext.data.DataWriter facilitates create, update, and destroy actions between - * an Ext.data.Store and a server-side framework. A Writer enabled Store will - * automatically manage the Ajax requests to perform CRUD actions on a Store. - * Ext.data.DataWriter is an abstract base class which is intended to be extended - * and should not be created directly. For existing implementations, see - * {@link Ext.data.JsonWriter}. - * Creating a writer is simple: - * -var writer = new Ext.data.JsonWriter({ - encode: false // <--- false causes data to be printed to jsonData config-property of Ext.Ajax#reqeust -}); - * - * * Same old JsonReader as Ext-2.x: - * -var reader = new Ext.data.JsonReader({idProperty: 'id'}, [{name: 'first'}, {name: 'last'}, {name: 'email'}]); - * - * - * The proxy for a writer enabled store can be configured with a simple url: - * -// Create a standard HttpProxy instance. -var proxy = new Ext.data.HttpProxy({ - url: 'app.php/users' // <--- Supports "provides"-type urls, such as '/users.json', '/products.xml' (Hello Rails/Merb) -}); - * - * For finer grained control, the proxy may also be configured with an API: - * -// Maximum flexibility with the API-configuration -var proxy = new Ext.data.HttpProxy({ - api: { - read : 'app.php/users/read', - create : 'app.php/users/create', - update : 'app.php/users/update', - destroy : { // <--- Supports object-syntax as well - url: 'app.php/users/destroy', - method: "DELETE" - } - } -}); - * - * Pulling it all together into a Writer-enabled Store: - * -var store = new Ext.data.Store({ - proxy: proxy, - reader: reader, - writer: writer, - autoLoad: true, - autoSave: true // -- Cell-level updates. -}); - * - * Initiating write-actions automatically, using the existing Ext2.0 Store/Record API: - * -var rec = store.getAt(0); -rec.set('email', 'foo@bar.com'); // <--- Immediately initiates an UPDATE action through configured proxy. - -store.remove(rec); // <---- Immediately initiates a DESTROY action through configured proxy. - * - * For record/batch updates, use the Store-configuration {@link Ext.data.Store#autoSave autoSave:false} - * -var store = new Ext.data.Store({ - proxy: proxy, - reader: reader, - writer: writer, - autoLoad: true, - autoSave: false // -- disable cell-updates -}); - -var urec = store.getAt(0); -urec.set('email', 'foo@bar.com'); - -var drec = store.getAt(1); -store.remove(drec); - -// Push the button! -store.save(); - * - * @constructor Create a new DataWriter - * @param {Object} meta Metadata configuration options (implementation-specific) - * @param {Object} recordType Either an Array of field definition objects as specified - * in {@link Ext.data.Record#create}, or an {@link Ext.data.Record} object created - * using {@link Ext.data.Record#create}. - */ -Ext.data.DataWriter = function(config){ - Ext.apply(this, config); -}; -Ext.data.DataWriter.prototype = { + expandAll : function(){ + this.root.expand(true); + }, /** - * @cfg {Boolean} writeAllFields - * false by default. Set true to have DataWriter return ALL fields of a modified - * record -- not just those that changed. - * false to have DataWriter only request modified fields from a record. + * Collapse all nodes */ - writeAllFields : false, + collapseAll : function(){ + this.root.collapse(true); + }, + /** - * @cfg {Boolean} listful - * false by default. Set true to have the DataWriter always write HTTP params as a list, - * even when acting upon a single record. + * Returns the selection model used by this TreePanel. + * @return {TreeSelectionModel} The selection model used by this TreePanel */ - listful : false, // <-- listful is actually not used internally here in DataWriter. @see Ext.data.Store#execute. + getSelectionModel : function(){ + if(!this.selModel){ + this.selModel = new Ext.tree.DefaultSelectionModel(); + } + return this.selModel; + }, /** - * Compiles a Store recordset into a data-format defined by an extension such as {@link Ext.data.JsonWriter} or {@link Ext.data.XmlWriter} in preparation for a {@link Ext.data.Api#actions server-write action}. The first two params are similar similar in nature to {@link Ext#apply}, - * Where the first parameter is the receiver of paramaters and the second, baseParams, the source. - * @param {Object} params The request-params receiver. - * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}. The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}. - * @param {String} action [{@link Ext.data.Api#actions create|update|destroy}] - * @param {Record/Record[]} rs The recordset to write, the subject(s) of the write action. + * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath} + * @param {String} path + * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info) + * @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with + * (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded. */ - apply : function(params, baseParams, action, rs) { - var data = [], - renderer = action + 'Record'; - // TODO implement @cfg listful here - if (Ext.isArray(rs)) { - Ext.each(rs, function(rec){ - data.push(this[renderer](rec)); - }, this); + expandPath : function(path, attr, callback){ + attr = attr || 'id'; + var keys = path.split(this.pathSeparator); + var curNode = this.root; + if(curNode.attributes[attr] != keys[1]){ // invalid root + if(callback){ + callback(false, null); + } + return; } - else if (rs instanceof Ext.data.Record) { - data = this[renderer](rs); + var index = 1; + var f = function(){ + if(++index == keys.length){ + if(callback){ + callback(true, curNode); + } + return; + } + var c = curNode.findChild(attr, keys[index]); + if(!c){ + if(callback){ + callback(false, curNode); + } + return; + } + curNode = c; + c.expand(false, false, f); + }; + curNode.expand(false, false, f); + }, + + /** + * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath} + * @param {String} path + * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info) + * @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with + * (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node. + */ + selectPath : function(path, attr, callback){ + attr = attr || 'id'; + var keys = path.split(this.pathSeparator), + v = keys.pop(); + if(keys.length > 1){ + var f = function(success, node){ + if(success && node){ + var n = node.findChild(attr, v); + if(n){ + n.select(); + if(callback){ + callback(true, n); + } + }else if(callback){ + callback(false, n); + } + }else{ + if(callback){ + callback(false, n); + } + } + }; + this.expandPath(keys.join(this.pathSeparator), attr, f); + }else{ + this.root.select(); + if(callback){ + callback(true, this.root); + } } - this.render(params, baseParams, data); }, /** - * abstract method meant to be overridden by all DataWriter extensions. It's the extension's job to apply the "data" to the "params". - * The data-object provided to render is populated with data according to the meta-info defined in the user's DataReader config, - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Record[]} rs Store recordset - * @param {Object} params Http params to be sent to server. - * @param {Object} data object populated according to DataReader meta-data. + * Returns the underlying Element for this tree + * @return {Ext.Element} The Element */ - render : Ext.emptyFn, + getTreeEl : function(){ + return this.body; + }, + + // private + onRender : function(ct, position){ + Ext.tree.TreePanel.superclass.onRender.call(this, ct, position); + this.el.addClass('x-tree'); + this.innerCt = this.body.createChild({tag:'ul', + cls:'x-tree-root-ct ' + + (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')}); + }, + + // private + initEvents : function(){ + Ext.tree.TreePanel.superclass.initEvents.call(this); + + if(this.containerScroll){ + Ext.dd.ScrollManager.register(this.body); + } + if((this.enableDD || this.enableDrop) && !this.dropZone){ + /** + * The dropZone used by this tree if drop is enabled (see {@link #enableDD} or {@link #enableDrop}) + * @property dropZone + * @type Ext.tree.TreeDropZone + */ + this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || { + ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true + }); + } + if((this.enableDD || this.enableDrag) && !this.dragZone){ + /** + * The dragZone used by this tree if drag is enabled (see {@link #enableDD} or {@link #enableDrag}) + * @property dragZone + * @type Ext.tree.TreeDragZone + */ + this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || { + ddGroup: this.ddGroup || 'TreeDD', + scroll: this.ddScroll + }); + } + this.getSelectionModel().init(this); + }, + + // private + afterRender : function(){ + Ext.tree.TreePanel.superclass.afterRender.call(this); + this.renderRoot(); + }, + beforeDestroy : function(){ + if(this.rendered){ + Ext.dd.ScrollManager.unregister(this.body); + Ext.destroy(this.dropZone, this.dragZone); + } + this.destroyRoot(); + Ext.destroy(this.loader); + this.nodeHash = this.root = this.loader = null; + Ext.tree.TreePanel.superclass.beforeDestroy.call(this); + }, + /** - * @cfg {Function} updateRecord Abstract method that should be implemented in all subclasses - * (e.g.: {@link Ext.data.JsonWriter#updateRecord JsonWriter.updateRecord} + * Destroy the root node. Not included by itself because we need to pass the silent parameter. + * @private */ - updateRecord : Ext.emptyFn, + destroyRoot : function(){ + if(this.root && this.root.destroy){ + this.root.destroy(true); + } + } /** - * @cfg {Function} createRecord Abstract method that should be implemented in all subclasses - * (e.g.: {@link Ext.data.JsonWriter#createRecord JsonWriter.createRecord}) + * @cfg {String/Number} activeItem + * @hide */ - createRecord : Ext.emptyFn, - /** - * @cfg {Function} destroyRecord Abstract method that should be implemented in all subclasses - * (e.g.: {@link Ext.data.JsonWriter#destroyRecord JsonWriter.destroyRecord}) + * @cfg {Boolean} autoDestroy + * @hide */ - destroyRecord : Ext.emptyFn, - /** - * Converts a Record to a hash, taking into account the state of the Ext.data.Record along with configuration properties - * related to its rendering, such as {@link #writeAllFields}, {@link Ext.data.Record#phantom phantom}, {@link Ext.data.Record#getChanges getChanges} and - * {@link Ext.data.DataReader#idProperty idProperty} - * @param {Ext.data.Record} - * @param {Object} config NOT YET IMPLEMENTED. Will implement an exlude/only configuration for fine-control over which fields do/don't get rendered. - * @return {Object} - * @protected - * TODO Implement excludes/only configuration with 2nd param? + * @cfg {Object/String/Function} autoLoad + * @hide */ - toHash : function(rec, config) { - var map = rec.fields.map, - data = {}, - raw = (this.writeAllFields === false && rec.phantom === false) ? rec.getChanges() : rec.data, - m; - Ext.iterate(raw, function(prop, value){ - if((m = map[prop])){ - data[m.mapping ? m.mapping : m.name] = value; - } - }); - // we don't want to write Ext auto-generated id to hash. Careful not to remove it on Models not having auto-increment pk though. - // We can tell its not auto-increment if the user defined a DataReader field for it *and* that field's value is non-empty. - // we could also do a RegExp here for the Ext.data.Record AUTO_ID prefix. - if (rec.phantom) { - if (rec.fields.containsKey(this.meta.idProperty) && Ext.isEmpty(rec.data[this.meta.idProperty])) { - delete data[this.meta.idProperty]; - } - } else { - data[this.meta.idProperty] = rec.id - } - return data; - }, - /** - * Converts a {@link Ext.data.DataWriter#toHash Hashed} {@link Ext.data.Record} to fields-array array suitable - * for encoding to xml via XTemplate, eg: -<tpl for="."><{name}>{value}</{name}</tpl> - * eg, non-phantom: -{id: 1, first: 'foo', last: 'bar'} --> [{name: 'id', value: 1}, {name: 'first', value: 'foo'}, {name: 'last', value: 'bar'}] - * {@link Ext.data.Record#phantom Phantom} records will have had their idProperty omitted in {@link #toHash} if determined to be auto-generated. - * Non AUTOINCREMENT pks should have been protected. - * @param {Hash} data Hashed by Ext.data.DataWriter#toHash - * @return {[Object]} Array of attribute-objects. - * @protected + * @cfg {Boolean} autoWidth + * @hide */ - toArray : function(data) { - var fields = []; - Ext.iterate(data, function(k, v) {fields.push({name: k, value: v});},this); - return fields; - } -};/** - * @class Ext.data.DataProxy - * @extends Ext.util.Observable - * Abstract base class for implementations which provide retrieval of unformatted data objects. - * This class is intended to be extended and should not be created directly. For existing implementations, - * see {@link Ext.data.DirectProxy}, {@link Ext.data.HttpProxy}, {@link Ext.data.ScriptTagProxy} and - * {@link Ext.data.MemoryProxy}. - * DataProxy implementations are usually used in conjunction with an implementation of {@link Ext.data.DataReader} - * (of the appropriate type which knows how to parse the data object) to provide a block of - * {@link Ext.data.Records} to an {@link Ext.data.Store}. - * The parameter to a DataProxy constructor may be an {@link Ext.data.Connection} or can also be the - * config object to an {@link Ext.data.Connection}. - * Custom implementations must implement either the doRequest method (preferred) or the - * load method (deprecated). See - * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#doRequest doRequest} or - * {@link Ext.data.HttpProxy}.{@link Ext.data.HttpProxy#load load} for additional details. - * Example 1 - * -proxy: new Ext.data.ScriptTagProxy({ - {@link Ext.data.Connection#url url}: 'http://extjs.com/forum/topics-remote.php' -}), - * - * Example 2 - * -proxy : new Ext.data.HttpProxy({ - {@link Ext.data.Connection#method method}: 'GET', - {@link Ext.data.HttpProxy#prettyUrls prettyUrls}: false, - {@link Ext.data.Connection#url url}: 'local/default.php', // see options parameter for {@link Ext.Ajax#request} - {@link #api}: { - // all actions except the following will use above url - create : 'local/new.php', - update : 'local/update.php' - } -}), - * - * And new in Ext version 3, attach centralized event-listeners upon the DataProxy class itself! This is a great place - * to implement a messaging system to centralize your application's user-feedback and error-handling. - * -// Listen to all "beforewrite" event fired by all proxies. -Ext.data.DataProxy.on('beforewrite', function(proxy, action) { - console.log('beforewrite: ', action); -}); - -// Listen to "write" event fired by all proxies -Ext.data.DataProxy.on('write', function(proxy, action, data, res, rs) { - console.info('write: ', action); -}); - -// Listen to "exception" event fired by all proxies -Ext.data.DataProxy.on('exception', function(proxy, type, action) { - console.error(type + action + ' exception); -}); - * - * Note: These three events are all fired with the signature of the corresponding DataProxy instance event {@link #beforewrite beforewrite}, {@link #write write} and {@link #exception exception}. - */ -Ext.data.DataProxy = function(conn){ - // make sure we have a config object here to support ux proxies. - // All proxies should now send config into superclass constructor. - conn = conn || {}; - - // This line caused a bug when people use custom Connection object having its own request method. - // http://extjs.com/forum/showthread.php?t=67194. Have to set DataProxy config - //Ext.applyIf(this, conn); - - this.api = conn.api; - this.url = conn.url; - this.restful = conn.restful; - this.listeners = conn.listeners; - - // deprecated - this.prettyUrls = conn.prettyUrls; - - /** - * @cfg {Object} api - * Specific urls to call on CRUD action methods "read", "create", "update" and "destroy". - * Defaults to: -api: { - read : undefined, - create : undefined, - update : undefined, - destroy : undefined -} - * - * The url is built based upon the action being executed [load|create|save|destroy] - * using the commensurate {@link #api} property, or if undefined default to the - * configured {@link Ext.data.Store}.{@link Ext.data.Store#url url}. - * For example: - * -api: { - load : '/controller/load', - create : '/controller/new', // Server MUST return idProperty of new record - save : '/controller/update', - destroy : '/controller/destroy_action' -} - -// Alternatively, one can use the object-form to specify each API-action -api: { - load: {url: 'read.php', method: 'GET'}, - create: 'create.php', - destroy: 'destroy.php', - save: 'update.php' -} - * - * If the specific URL for a given CRUD action is undefined, the CRUD action request - * will be directed to the configured {@link Ext.data.Connection#url url}. - * Note: To modify the URL for an action dynamically the appropriate API - * property should be modified before the action is requested using the corresponding before - * action event. For example to modify the URL associated with the load action: - * -// modify the url for the action -myStore.on({ - beforeload: { - fn: function (store, options) { - // use {@link Ext.data.HttpProxy#setUrl setUrl} to change the URL for *just* this request. - store.proxy.setUrl('changed1.php'); - - // set optional second parameter to true to make this URL change - // permanent, applying this URL for all subsequent requests. - store.proxy.setUrl('changed1.php', true); - - // Altering the proxy API should be done using the public - // method {@link Ext.data.DataProxy#setApi setApi}. - store.proxy.setApi('read', 'changed2.php'); - - // Or set the entire API with a config-object. - // When using the config-object option, you must redefine the entire - // API -- not just a specific action of it. - store.proxy.setApi({ - read : 'changed_read.php', - create : 'changed_create.php', - update : 'changed_update.php', - destroy : 'changed_destroy.php' - }); - } - } -}); - * - * - */ - - this.addEvents( - /** - * @event exception - * Fires if an exception occurs in the Proxy during a remote request. This event is relayed - * through a corresponding {@link Ext.data.Store}.{@link Ext.data.Store#exception exception}, - * so any Store instance may observe this event. - * In addition to being fired through the DataProxy instance that raised the event, this event is also fired - * through the Ext.data.DataProxy class to allow for centralized processing of exception events from all - * DataProxies by attaching a listener to the Ext.data.Proxy class itself. - * This event can be fired for one of two reasons: - * - * remote-request failed : - * The server did not return status === 200. - * - * remote-request succeeded : - * The remote-request succeeded but the reader could not read the response. - * This means the server returned data, but the configured Reader threw an - * error while reading the response. In this case, this event will be - * raised and the caught error will be passed along into this event. - * - * - * This event fires with two different contexts based upon the 2nd - * parameter type [remote|response]. The first four parameters - * are identical between the two contexts -- only the final two parameters - * differ. - * @param {DataProxy} this The proxy that sent the request - * @param {String} type - * The value of this parameter will be either 'response' or 'remote'. - * - * 'response' : - * An invalid response from the server was returned: either 404, - * 500 or the response meta-data does not match that defined in the DataReader - * (e.g.: root, idProperty, successProperty). - * - * 'remote' : - * A valid response was returned from the server having - * successProperty === false. This response might contain an error-message - * sent from the server. For example, the user may have failed - * authentication/authorization or a database validation error occurred. - * - * - * @param {String} action Name of the action (see {@link Ext.data.Api#actions}. - * @param {Object} options The options for the action that were specified in the {@link #request}. - * @param {Object} response - * The value of this parameter depends on the value of the type parameter: - * - * 'response' : - * The raw browser response object (e.g.: XMLHttpRequest) - * - * 'remote' : - * The decoded response object sent from the server. - * - * - * @param {Mixed} arg - * The type and value of this parameter depends on the value of the type parameter: - * - * 'response' : Error - * The JavaScript Error object caught if the configured Reader could not read the data. - * If the remote request returns success===false, this parameter will be null. - * - * 'remote' : Record/Record[] - * This parameter will only exist if the action was a write action - * (Ext.data.Api.actions.create|update|destroy). - * - * - */ - 'exception', - /** - * @event beforeload - * Fires before a request to retrieve a data object. - * @param {DataProxy} this The proxy for the request - * @param {Object} params The params object passed to the {@link #request} function - */ - 'beforeload', - /** - * @event load - * Fires before the load method's callback is called. - * @param {DataProxy} this The proxy for the request - * @param {Object} o The request transaction object - * @param {Object} options The callback's options property as passed to the {@link #request} function - */ - 'load', - /** - * @event loadexception - * This event is deprecated. The signature of the loadexception event - * varies depending on the proxy, use the catch-all {@link #exception} event instead. - * This event will fire in addition to the {@link #exception} event. - * @param {misc} misc See {@link #exception}. - * @deprecated - */ - 'loadexception', - /** - * @event beforewrite - * Fires before a request is generated for one of the actions Ext.data.Api.actions.create|update|destroy - * In addition to being fired through the DataProxy instance that raised the event, this event is also fired - * through the Ext.data.DataProxy class to allow for centralized processing of beforewrite events from all - * DataProxies by attaching a listener to the Ext.data.Proxy class itself. - * @param {DataProxy} this The proxy for the request - * @param {String} action [Ext.data.Api.actions.create|update|destroy] - * @param {Record/Array[Record]} rs The Record(s) to create|update|destroy. - * @param {Object} params The request params object. Edit params to add parameters to the request. - */ - 'beforewrite', - /** - * @event write - * Fires before the request-callback is called - * In addition to being fired through the DataProxy instance that raised the event, this event is also fired - * through the Ext.data.DataProxy class to allow for centralized processing of write events from all - * DataProxies by attaching a listener to the Ext.data.Proxy class itself. - * @param {DataProxy} this The proxy that sent the request - * @param {String} action [Ext.data.Api.actions.create|upate|destroy] - * @param {Object} data The data object extracted from the server-response - * @param {Object} response The decoded response from server - * @param {Record/Record{}} rs The records from Store - * @param {Object} options The callback's options property as passed to the {@link #request} function - */ - 'write' - ); - Ext.data.DataProxy.superclass.constructor.call(this); - - // Prepare the proxy api. Ensures all API-actions are defined with the Object-form. - try { - Ext.data.Api.prepare(this); - } catch (e) { - if (e instanceof Ext.data.Api.Error) { - e.toConsole(); - } - } - // relay each proxy's events onto Ext.data.DataProxy class for centralized Proxy-listening - Ext.data.DataProxy.relayEvents(this, ['beforewrite', 'write', 'exception']); -}; - -Ext.extend(Ext.data.DataProxy, Ext.util.Observable, { - /** - * @cfg {Boolean} restful - * Defaults to false. Set to true to operate in a RESTful manner. - * Note: this parameter will automatically be set to true if the - * {@link Ext.data.Store} it is plugged into is set to restful: true. If the - * Store is RESTful, there is no need to set this option on the proxy. - * RESTful implementations enable the serverside framework to automatically route - * actions sent to one url based upon the HTTP method, for example: - * -store: new Ext.data.Store({ - restful: true, - proxy: new Ext.data.HttpProxy({url:'/users'}); // all requests sent to /users - ... -)} - * - * If there is no {@link #api} specified in the configuration of the proxy, - * all requests will be marshalled to a single RESTful url (/users) so the serverside - * framework can inspect the HTTP Method and act accordingly: - * -Method url action -POST /users create -GET /users read -PUT /users/23 update -DESTROY /users/23 delete - * - * If set to true, a {@link Ext.data.Record#phantom non-phantom} record's - * {@link Ext.data.Record#id id} will be appended to the url. Some MVC (e.g., Ruby on Rails, - * Merb and Django) support segment based urls where the segments in the URL follow the - * Model-View-Controller approach: - * someSite.com/controller/action/id - * - * Where the segments in the url are typically: - * The first segment : represents the controller class that should be invoked. - * The second segment : represents the class function, or method, that should be called. - * The third segment : represents the ID (a variable typically passed to the method). - * - * Refer to {@link Ext.data.DataProxy#api} for additional information. - */ - restful: false, - - /** - * Redefines the Proxy's API or a single action of an API. Can be called with two method signatures. - * If called with an object as the only parameter, the object should redefine the entire API, e.g.: -proxy.setApi({ - read : '/users/read', - create : '/users/create', - update : '/users/update', - destroy : '/users/destroy' -}); - - * If called with two parameters, the first parameter should be a string specifying the API action to - * redefine and the second parameter should be the URL (or function if using DirectProxy) to call for that action, e.g.: -proxy.setApi(Ext.data.Api.actions.read, '/users/new_load_url'); - - * @param {String/Object} api An API specification object, or the name of an action. - * @param {String/Function} url The URL (or function if using DirectProxy) to call for the action. - */ - setApi : function() { - if (arguments.length == 1) { - var valid = Ext.data.Api.isValid(arguments[0]); - if (valid === true) { - this.api = arguments[0]; - } - else { - throw new Ext.data.Api.Error('invalid', valid); - } - } - else if (arguments.length == 2) { - if (!Ext.data.Api.isAction(arguments[0])) { - throw new Ext.data.Api.Error('invalid', arguments[0]); - } - this.api[arguments[0]] = arguments[1]; - } - Ext.data.Api.prepare(this); - }, - - /** - * Returns true if the specified action is defined as a unique action in the api-config. - * request. If all API-actions are routed to unique urls, the xaction parameter is unecessary. However, if no api is defined - * and all Proxy actions are routed to DataProxy#url, the server-side will require the xaction parameter to perform a switch to - * the corresponding code for CRUD action. - * @param {String [Ext.data.Api.CREATE|READ|UPDATE|DESTROY]} action - * @return {Boolean} - */ - isApiAction : function(action) { - return (this.api[action]) ? true : false; - }, - - /** - * All proxy actions are executed through this method. Automatically fires the "before" + action event - * @param {String} action Name of the action - * @param {Ext.data.Record/Ext.data.Record[]/null} rs Will be null when action is 'load' - * @param {Object} params - * @param {Ext.data.DataReader} reader - * @param {Function} callback - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the Proxy object. - * @param {Object} options Any options specified for the action (e.g. see {@link Ext.data.Store#load}. - */ - request : function(action, rs, params, reader, callback, scope, options) { - if (!this.api[action] && !this.load) { - throw new Ext.data.DataProxy.Error('action-undefined', action); - } - params = params || {}; - if ((action === Ext.data.Api.actions.read) ? this.fireEvent("beforeload", this, params) : this.fireEvent("beforewrite", this, action, rs, params) !== false) { - this.doRequest.apply(this, arguments); - } - else { - callback.call(scope || this, null, options, false); - } - }, - - - /** - * Deprecated load method using old method signature. See {@doRequest} for preferred method. - * @deprecated - * @param {Object} params - * @param {Object} reader - * @param {Object} callback - * @param {Object} scope - * @param {Object} arg - */ - load : null, - - /** - * @cfg {Function} doRequest Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers. - * (e.g.: {@link Ext.data.HttpProxy#doRequest HttpProxy.doRequest}, - * {@link Ext.data.DirectProxy#doRequest DirectProxy.doRequest}). - */ - doRequest : function(action, rs, params, reader, callback, scope, options) { - // default implementation of doRequest for backwards compatibility with 2.0 proxies. - // If we're executing here, the action is probably "load". - // Call with the pre-3.0 method signature. - this.load(params, reader, callback, scope, options); - }, - - /** - * @cfg {Function} onRead Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers. Callback for read {@link Ext.data.Api#actions action}. - * @param {String} action Action name as per {@link Ext.data.Api.actions#read}. - * @param {Object} o The request transaction object - * @param {Object} res The server response - * @fires loadexception (deprecated) - * @fires exception - * @fires load - * @protected - */ - onRead : Ext.emptyFn, - /** - * @cfg {Function} onWrite Abstract method that should be implemented in all subclasses. Note: Should only be used by custom-proxy developers. Callback for create, update and destroy {@link Ext.data.Api#actions actions}. - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} trans The request transaction object - * @param {Object} res The server response - * @fires exception - * @fires write - * @protected - */ - onWrite : Ext.emptyFn, - /** - * buildUrl - * Sets the appropriate url based upon the action being executed. If restful is true, and only a single record is being acted upon, - * url will be built Rails-style, as in "/controller/action/32". restful will aply iff the supplied record is an - * instance of Ext.data.Record rather than an Array of them. - * @param {String} action The api action being executed [read|create|update|destroy] - * @param {Ext.data.Record/Array[Ext.data.Record]} The record or Array of Records being acted upon. - * @return {String} url - * @private - */ - buildUrl : function(action, record) { - record = record || null; - - // conn.url gets nullified after each request. If it's NOT null here, that means the user must have intervened with a call - // to DataProxy#setUrl or DataProxy#setApi and changed it before the request was executed. If that's the case, use conn.url, - // otherwise, build the url from the api or this.url. - var url = (this.conn && this.conn.url) ? this.conn.url : (this.api[action]) ? this.api[action].url : this.url; - if (!url) { - throw new Ext.data.Api.Error('invalid-url', action); - } - - // look for urls having "provides" suffix used in some MVC frameworks like Rails/Merb and others. The provides suffice informs - // the server what data-format the client is dealing with and returns data in the same format (eg: application/json, application/xml, etc) - // e.g.: /users.json, /users.xml, etc. - // with restful routes, we need urls like: - // PUT /users/1.json - // DELETE /users/1.json - var provides = null; - var m = url.match(/(.*)(\.json|\.xml|\.html)$/); - if (m) { - provides = m[2]; // eg ".json" - url = m[1]; // eg: "/users" - } - // prettyUrls is deprectated in favor of restful-config - if ((this.restful === true || this.prettyUrls === true) && record instanceof Ext.data.Record && !record.phantom) { - url += '/' + record.id; - } - return (provides === null) ? url : url + provides; - }, - - /** - * Destroys the proxy by purging any event listeners and cancelling any active requests. - */ - destroy: function(){ - this.purgeListeners(); - } -}); - -// Apply the Observable prototype to the DataProxy class so that proxy instances can relay their -// events to the class. Allows for centralized listening of all proxy instances upon the DataProxy class. -Ext.apply(Ext.data.DataProxy, Ext.util.Observable.prototype); -Ext.util.Observable.call(Ext.data.DataProxy); - -/** - * @class Ext.data.DataProxy.Error - * @extends Ext.Error - * DataProxy Error extension. - * constructor - * @param {String} name - * @param {Record/Array[Record]/Array} - */ -Ext.data.DataProxy.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); - }, - name: 'Ext.data.DataProxy' -}); -Ext.apply(Ext.data.DataProxy.Error.prototype, { - lang: { - 'action-undefined': "DataProxy attempted to execute an API-action but found an undefined url / function. Please review your Proxy url/api-configuration.", - 'api-invalid': 'Recieved an invalid API-configuration. Please ensure your proxy API-configuration contains only the actions from Ext.data.Api.actions.' - } -}); - - -/** - * @class Ext.data.Request - * A simple Request class used internally to the data package to provide more generalized remote-requests - * to a DataProxy. - * TODO Not yet implemented. Implement in Ext.data.Store#execute - */ -Ext.data.Request = function(params) { - Ext.apply(this, params); -}; -Ext.data.Request.prototype = { /** - * @cfg {String} action + * @cfg {Boolean/Number} bufferResize + * @hide */ - action : undefined, /** - * @cfg {Ext.data.Record[]/Ext.data.Record} rs The Store recordset associated with the request. + * @cfg {String} defaultType + * @hide */ - rs : undefined, /** - * @cfg {Object} params HTTP request params + * @cfg {Object} defaults + * @hide */ - params: undefined, /** - * @cfg {Function} callback The function to call when request is complete + * @cfg {Boolean} hideBorders + * @hide */ - callback : Ext.emptyFn, /** - * @cfg {Object} scope The scope of the callback funtion + * @cfg {Mixed} items + * @hide */ - scope : undefined, /** - * @cfg {Ext.data.DataReader} reader The DataReader instance which will parse the received response + * @cfg {String} layout + * @hide */ - reader : undefined -}; -/** - * @class Ext.data.Response - * A generic response class to normalize response-handling internally to the framework. - */ -Ext.data.Response = function(params) { - Ext.apply(this, params); -}; -Ext.data.Response.prototype = { /** - * @cfg {String} action {@link Ext.data.Api#actions} + * @cfg {Object} layoutConfig + * @hide */ - action: undefined, /** - * @cfg {Boolean} success + * @cfg {Boolean} monitorResize + * @hide */ - success : undefined, /** - * @cfg {String} message + * @property items + * @hide */ - message : undefined, /** - * @cfg {Array/Object} data + * @method cascade + * @hide */ - data: undefined, /** - * @cfg {Object} raw The raw response returned from server-code + * @method doLayout + * @hide */ - raw: undefined, /** - * @cfg {Ext.data.Record/Ext.data.Record[]} records related to the Request action + * @method find + * @hide */ - records: undefined -}; -/** - * @class Ext.data.ScriptTagProxy - * @extends Ext.data.DataProxy - * An implementation of Ext.data.DataProxy that reads a data object from a URL which may be in a domain - * other than the originating domain of the running page. - * - * Note that if you are retrieving data from a page that is in a domain that is NOT the same as the originating domain - * of the running page, you must use this class, rather than HttpProxy. - * - * The content passed back from a server resource requested by a ScriptTagProxy must be executable JavaScript - * source code because it is used as the source inside a <script> tag. - * - * In order for the browser to process the returned data, the server must wrap the data object - * with a call to a callback function, the name of which is passed as a parameter by the ScriptTagProxy. - * Below is a Java example for a servlet which returns data for either a ScriptTagProxy, or an HttpProxy - * depending on whether the callback name was passed: - * - * -boolean scriptTag = false; -String cb = request.getParameter("callback"); -if (cb != null) { - scriptTag = true; - response.setContentType("text/javascript"); -} else { - response.setContentType("application/x-json"); -} -Writer out = response.getWriter(); -if (scriptTag) { - out.write(cb + "("); -} -out.print(dataBlock.toJsonString()); -if (scriptTag) { - out.write(");"); -} - - * Below is a PHP example to do the same thing: -$callback = $_REQUEST['callback']; - -// Create the output object. -$output = array('a' => 'Apple', 'b' => 'Banana'); - -//start output -if ($callback) { - header('Content-Type: text/javascript'); - echo $callback . '(' . json_encode($output) . ');'; -} else { - header('Content-Type: application/x-json'); - echo json_encode($output); -} - - * Below is the ASP.Net code to do the same thing: -String jsonString = "{success: true}"; -String cb = Request.Params.Get("callback"); -String responseString = ""; -if (!String.IsNullOrEmpty(cb)) { - responseString = cb + "(" + jsonString + ")"; -} else { - responseString = jsonString; -} -Response.Write(responseString); - - * - * @constructor - * @param {Object} config A configuration object. - */ -Ext.data.ScriptTagProxy = function(config){ - Ext.apply(this, config); - - Ext.data.ScriptTagProxy.superclass.constructor.call(this, config); - - this.head = document.getElementsByTagName("head")[0]; - - /** - * @event loadexception - * Deprecated in favor of 'exception' event. - * Fires if an exception occurs in the Proxy during data loading. This event can be fired for one of two reasons: - * The load call timed out. This means the load callback did not execute within the time limit - * specified by {@link #timeout}. In this case, this event will be raised and the - * fourth parameter (read error) will be null. - * The load succeeded but the reader could not read the response. This means the server returned - * data, but the configured Reader threw an error while reading the data. In this case, this event will be - * raised and the caught error will be passed along as the fourth parameter of this event. - * Note that this event is also relayed through {@link Ext.data.Store}, so you can listen for it directly - * on any Store instance. - * @param {Object} this - * @param {Object} options The loading options that were specified (see {@link #load} for details). If the load - * call timed out, this parameter will be null. - * @param {Object} arg The callback's arg object passed to the {@link #load} function - * @param {Error} e The JavaScript Error object caught if the configured Reader could not read the data. - * If the remote request returns success: false, this parameter will be null. - */ -}; - -Ext.data.ScriptTagProxy.TRANS_ID = 1000; - -Ext.extend(Ext.data.ScriptTagProxy, Ext.data.DataProxy, { - /** - * @cfg {String} url The URL from which to request the data object. - */ - /** - * @cfg {Number} timeout (optional) The number of milliseconds to wait for a response. Defaults to 30 seconds. - */ - timeout : 30000, - /** - * @cfg {String} callbackParam (Optional) The name of the parameter to pass to the server which tells - * the server the name of the callback function set up by the load call to process the returned data object. - * Defaults to "callback".The server-side processing must read this parameter value, and generate - * javascript output which calls this named function passing the data object as its only parameter. - */ - callbackParam : "callback", - /** - * @cfg {Boolean} nocache (optional) Defaults to true. Disable caching by adding a unique parameter - * name to the request. - */ - nocache : true, - - /** - * HttpProxy implementation of DataProxy#doRequest - * @param {String} action - * @param {Ext.data.Record/Ext.data.Record[]} rs If action is read, rs will be null - * @param {Object} params An object containing properties which are to be used as HTTP parameters - * for the request to the remote server. - * @param {Ext.data.DataReader} reader The Reader object which converts the data - * object into a block of Ext.data.Records. - * @param {Function} callback The function into which to pass the block of Ext.data.Records. - * The function must be passed - * The Record block object - * The "arg" argument from the load function - * A boolean success indicator - * - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window. - * @param {Object} arg An optional argument which is passed to the callback as its second parameter. - */ - doRequest : function(action, rs, params, reader, callback, scope, arg) { - var p = Ext.urlEncode(Ext.apply(params, this.extraParams)); - - var url = this.buildUrl(action, rs); - if (!url) { - throw new Ext.data.Api.Error('invalid-url', url); - } - url = Ext.urlAppend(url, p); - - if(this.nocache){ - url = Ext.urlAppend(url, '_dc=' + (new Date().getTime())); - } - var transId = ++Ext.data.ScriptTagProxy.TRANS_ID; - var trans = { - id : transId, - action: action, - cb : "stcCallback"+transId, - scriptId : "stcScript"+transId, - params : params, - arg : arg, - url : url, - callback : callback, - scope : scope, - reader : reader - }; - window[trans.cb] = this.createCallback(action, rs, trans); - url += String.format("&{0}={1}", this.callbackParam, trans.cb); - if(this.autoAbort !== false){ - this.abort(); - } - - trans.timeoutId = this.handleFailure.defer(this.timeout, this, [trans]); - - var script = document.createElement("script"); - script.setAttribute("src", url); - script.setAttribute("type", "text/javascript"); - script.setAttribute("id", trans.scriptId); - this.head.appendChild(script); - - this.trans = trans; - }, - - // @private createCallback - createCallback : function(action, rs, trans) { - var self = this; - return function(res) { - self.trans = false; - self.destroyTrans(trans, true); - if (action === Ext.data.Api.actions.read) { - self.onRead.call(self, action, trans, res); - } else { - self.onWrite.call(self, action, trans, res, rs); - } - }; - }, - /** - * Callback for read actions - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} trans The request transaction object - * @param {Object} res The server response - * @protected - */ - onRead : function(action, trans, res) { - var result; - try { - result = trans.reader.readRecords(res); - }catch(e){ - // @deprecated: fire loadexception - this.fireEvent("loadexception", this, trans, res, e); - - this.fireEvent('exception', this, 'response', action, trans, res, e); - trans.callback.call(trans.scope||window, null, trans.arg, false); - return; - } - if (result.success === false) { - // @deprecated: fire old loadexception for backwards-compat. - this.fireEvent('loadexception', this, trans, res); - - this.fireEvent('exception', this, 'remote', action, trans, res, null); - } else { - this.fireEvent("load", this, res, trans.arg); - } - trans.callback.call(trans.scope||window, result, trans.arg, result.success); - }, - /** - * Callback for write actions - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} trans The request transaction object - * @param {Object} res The server response - * @protected - */ - onWrite : function(action, trans, response, rs) { - var reader = trans.reader; - try { - // though we already have a response object here in STP, run through readResponse to catch any meta-data exceptions. - var res = reader.readResponse(action, response); - } catch (e) { - this.fireEvent('exception', this, 'response', action, trans, res, e); - trans.callback.call(trans.scope||window, null, res, false); - return; - } - if(!res.success === true){ - this.fireEvent('exception', this, 'remote', action, trans, res, rs); - trans.callback.call(trans.scope||window, null, res, false); - return; - } - this.fireEvent("write", this, action, res.data, res, rs, trans.arg ); - trans.callback.call(trans.scope||window, res.data, res, true); - }, - - // private - isLoading : function(){ - return this.trans ? true : false; - }, - - /** - * Abort the current server request. - */ - abort : function(){ - if(this.isLoading()){ - this.destroyTrans(this.trans); - } - }, - - // private - destroyTrans : function(trans, isLoaded){ - this.head.removeChild(document.getElementById(trans.scriptId)); - clearTimeout(trans.timeoutId); - if(isLoaded){ - window[trans.cb] = undefined; - try{ - delete window[trans.cb]; - }catch(e){} - }else{ - // if hasn't been loaded, wait for load to remove it to prevent script error - window[trans.cb] = function(){ - window[trans.cb] = undefined; - try{ - delete window[trans.cb]; - }catch(e){} - }; - } - }, - - // private - handleFailure : function(trans){ - this.trans = false; - this.destroyTrans(trans, false); - if (trans.action === Ext.data.Api.actions.read) { - // @deprecated firing loadexception - this.fireEvent("loadexception", this, null, trans.arg); - } - - this.fireEvent('exception', this, 'response', trans.action, { - response: null, - options: trans.arg - }); - trans.callback.call(trans.scope||window, null, trans.arg, false); - }, - - // inherit docs - destroy: function(){ - this.abort(); - Ext.data.ScriptTagProxy.superclass.destroy.call(this); - } -});/** - * @class Ext.data.HttpProxy - * @extends Ext.data.DataProxy - * An implementation of {@link Ext.data.DataProxy} that processes data requests within the same - * domain of the originating page. - * Note: this class cannot be used to retrieve data from a domain other - * than the domain from which the running page was served. For cross-domain requests, use a - * {@link Ext.data.ScriptTagProxy ScriptTagProxy}. - * Be aware that to enable the browser to parse an XML document, the server must set - * the Content-Type header in the HTTP response to "text/xml". - * @constructor - * @param {Object} conn - * An {@link Ext.data.Connection} object, or options parameter to {@link Ext.Ajax#request}. - * Note that if this HttpProxy is being used by a {@link Ext.data.Store Store}, then the - * Store's call to {@link #load} will override any specified callback and params - * options. In this case, use the Store's {@link Ext.data.Store#events events} to modify parameters, - * or react to loading events. The Store's {@link Ext.data.Store#baseParams baseParams} may also be - * used to pass parameters known at instantiation time. - * If an options parameter is passed, the singleton {@link Ext.Ajax} object will be used to make - * the request. - */ -Ext.data.HttpProxy = function(conn){ - Ext.data.HttpProxy.superclass.constructor.call(this, conn); - - /** - * The Connection object (Or options parameter to {@link Ext.Ajax#request}) which this HttpProxy - * uses to make requests to the server. Properties of this object may be changed dynamically to - * change the way data is requested. - * @property - */ - this.conn = conn; - - // nullify the connection url. The url param has been copied to 'this' above. The connection - // url will be set during each execution of doRequest when buildUrl is called. This makes it easier for users to override the - // connection url during beforeaction events (ie: beforeload, beforewrite, etc). - // Url is always re-defined during doRequest. - this.conn.url = null; - - this.useAjax = !conn || !conn.events; - - // A hash containing active requests, keyed on action [Ext.data.Api.actions.create|read|update|destroy] - var actions = Ext.data.Api.actions; - this.activeRequest = {}; - for (var verb in actions) { - this.activeRequest[actions[verb]] = undefined; - } -}; - -Ext.extend(Ext.data.HttpProxy, Ext.data.DataProxy, { - /** - * Return the {@link Ext.data.Connection} object being used by this Proxy. - * @return {Connection} The Connection object. This object may be used to subscribe to events on - * a finer-grained basis than the DataProxy events. - */ - getConnection : function() { - return this.useAjax ? Ext.Ajax : this.conn; - }, - - /** - * Used for overriding the url used for a single request. Designed to be called during a beforeaction event. Calling setUrl - * will override any urls set via the api configuration parameter. Set the optional parameter makePermanent to set the url for - * all subsequent requests. If not set to makePermanent, the next request will use the same url or api configuration defined - * in the initial proxy configuration. - * @param {String} url - * @param {Boolean} makePermanent (Optional) [false] - * - * (e.g.: beforeload, beforesave, etc). - */ - setUrl : function(url, makePermanent) { - this.conn.url = url; - if (makePermanent === true) { - this.url = url; - this.api = null; - Ext.data.Api.prepare(this); - } - }, - - /** - * HttpProxy implementation of DataProxy#doRequest - * @param {String} action The crud action type (create, read, update, destroy) - * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null - * @param {Object} params An object containing properties which are to be used as HTTP parameters - * for the request to the remote server. - * @param {Ext.data.DataReader} reader The Reader object which converts the data - * object into a block of Ext.data.Records. - * @param {Function} callback - * A function to be called after the request. - * The callback is passed the following arguments: - * r : Ext.data.Record[] The block of Ext.data.Records. - * options: Options object from the action request - * success: Boolean success indicator - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window. - * @param {Object} arg An optional argument which is passed to the callback as its second parameter. - * @protected - */ - doRequest : function(action, rs, params, reader, cb, scope, arg) { - var o = { - method: (this.api[action]) ? this.api[action]['method'] : undefined, - request: { - callback : cb, - scope : scope, - arg : arg - }, - reader: reader, - callback : this.createCallback(action, rs), - scope: this - }; - - // If possible, transmit data using jsonData || xmlData on Ext.Ajax.request (An installed DataWriter would have written it there.). - // Use std HTTP params otherwise. - if (params.jsonData) { - o.jsonData = params.jsonData; - } else if (params.xmlData) { - o.xmlData = params.xmlData; - } else { - o.params = params || {}; - } - // Set the connection url. If this.conn.url is not null here, - // the user must have overridden the url during a beforewrite/beforeload event-handler. - // this.conn.url is nullified after each request. - this.conn.url = this.buildUrl(action, rs); - - if(this.useAjax){ - - Ext.applyIf(o, this.conn); - - // If a currently running request is found for this action, abort it. - if (this.activeRequest[action]) { - //// - // Disabled aborting activeRequest while implementing REST. activeRequest[action] will have to become an array - // TODO ideas anyone? - // - //Ext.Ajax.abort(this.activeRequest[action]); - } - this.activeRequest[action] = Ext.Ajax.request(o); - }else{ - this.conn.request(o); - } - // request is sent, nullify the connection url in preparation for the next request - this.conn.url = null; - }, - - /** - * Returns a callback function for a request. Note a special case is made for the - * read action vs all the others. - * @param {String} action [create|update|delete|load] - * @param {Ext.data.Record[]} rs The Store-recordset being acted upon - * @private - */ - createCallback : function(action, rs) { - return function(o, success, response) { - this.activeRequest[action] = undefined; - if (!success) { - if (action === Ext.data.Api.actions.read) { - // @deprecated: fire loadexception for backwards compat. - // TODO remove in 3.1 - this.fireEvent('loadexception', this, o, response); - } - this.fireEvent('exception', this, 'response', action, o, response); - o.request.callback.call(o.request.scope, null, o.request.arg, false); - return; - } - if (action === Ext.data.Api.actions.read) { - this.onRead(action, o, response); - } else { - this.onWrite(action, o, response, rs); - } - }; - }, - - /** - * Callback for read action - * @param {String} action Action name as per {@link Ext.data.Api.actions#read}. - * @param {Object} o The request transaction object - * @param {Object} res The server response - * @fires loadexception (deprecated) - * @fires exception - * @fires load - * @protected - */ - onRead : function(action, o, response) { - var result; - try { - result = o.reader.read(response); - }catch(e){ - // @deprecated: fire old loadexception for backwards-compat. - // TODO remove in 3.1 - this.fireEvent('loadexception', this, o, response, e); - - this.fireEvent('exception', this, 'response', action, o, response, e); - o.request.callback.call(o.request.scope, null, o.request.arg, false); - return; - } - if (result.success === false) { - // @deprecated: fire old loadexception for backwards-compat. - // TODO remove in 3.1 - this.fireEvent('loadexception', this, o, response); - - // Get DataReader read-back a response-object to pass along to exception event - var res = o.reader.readResponse(action, response); - this.fireEvent('exception', this, 'remote', action, o, res, null); - } - else { - this.fireEvent('load', this, o, o.request.arg); - } - // TODO refactor onRead, onWrite to be more generalized now that we're dealing with Ext.data.Response instance - // the calls to request.callback(...) in each will have to be made identical. - // NOTE reader.readResponse does not currently return Ext.data.Response - o.request.callback.call(o.request.scope, result, o.request.arg, result.success); - }, - /** - * Callback for write actions - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} trans The request transaction object - * @param {Object} res The server response - * @fires exception - * @fires write - * @protected - */ - onWrite : function(action, o, response, rs) { - var reader = o.reader; - var res; - try { - res = reader.readResponse(action, response); - } catch (e) { - this.fireEvent('exception', this, 'response', action, o, response, e); - o.request.callback.call(o.request.scope, null, o.request.arg, false); - return; - } - if (res.success === true) { - this.fireEvent('write', this, action, res.data, res, rs, o.request.arg); - } else { - this.fireEvent('exception', this, 'remote', action, o, res, rs); - } - // TODO refactor onRead, onWrite to be more generalized now that we're dealing with Ext.data.Response instance - // the calls to request.callback(...) in each will have to be made similar. - // NOTE reader.readResponse does not currently return Ext.data.Response - o.request.callback.call(o.request.scope, res.data, res, res.success); - }, - - // inherit docs - destroy: function(){ - if(!this.useAjax){ - this.conn.abort(); - }else if(this.activeRequest){ - var actions = Ext.data.Api.actions; - for (var verb in actions) { - if(this.activeRequest[actions[verb]]){ - Ext.Ajax.abort(this.activeRequest[actions[verb]]); - } - } - } - Ext.data.HttpProxy.superclass.destroy.call(this); - } -});/** - * @class Ext.data.MemoryProxy - * @extends Ext.data.DataProxy - * An implementation of Ext.data.DataProxy that simply passes the data specified in its constructor - * to the Reader when its load method is called. - * @constructor - * @param {Object} data The data object which the Reader uses to construct a block of Ext.data.Records. - */ -Ext.data.MemoryProxy = function(data){ - // Must define a dummy api with "read" action to satisfy DataProxy#doRequest and Ext.data.Api#prepare *before* calling super - var api = {}; - api[Ext.data.Api.actions.read] = true; - Ext.data.MemoryProxy.superclass.constructor.call(this, { - api: api - }); - this.data = data; -}; - -Ext.extend(Ext.data.MemoryProxy, Ext.data.DataProxy, { - /** - * @event loadexception - * Fires if an exception occurs in the Proxy during data loading. Note that this event is also relayed - * through {@link Ext.data.Store}, so you can listen for it directly on any Store instance. - * @param {Object} this - * @param {Object} arg The callback's arg object passed to the {@link #load} function - * @param {Object} null This parameter does not apply and will always be null for MemoryProxy - * @param {Error} e The JavaScript Error object caught if the configured Reader could not read the data - */ - - /** - * MemoryProxy implementation of DataProxy#doRequest - * @param {String} action - * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null - * @param {Object} params An object containing properties which are to be used as HTTP parameters - * for the request to the remote server. - * @param {Ext.data.DataReader} reader The Reader object which converts the data - * object into a block of Ext.data.Records. - * @param {Function} callback The function into which to pass the block of Ext.data.Records. - * The function must be passed - * The Record block object - * The "arg" argument from the load function - * A boolean success indicator - * - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window. - * @param {Object} arg An optional argument which is passed to the callback as its second parameter. - */ - doRequest : function(action, rs, params, reader, callback, scope, arg) { - // No implementation for CRUD in MemoryProxy. Assumes all actions are 'load' - params = params || {}; - var result; - try { - result = reader.readRecords(this.data); - }catch(e){ - // @deprecated loadexception - this.fireEvent("loadexception", this, null, arg, e); - - this.fireEvent('exception', this, 'response', action, arg, null, e); - callback.call(scope, null, arg, false); - return; - } - callback.call(scope, result, arg, true); - } -});/** - * @class Ext.data.JsonWriter - * @extends Ext.data.DataWriter - * DataWriter extension for writing an array or single {@link Ext.data.Record} object(s) in preparation for executing a remote CRUD action. - */ -Ext.data.JsonWriter = Ext.extend(Ext.data.DataWriter, { /** - * @cfg {Boolean} encode true to {@link Ext.util.JSON#encode encode} the - * {@link Ext.data.DataWriter#toHash hashed data}. Defaults to true. When using - * {@link Ext.data.DirectProxy}, set this to false since Ext.Direct.JsonProvider will perform - * its own json-encoding. In addition, if you're using {@link Ext.data.HttpProxy}, setting to false - * will cause HttpProxy to transmit data using the jsonData configuration-params of {@link Ext.Ajax#request} - * instead of params. When using a {@link Ext.data.Store#restful} Store, some serverside frameworks are - * tuned to expect data through the jsonData mechanism. In those cases, one will want to set encode: false, as in - * let the lower-level connection object (eg: Ext.Ajax) do the encoding. + * @method findBy + * @hide */ - encode : true, /** - * @cfg {Boolean} encodeDelete False to send only the id to the server on delete, true to encode it in an object - * literal, eg: -{id: 1} - * Defaults to false + * @method findById + * @hide */ - encodeDelete: false, - - constructor : function(config){ - Ext.data.JsonWriter.superclass.constructor.call(this, config); - }, - /** - * Final action of a write event. Apply the written data-object to params. - * @param {Object} http params-object to write-to. - * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}. The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}. - * @param {Object/Object[]} data Data-object representing compiled Store-recordset. + * @method findByType + * @hide */ - render : function(params, baseParams, data) { - if (this.encode === true) { - // Encode here now. - Ext.apply(params, baseParams); - params[this.meta.root] = Ext.encode(data); - } else { - // defer encoding for some other layer, probably in {@link Ext.Ajax#request}. Place everything into "jsonData" key. - var jdata = Ext.apply({}, baseParams); - jdata[this.meta.root] = data; - params.jsonData = jdata; - } - }, /** - * Implements abstract Ext.data.DataWriter#createRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Object} + * @method getComponent + * @hide */ - createRecord : function(rec) { - return this.toHash(rec); - }, /** - * Implements abstract Ext.data.DataWriter#updateRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Object} + * @method getLayout + * @hide */ - updateRecord : function(rec) { - return this.toHash(rec); - - }, /** - * Implements abstract Ext.data.DataWriter#destroyRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Object} + * @method getUpdater + * @hide */ - destroyRecord : function(rec){ - if(this.encodeDelete){ - var data = {}; - data[this.meta.idProperty] = rec.id; - return data; - }else{ - return rec.id; - } - } -});/** - * @class Ext.data.JsonReader - * @extends Ext.data.DataReader - * Data reader class to create an Array of {@link Ext.data.Record} objects - * from a JSON packet based on mappings in a provided {@link Ext.data.Record} - * constructor. - * Example code: - * -var myReader = new Ext.data.JsonReader({ - // metadata configuration options: - {@link #idProperty}: 'id' - {@link #root}: 'rows', - {@link #totalProperty}: 'results', - {@link Ext.data.DataReader#messageProperty}: "msg" // The element within the response that provides a user-feedback message (optional) - - // the fields config option will internally create an {@link Ext.data.Record} - // constructor that provides mapping for reading the record data objects - {@link Ext.data.DataReader#fields fields}: [ - // map Record's 'firstname' field to data object's key of same name - {name: 'name'}, - // map Record's 'job' field to data object's 'occupation' key - {name: 'job', mapping: 'occupation'} - ] -}); - - * This would consume a JSON data object of the form: -{ - results: 2000, // Reader's configured {@link #totalProperty} - rows: [ // Reader's configured {@link #root} - // record data objects: - { {@link #idProperty id}: 1, firstname: 'Bill', occupation: 'Gardener' }, - { {@link #idProperty id}: 2, firstname: 'Ben' , occupation: 'Horticulturalist' }, - ... - ] -} - - * Automatic configuration using metaData - * It is possible to change a JsonReader's metadata at any time by including - * a metaData property in the JSON data object. If the JSON data - * object has a metaData property, a {@link Ext.data.Store Store} - * object using this Reader will reconfigure itself to use the newly provided - * field definition and fire its {@link Ext.data.Store#metachange metachange} - * event. The metachange event handler may interrogate the metaData - * property to perform any configuration required. - * Note that reconfiguring a Store potentially invalidates objects which may - * refer to Fields or Records which no longer exist. - * To use this facility you would create the JsonReader like this: -var myReader = new Ext.data.JsonReader(); - - * The first data packet from the server would configure the reader by - * containing a metaData property and the data. For - * example, the JSON data object might take the form: -{ - metaData: { - "{@link #idProperty}": "id", - "{@link #root}": "rows", - "{@link #totalProperty}": "results" - "{@link #successProperty}": "success", - "{@link Ext.data.DataReader#fields fields}": [ - {"name": "name"}, - {"name": "job", "mapping": "occupation"} - ], - // used by store to set its sortInfo - "sortInfo":{ - "field": "name", - "direction": "ASC" - }, - // {@link Ext.PagingToolbar paging data} (if applicable) - "start": 0, - "limit": 2, - // custom property - "foo": "bar" - }, - // Reader's configured {@link #successProperty} - "success": true, - // Reader's configured {@link #totalProperty} - "results": 2000, - // Reader's configured {@link #root} - // (this data simulates 2 results {@link Ext.PagingToolbar per page}) - "rows": [ // *Note: this must be an Array - { "id": 1, "name": "Bill", "occupation": "Gardener" }, - { "id": 2, "name": "Ben", "occupation": "Horticulturalist" } - ] -} - * - * The metaData property in the JSON data object should contain: - * - * any of the configuration options for this class - * a {@link Ext.data.Record#fields fields} property which - * the JsonReader will use as an argument to the - * {@link Ext.data.Record#create data Record create method} in order to - * configure the layout of the Records it will produce. - * a {@link Ext.data.Store#sortInfo sortInfo} property - * which the JsonReader will use to set the {@link Ext.data.Store}'s - * {@link Ext.data.Store#sortInfo sortInfo} property - * any custom properties needed - * - * - * @constructor - * Create a new JsonReader - * @param {Object} meta Metadata configuration options. - * @param {Array/Object} recordType - * Either an Array of {@link Ext.data.Field Field} definition objects (which - * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record} - * constructor created from {@link Ext.data.Record#create}. - */ -Ext.data.JsonReader = function(meta, recordType){ - meta = meta || {}; /** - * @cfg {String} idProperty [id] Name of the property within a row object - * that contains a record identifier value. Defaults to id + * @method insert + * @hide */ /** - * @cfg {String} successProperty [success] Name of the property from which to - * retrieve the success attribute. Defaults to success. See - * {@link Ext.data.DataProxy}.{@link Ext.data.DataProxy#exception exception} - * for additional information. + * @method load + * @hide */ /** - * @cfg {String} totalProperty [total] Name of the property from which to - * retrieve the total number of records in the dataset. This is only needed - * if the whole dataset is not passed in one go, but is being paged from - * the remote server. Defaults to total. + * @method remove + * @hide */ /** - * @cfg {String} root [undefined] Required. The name of the property - * which contains the Array of row objects. Defaults to undefined. - * An exception will be thrown if the root property is undefined. The data - * packet value for this property should be an empty array to clear the data - * or show no data. + * @event add + * @hide */ - Ext.applyIf(meta, { - idProperty: 'id', - successProperty: 'success', - totalProperty: 'total' - }); - - Ext.data.JsonReader.superclass.constructor.call(this, meta, recordType || meta.fields); -}; -Ext.extend(Ext.data.JsonReader, Ext.data.DataReader, { /** - * This JsonReader's metadata as passed to the constructor, or as passed in - * the last data packet's metaData property. - * @type Mixed - * @property meta + * @method removeAll + * @hide */ /** - * This method is only used by a DataProxy which has retrieved data from a remote server. - * @param {Object} response The XHR object which contains the JSON data in its responseText. - * @return {Object} data A data block which is used by an Ext.data.Store object as - * a cache of Ext.data.Records. + * @event afterLayout + * @hide */ - read : function(response){ - var json = response.responseText; - var o = Ext.decode(json); - if(!o) { - throw {message: 'JsonReader.read: Json object not found'}; - } - return this.readRecords(o); - }, - /** - * Decode a json response from server. - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} response - * TODO: refactor code between JsonReader#readRecords, #readResponse into 1 method. - * there's ugly duplication going on due to maintaining backwards compat. with 2.0. It's time to do this. + * @event beforeadd + * @hide */ - readResponse : function(action, response) { - var o = (response.responseText !== undefined) ? Ext.decode(response.responseText) : response; - if(!o) { - throw new Ext.data.JsonReader.Error('response'); - } - - var root = this.getRoot(o); - if (action === Ext.data.Api.actions.create) { - var def = Ext.isDefined(root); - if (def && Ext.isEmpty(root)) { - throw new Ext.data.JsonReader.Error('root-empty', this.meta.root); - } - else if (!def) { - throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root); - } - } - - // instantiate response object - var res = new Ext.data.Response({ - action: action, - success: this.getSuccess(o), - data: (root) ? this.extractData(root, false) : [], - message: this.getMessage(o), - raw: o - }); - - // blow up if no successProperty - if (Ext.isEmpty(res.success)) { - throw new Ext.data.JsonReader.Error('successProperty-response', this.meta.successProperty); - } - return res; - }, - /** - * Create a data block containing Ext.data.Records from a JSON object. - * @param {Object} o An object which contains an Array of row objects in the property specified - * in the config as 'root, and optionally a property, specified in the config as 'totalProperty' - * which contains the total size of the dataset. - * @return {Object} data A data block which is used by an Ext.data.Store object as - * a cache of Ext.data.Records. + * @event beforeremove + * @hide + */ + /** + * @event remove + * @hide */ - readRecords : function(o){ - /** - * After any data loads, the raw JSON data is available for further custom processing. If no data is - * loaded or there is a load exception this property will be undefined. - * @type Object - */ - this.jsonData = o; - if(o.metaData){ - this.onMetaChange(o.metaData); - } - var s = this.meta, Record = this.recordType, - f = Record.prototype.fields, fi = f.items, fl = f.length, v; - - var root = this.getRoot(o), c = root.length, totalRecords = c, success = true; - if(s.totalProperty){ - v = parseInt(this.getTotal(o), 10); - if(!isNaN(v)){ - totalRecords = v; - } - } - if(s.successProperty){ - v = this.getSuccess(o); - if(v === false || v === 'false'){ - success = false; - } - } - - // TODO return Ext.data.Response instance instead. @see #readResponse - return { - success : success, - records : this.extractData(root, true), // <-- true to return [Ext.data.Record] - totalRecords : totalRecords - }; - }, - - // private - buildExtractors : function() { - if(this.ef){ - return; - } - var s = this.meta, Record = this.recordType, - f = Record.prototype.fields, fi = f.items, fl = f.length; - if(s.totalProperty) { - this.getTotal = this.createAccessor(s.totalProperty); - } - if(s.successProperty) { - this.getSuccess = this.createAccessor(s.successProperty); - } - if (s.messageProperty) { - this.getMessage = this.createAccessor(s.messageProperty); - } - this.getRoot = s.root ? this.createAccessor(s.root) : function(p){return p;}; - if (s.id || s.idProperty) { - var g = this.createAccessor(s.id || s.idProperty); - this.getId = function(rec) { - var r = g(rec); - return (r === undefined || r === '') ? null : r; - }; - } else { - this.getId = function(){return null;}; - } - var ef = []; - for(var i = 0; i < fl; i++){ - f = fi[i]; - var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name; - ef.push(this.createAccessor(map)); - } - this.ef = ef; - }, + /** - * @ignore - * TODO This isn't used anywhere?? Don't we want to use this where possible instead of complex #createAccessor? + * @cfg {String} allowDomMove @hide */ - simpleAccess : function(obj, subsc) { - return obj[subsc]; - }, - /** - * @ignore + * @cfg {String} autoEl @hide */ - createAccessor : function(){ - var re = /[\[\.]/; - return function(expr) { - if(Ext.isEmpty(expr)){ - return Ext.emptyFn; - } - if(Ext.isFunction(expr)){ - return expr; - } - var i = String(expr).search(re); - if(i >= 0){ - return new Function('obj', 'return obj' + (i > 0 ? '.' : '') + expr); - } - return function(obj){ - return obj[expr]; - }; - - }; - }(), - /** - * type-casts a single row of raw-data from server - * @param {Object} data - * @param {Array} items - * @param {Integer} len - * @private + * @cfg {String} applyTo @hide */ - extractValues : function(data, items, len) { - var f, values = {}; - for(var j = 0; j < len; j++){ - f = items[j]; - var v = this.ef[j](data); - values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data); - } - return values; - } -}); - -/** - * @class Ext.data.JsonReader.Error - * Error class for JsonReader - */ -Ext.data.JsonReader.Error = Ext.extend(Ext.Error, { - constructor : function(message, arg) { - this.arg = arg; - Ext.Error.call(this, message); - }, - name : 'Ext.data.JsonReader' -}); -Ext.apply(Ext.data.JsonReader.Error.prototype, { - lang: { - 'response': 'An error occurred while json-decoding your server response', - 'successProperty-response': 'Could not locate your "successProperty" in your server response. Please review your JsonReader config to ensure the config-property "successProperty" matches the property in your server-response. See the JsonReader docs.', - 'root-undefined-config': 'Your JsonReader was configured without a "root" property. Please review your JsonReader config and make sure to define the root property. See the JsonReader docs.', - 'idProperty-undefined' : 'Your JsonReader was configured without an "idProperty" Please review your JsonReader configuration and ensure the "idProperty" is set (e.g.: "id"). See the JsonReader docs.', - 'root-empty': 'Data was expected to be returned by the server in the "root" property of the response. Please review your JsonReader configuration to ensure the "root" property matches that returned in the server-response. See JsonReader docs.' - } -}); -/** - * @class Ext.data.ArrayReader - * @extends Ext.data.JsonReader - * Data reader class to create an Array of {@link Ext.data.Record} objects from an Array. - * Each element of that Array represents a row of data fields. The - * fields are pulled into a Record object using as a subscript, the mapping property - * of the field definition if it exists, or the field's ordinal position in the definition. - * Example code: - * -var Employee = Ext.data.Record.create([ - {name: 'name', mapping: 1}, // "mapping" only needed if an "id" field is present which - {name: 'occupation', mapping: 2} // precludes using the ordinal position as the index. -]); -var myReader = new Ext.data.ArrayReader({ - {@link #idIndex}: 0 -}, Employee); - - * This would consume an Array like this: - * -[ [1, 'Bill', 'Gardener'], [2, 'Ben', 'Horticulturalist'] ] - * - * @constructor - * Create a new ArrayReader - * @param {Object} meta Metadata configuration options. - * @param {Array/Object} recordType - * Either an Array of {@link Ext.data.Field Field} definition objects (which - * will be passed to {@link Ext.data.Record#create}, or a {@link Ext.data.Record Record} - * constructor created from {@link Ext.data.Record#create}. - */ -Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, { /** - * @cfg {String} successProperty - * @hide + * @cfg {String} contentEl @hide */ /** - * @cfg {Number} id (optional) The subscript within row Array that provides an ID for the Record. - * Deprecated. Use {@link #idIndex} instead. + * @cfg {Mixed} data @hide */ /** - * @cfg {Number} idIndex (optional) The subscript within row Array that provides an ID for the Record. + * @cfg {Mixed} tpl @hide */ /** - * Create a data block containing Ext.data.Records from an Array. - * @param {Object} o An Array of row objects which represents the dataset. - * @return {Object} data A data block which is used by an Ext.data.Store object as - * a cache of Ext.data.Records. + * @cfg {String} tplWriteMode @hide */ - readRecords : function(o){ - this.arrayData = o; - var s = this.meta, - sid = s ? Ext.num(s.idIndex, s.id) : null, - recordType = this.recordType, - fields = recordType.prototype.fields, - records = [], - success = true, - v; - - var root = this.getRoot(o); - - for(var i = 0, len = root.length; i < len; i++) { - var n = root[i], - values = {}, - id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null); - for(var j = 0, jlen = fields.length; j < jlen; j++) { - var f = fields.items[j], - k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j; - v = n[k] !== undefined ? n[k] : f.defaultValue; - v = f.convert(v, n); - values[f.name] = v; - } - var record = new recordType(values, id); - record.json = n; - records[records.length] = record; - } - - var totalRecords = records.length; - - if(s.totalProperty) { - v = parseInt(this.getTotal(o), 10); - if(!isNaN(v)) { - totalRecords = v; - } - } - if(s.successProperty){ - v = this.getSuccess(o); - if(v === false || v === 'false'){ - success = false; - } - } - - return { - success : success, - records : records, - totalRecords : totalRecords - }; - } -});/** - * @class Ext.data.ArrayStore - * @extends Ext.data.Store - * Formerly known as "SimpleStore". - * Small helper class to make creating {@link Ext.data.Store}s from Array data easier. - * An ArrayStore will be automatically configured with a {@link Ext.data.ArrayReader}. - * A store configuration would be something like: -var store = new Ext.data.ArrayStore({ - // store configs - autoDestroy: true, - storeId: 'myStore', - // reader configs - idIndex: 0, - fields: [ - 'company', - {name: 'price', type: 'float'}, - {name: 'change', type: 'float'}, - {name: 'pctChange', type: 'float'}, - {name: 'lastChange', type: 'date', dateFormat: 'n/j h:ia'} - ] -}); - * - * This store is configured to consume a returned object of the form: -var myData = [ - ['3m Co',71.72,0.02,0.03,'9/1 12:00am'], - ['Alcoa Inc',29.01,0.42,1.47,'9/1 12:00am'], - ['Boeing Co.',75.43,0.53,0.71,'9/1 12:00am'], - ['Hewlett-Packard Co.',36.53,-0.03,-0.08,'9/1 12:00am'], - ['Wal-Mart Stores, Inc.',45.45,0.73,1.63,'9/1 12:00am'] -]; - * - * An object literal of this form could also be used as the {@link #data} config option. - * *Note: Although not listed here, this class accepts all of the configuration options of - * {@link Ext.data.ArrayReader ArrayReader}. - * @constructor - * @param {Object} config - * @xtype arraystore - */ -Ext.data.ArrayStore = Ext.extend(Ext.data.Store, { /** - * @cfg {Ext.data.DataReader} reader @hide + * @cfg {String} disabledClass @hide */ - constructor: function(config){ - Ext.data.ArrayStore.superclass.constructor.call(this, Ext.apply(config, { - reader: new Ext.data.ArrayReader(config) - })); - }, - - loadData : function(data, append){ - if(this.expandData === true){ - var r = []; - for(var i = 0, len = data.length; i < len; i++){ - r[r.length] = [data[i]]; - } - data = r; - } - Ext.data.ArrayStore.superclass.loadData.call(this, data, append); - } -}); -Ext.reg('arraystore', Ext.data.ArrayStore); - -// backwards compat -Ext.data.SimpleStore = Ext.data.ArrayStore; -Ext.reg('simplestore', Ext.data.SimpleStore);/** - * @class Ext.data.JsonStore - * @extends Ext.data.Store - * Small helper class to make creating {@link Ext.data.Store}s from JSON data easier. - * A JsonStore will be automatically configured with a {@link Ext.data.JsonReader}. - * A store configuration would be something like: -var store = new Ext.data.JsonStore({ - // store configs - autoDestroy: true, - url: 'get-images.php', - storeId: 'myStore', - // reader configs - root: 'images', - idProperty: 'name', - fields: ['name', 'url', {name:'size', type: 'float'}, {name:'lastmod', type:'date'}] -}); - * - * This store is configured to consume a returned object of the form: -{ - images: [ - {name: 'Image one', url:'/GetImage.php?id=1', size:46.5, lastmod: new Date(2007, 10, 29)}, - {name: 'Image Two', url:'/GetImage.php?id=2', size:43.2, lastmod: new Date(2007, 10, 30)} - ] -} - * - * An object literal of this form could also be used as the {@link #data} config option. - * *Note: Although not listed here, this class accepts all of the configuration options of - * {@link Ext.data.JsonReader JsonReader}. - * @constructor - * @param {Object} config - * @xtype jsonstore - */ -Ext.data.JsonStore = Ext.extend(Ext.data.Store, { /** - * @cfg {Ext.data.DataReader} reader @hide + * @cfg {String} elements @hide */ - constructor: function(config){ - Ext.data.JsonStore.superclass.constructor.call(this, Ext.apply(config, { - reader: new Ext.data.JsonReader(config) - })); - } -}); -Ext.reg('jsonstore', Ext.data.JsonStore);/** - * @class Ext.data.XmlWriter - * @extends Ext.data.DataWriter - * DataWriter extension for writing an array or single {@link Ext.data.Record} object(s) in preparation for executing a remote CRUD action via XML. - * XmlWriter uses an instance of {@link Ext.XTemplate} for maximum flexibility in defining your own custom XML schema if the default schema is not appropriate for your needs. - * See the {@link #tpl} configuration-property. - */ -Ext.data.XmlWriter = function(params) { - Ext.data.XmlWriter.superclass.constructor.apply(this, arguments); - // compile the XTemplate for rendering XML documents. - this.tpl = (typeof(this.tpl) === 'string') ? new Ext.XTemplate(this.tpl).compile() : this.tpl.compile(); -}; -Ext.extend(Ext.data.XmlWriter, Ext.data.DataWriter, { /** - * @cfg {String} documentRoot [xrequest] (Optional) The name of the XML document root-node. Note: - * this parameter is required only when sending extra {@link Ext.data.Store#baseParams baseParams} to the server - * during a write-request -- if no baseParams are set, the {@link Ext.data.XmlReader#record} meta-property can - * suffice as the XML document root-node for write-actions involving just a single record. For requests - * involving multiple records and NO baseParams, the {@link Ext.data.XmlWriter#root} property can - * act as the XML document root. + * @cfg {String} html @hide */ - documentRoot: 'xrequest', /** - * @cfg {Boolean} forceDocumentRoot [false] Set to true to force XML documents having a root-node as defined - * by {@link #documentRoot}, even with no baseParams defined. + * @cfg {Boolean} preventBodyReset + * @hide */ - forceDocumentRoot: false, /** - * @cfg {String} root [records] The name of the containing element which will contain the nodes of an write-action involving multiple records. Each - * xml-record written to the server will be wrapped in an element named after {@link Ext.data.XmlReader#record} property. - * eg: --<?xml version="1.0" encoding="UTF-8"?> -<user><first>Barney</first></user> - - * However, when multiple records are written in a batch-operation, these records must be wrapped in a containing - * Element. - * eg: --<?xml version="1.0" encoding="UTF-8"?> - <records> - <first>Barney</first></user> - <records><first>Barney</first></user> - </records> - - * Defaults to records. Do not confuse the nature of this property with that of {@link #documentRoot} + * @property disabled + * @hide */ - root: 'records', /** - * @cfg {String} xmlVersion [1.0] The version written to header of xml documents. -<?xml version="1.0" encoding="ISO-8859-15"?> + * @method applyToMarkup + * @hide */ - xmlVersion : '1.0', /** - * @cfg {String} xmlEncoding [ISO-8859-15] The encoding written to header of xml documents. -<?xml version="1.0" encoding="ISO-8859-15"?> + * @method enable + * @hide */ - xmlEncoding: 'ISO-8859-15', /** - * @cfg {String/Ext.XTemplate} tpl The XML template used to render {@link Ext.data.Api#actions write-actions} to your server. - * One can easily provide his/her own custom {@link Ext.XTemplate#constructor template-definition} if the default does not suffice. - * Defaults to: --<?xml version="{version}" encoding="{encoding}"?> - <tpl if="documentRoot"><{documentRoot}> - <tpl for="baseParams"> - <tpl for="."> - <{name}>{value}</{name}> - </tpl> - </tpl> - <tpl if="records.length > 1"><{root}>', - <tpl for="records"> - <{parent.record}> - <tpl for="."> - <{name}>{value}</{name}> - </tpl> - </{parent.record}> - </tpl> - <tpl if="records.length > 1"></{root}></tpl> - <tpl if="documentRoot"></{documentRoot}></tpl> - - * Templates will be called with the following API - * - * {String} version [1.0] The xml version. - * {String} encoding [ISO-8859-15] The xml encoding. - * {String/false} documentRoot The XML document root-node name or false if not required. See {@link #documentRoot} and {@link #forceDocumentRoot}. - * {String} record The meta-data parameter defined on your {@link Ext.data.XmlReader#record} configuration represents the name of the xml-tag containing each record. - * {String} root The meta-data parameter defined by {@link Ext.data.XmlWriter#root} configuration-parameter. Represents the name of the xml root-tag when sending multiple records to the server. - * {Array} records The records being sent to the server, ie: the subject of the write-action being performed. The records parameter will be always be an array, even when only a single record is being acted upon. - * Each item within the records array will contain an array of field objects having the following properties: - * - * {String} name The field-name of the record as defined by your {@link Ext.data.Record#create Ext.data.Record definition}. The "mapping" property will be used, otherwise it will match the "name" property. Use this parameter to define the XML tag-name of the property. - * {Mixed} value The record value of the field enclosed within XML tags specified by name property above. - * - * {Array} baseParams. The baseParams as defined upon {@link Ext.data.Store#baseParams}. Note that the baseParams have been converted into an array of [{name : "foo", value: "bar"}, ...] pairs in the same manner as the records parameter above. See {@link #documentRoot} and {@link #forceDocumentRoot}. - * + * @method disable + * @hide */ - // Break up encoding here in case it's being included by some kind of page that will parse it (eg. PHP) - tpl: '<' + '?xml version="{version}" encoding="{encoding}"?' + '><{documentRoot}><{name}>{value}<{root}><{parent.record}><{name}>{value}', - /** - * XmlWriter implementation of the final stage of a write action. - * @param {Object} params Transport-proxy's (eg: {@link Ext.Ajax#request}) params-object to write-to. - * @param {Object} baseParams as defined by {@link Ext.data.Store#baseParams}. The baseParms must be encoded by the extending class, eg: {@link Ext.data.JsonWriter}, {@link Ext.data.XmlWriter}. - * @param {Object/Object[]} data Data-object representing the compiled Store-recordset. + * @method setDisabled + * @hide */ - render : function(params, baseParams, data) { - baseParams = this.toArray(baseParams); - params.xmlData = this.tpl.applyTemplate({ - version: this.xmlVersion, - encoding: this.xmlEncoding, - documentRoot: (baseParams.length > 0 || this.forceDocumentRoot === true) ? this.documentRoot : false, - record: this.meta.record, - root: this.root, - baseParams: baseParams, - records: (Ext.isArray(data[0])) ? data : [data] +}); + +Ext.tree.TreePanel.nodeTypes = {}; + +Ext.reg('treepanel', Ext.tree.TreePanel);Ext.tree.TreeEventModel = function(tree){ + this.tree = tree; + this.tree.on('render', this.initEvents, this); +}; + +Ext.tree.TreeEventModel.prototype = { + initEvents : function(){ + var t = this.tree; + + if(t.trackMouseOver !== false){ + t.mon(t.innerCt, { + scope: this, + mouseover: this.delegateOver, + mouseout: this.delegateOut + }); + } + t.mon(t.getTreeEl(), { + scope: this, + click: this.delegateClick, + dblclick: this.delegateDblClick, + contextmenu: this.delegateContextMenu }); }, - /** - * createRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Array} Array of name:value pairs for attributes of the {@link Ext.data.Record}. See {@link Ext.data.DataWriter#toHash}. - */ - createRecord : function(rec) { - return this.toArray(this.toHash(rec)); + getNode : function(e){ + var t; + if(t = e.getTarget('.x-tree-node-el', 10)){ + var id = Ext.fly(t, '_treeEvents').getAttribute('tree-node-id', 'ext'); + if(id){ + return this.tree.getNodeById(id); + } + } + return null; }, - /** - * updateRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Array} Array of {name:value} pairs for attributes of the {@link Ext.data.Record}. See {@link Ext.data.DataWriter#toHash}. - */ - updateRecord : function(rec) { - return this.toArray(this.toHash(rec)); + getNodeTarget : function(e){ + var t = e.getTarget('.x-tree-node-icon', 1); + if(!t){ + t = e.getTarget('.x-tree-node-el', 6); + } + return t; + }, + delegateOut : function(e, t){ + if(!this.beforeEvent(e)){ + return; + } + if(e.getTarget('.x-tree-ec-icon', 1)){ + var n = this.getNode(e); + this.onIconOut(e, n); + if(n == this.lastEcOver){ + delete this.lastEcOver; + } + } + if((t = this.getNodeTarget(e)) && !e.within(t, true)){ + this.onNodeOut(e, this.getNode(e)); + } }, - /** - * destroyRecord - * @protected - * @param {Ext.data.Record} rec - * @return {Array} Array containing a attribute-object (name/value pair) representing the {@link Ext.data.DataReader#idProperty idProperty}. - */ - destroyRecord : function(rec) { - var data = {}; - data[this.meta.idProperty] = rec.id; - return this.toArray(data); - } -}); -/** - * @class Ext.data.XmlReader - * @extends Ext.data.DataReader - * Data reader class to create an Array of {@link Ext.data.Record} objects from an XML document - * based on mappings in a provided {@link Ext.data.Record} constructor. - * Note: that in order for the browser to parse a returned XML document, the Content-Type - * header in the HTTP response must be set to "text/xml" or "application/xml". - * Example code: - * -var Employee = Ext.data.Record.create([ - {name: 'name', mapping: 'name'}, // "mapping" property not needed if it is the same as "name" - {name: 'occupation'} // This field will use "occupation" as the mapping. -]); -var myReader = new Ext.data.XmlReader({ - totalProperty: "results", // The element which contains the total dataset size (optional) - record: "row", // The repeated element which contains row information - idProperty: "id" // The element within the row that provides an ID for the record (optional) - messageProperty: "msg" // The element within the response that provides a user-feedback message (optional) -}, Employee); - - * - * This would consume an XML file like this: - * -<?xml version="1.0" encoding="UTF-8"?> -<dataset> - <results>2</results> - <row> - <id>1</id> - <name>Bill</name> - <occupation>Gardener</occupation> - </row> - <row> - <id>2</id> - <name>Ben</name> - <occupation>Horticulturalist</occupation> - </row> -</dataset> - - * @cfg {String} totalProperty The DomQuery path from which to retrieve the total number of records - * in the dataset. This is only needed if the whole dataset is not passed in one go, but is being - * paged from the remote server. - * @cfg {String} record The DomQuery path to the repeated element which contains record information. - * @cfg {String} record The DomQuery path to the repeated element which contains record information. - * @cfg {String} successProperty The DomQuery path to the success attribute used by forms. - * @cfg {String} idPath The DomQuery path relative from the record element to the element that contains - * a record identifier value. - * @constructor - * Create a new XmlReader. - * @param {Object} meta Metadata configuration options - * @param {Object} recordType Either an Array of field definition objects as passed to - * {@link Ext.data.Record#create}, or a Record constructor object created using {@link Ext.data.Record#create}. - */ -Ext.data.XmlReader = function(meta, recordType){ - meta = meta || {}; + delegateOver : function(e, t){ + if(!this.beforeEvent(e)){ + return; + } + if(Ext.isGecko && !this.trackingDoc){ // prevent hanging in FF + Ext.getBody().on('mouseover', this.trackExit, this); + this.trackingDoc = true; + } + if(this.lastEcOver){ // prevent hung highlight + this.onIconOut(e, this.lastEcOver); + delete this.lastEcOver; + } + if(e.getTarget('.x-tree-ec-icon', 1)){ + this.lastEcOver = this.getNode(e); + this.onIconOver(e, this.lastEcOver); + } + if(t = this.getNodeTarget(e)){ + this.onNodeOver(e, this.getNode(e)); + } + }, - // backwards compat, convert idPath or id / success - Ext.applyIf(meta, { - idProperty: meta.idProperty || meta.idPath || meta.id, - successProperty: meta.successProperty || meta.success - }); + trackExit : function(e){ + if(this.lastOverNode){ + if(this.lastOverNode.ui && !e.within(this.lastOverNode.ui.getEl())){ + this.onNodeOut(e, this.lastOverNode); + } + delete this.lastOverNode; + Ext.getBody().un('mouseover', this.trackExit, this); + this.trackingDoc = false; + } - Ext.data.XmlReader.superclass.constructor.call(this, meta, recordType || meta.fields); -}; -Ext.extend(Ext.data.XmlReader, Ext.data.DataReader, { - /** - * This method is only used by a DataProxy which has retrieved data from a remote server. - * @param {Object} response The XHR object which contains the parsed XML document. The response is expected - * to contain a property called responseXML which refers to an XML document object. - * @return {Object} records A data block which is used by an {@link Ext.data.Store} as - * a cache of Ext.data.Records. - */ - read : function(response){ - var doc = response.responseXML; - if(!doc) { - throw {message: "XmlReader.read: XML Document not available"}; + }, + + delegateClick : function(e, t){ + if(this.beforeEvent(e)){ + if(e.getTarget('input[type=checkbox]', 1)){ + this.onCheckboxClick(e, this.getNode(e)); + }else if(e.getTarget('.x-tree-ec-icon', 1)){ + this.onIconClick(e, this.getNode(e)); + }else if(this.getNodeTarget(e)){ + this.onNodeClick(e, this.getNode(e)); + } + }else{ + this.checkContainerEvent(e, 'click'); + } + }, + + delegateDblClick : function(e, t){ + if(this.beforeEvent(e)){ + if(this.getNodeTarget(e)){ + this.onNodeDblClick(e, this.getNode(e)); + } + }else{ + this.checkContainerEvent(e, 'dblclick'); + } + }, + + delegateContextMenu : function(e, t){ + if(this.beforeEvent(e)){ + if(this.getNodeTarget(e)){ + this.onNodeContextMenu(e, this.getNode(e)); + } + }else{ + this.checkContainerEvent(e, 'contextmenu'); } - return this.readRecords(doc); + }, + + checkContainerEvent: function(e, type){ + if(this.disabled){ + e.stopEvent(); + return false; + } + this.onContainerEvent(e, type); }, - /** - * Create a data block containing Ext.data.Records from an XML document. - * @param {Object} doc A parsed XML document. - * @return {Object} records A data block which is used by an {@link Ext.data.Store} as - * a cache of Ext.data.Records. - */ - readRecords : function(doc){ - /** - * After any data loads/reads, the raw XML Document is available for further custom processing. - * @type XMLDocument - */ - this.xmlData = doc; + onContainerEvent: function(e, type){ + this.tree.fireEvent('container' + type, this.tree, e); + }, - var root = doc.documentElement || doc, - q = Ext.DomQuery, - totalRecords = 0, - success = true; + onNodeClick : function(e, node){ + node.ui.onClick(e); + }, - if(this.meta.totalProperty){ - totalRecords = this.getTotal(root, 0); - } - if(this.meta.successProperty){ - success = this.getSuccess(root); - } + onNodeOver : function(e, node){ + this.lastOverNode = node; + node.ui.onOver(e); + }, - var records = this.extractData(q.select(this.meta.record, root), true); // <-- true to return Ext.data.Record[] + onNodeOut : function(e, node){ + node.ui.onOut(e); + }, - // TODO return Ext.data.Response instance. @see #readResponse - return { - success : success, - records : records, - totalRecords : totalRecords || records.length - }; + onIconOver : function(e, node){ + node.ui.addClass('x-tree-ec-over'); }, - /** - * Decode a json response from server. - * @param {String} action [{@link Ext.data.Api#actions} create|read|update|destroy] - * @param {Object} response HTTP Response object from browser. - * @return {Ext.data.Response} response Returns an instance of {@link Ext.data.Response} - */ - readResponse : function(action, response) { - var q = Ext.DomQuery, - doc = response.responseXML; + onIconOut : function(e, node){ + node.ui.removeClass('x-tree-ec-over'); + }, - // create general Response instance. - var res = new Ext.data.Response({ - action: action, - success : this.getSuccess(doc), - message: this.getMessage(doc), - data: this.extractData(q.select(this.meta.record, doc) || q.select(this.meta.root, doc), false), - raw: doc - }); + onIconClick : function(e, node){ + node.ui.ecClick(e); + }, - if (Ext.isEmpty(res.success)) { - throw new Ext.data.DataReader.Error('successProperty-response', this.meta.successProperty); - } + onCheckboxClick : function(e, node){ + node.ui.onCheckChange(e); + }, - // Create actions from a response having status 200 must return pk - if (action === Ext.data.Api.actions.create) { - var def = Ext.isDefined(res.data); - if (def && Ext.isEmpty(res.data)) { - throw new Ext.data.JsonReader.Error('root-empty', this.meta.root); - } - else if (!def) { - throw new Ext.data.JsonReader.Error('root-undefined-response', this.meta.root); - } - } - return res; + onNodeDblClick : function(e, node){ + node.ui.onDblClick(e); }, - getSuccess : function() { + onNodeContextMenu : function(e, node){ + node.ui.onContextMenu(e); + }, + + beforeEvent : function(e){ + var node = this.getNode(e); + if(this.disabled || !node || !node.ui){ + e.stopEvent(); + return false; + } return true; }, + disable: function(){ + this.disabled = true; + }, + + enable: function(){ + this.disabled = false; + } +};/** + * @class Ext.tree.DefaultSelectionModel + * @extends Ext.util.Observable + * The default single selection for a TreePanel. + */ +Ext.tree.DefaultSelectionModel = function(config){ + this.selNode = null; + + this.addEvents( + /** + * @event selectionchange + * Fires when the selected node changes + * @param {DefaultSelectionModel} this + * @param {TreeNode} node the new selection + */ + 'selectionchange', + + /** + * @event beforeselect + * Fires before the selected node changes, return false to cancel the change + * @param {DefaultSelectionModel} this + * @param {TreeNode} node the new selection + * @param {TreeNode} node the old selection + */ + 'beforeselect' + ); + + Ext.apply(this, config); + Ext.tree.DefaultSelectionModel.superclass.constructor.call(this); +}; + +Ext.extend(Ext.tree.DefaultSelectionModel, Ext.util.Observable, { + init : function(tree){ + this.tree = tree; + tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); + tree.on('click', this.onNodeClick, this); + }, + + onNodeClick : function(node, e){ + this.select(node); + }, + /** - * build response-data extractor functions. - * @private - * @ignore + * Select a node. + * @param {TreeNode} node The node to select + * @return {TreeNode} The selected node */ - buildExtractors : function() { - if(this.ef){ - return; - } - var s = this.meta, - Record = this.recordType, - f = Record.prototype.fields, - fi = f.items, - fl = f.length; - - if(s.totalProperty) { - this.getTotal = this.createAccessor(s.totalProperty); - } - if(s.successProperty) { - this.getSuccess = this.createAccessor(s.successProperty); - } - if (s.messageProperty) { - this.getMessage = this.createAccessor(s.messageProperty); + select : function(node, /* private*/ selectNextNode){ + // If node is hidden, select the next node in whatever direction was being moved in. + if (!Ext.fly(node.ui.wrap).isVisible() && selectNextNode) { + return selectNextNode.call(this, node); } - this.getRoot = function(res) { - return (!Ext.isEmpty(res[this.meta.record])) ? res[this.meta.record] : res[this.meta.root]; - } - if (s.idPath || s.idProperty) { - var g = this.createAccessor(s.idPath || s.idProperty); - this.getId = function(rec) { - var id = g(rec) || rec.id; - return (id === undefined || id === '') ? null : id; - }; - } else { - this.getId = function(){return null;}; + var last = this.selNode; + if(node == last){ + node.ui.onSelectedChange(true); + }else if(this.fireEvent('beforeselect', this, node, last) !== false){ + if(last && last.ui){ + last.ui.onSelectedChange(false); + } + this.selNode = node; + node.ui.onSelectedChange(true); + this.fireEvent('selectionchange', this, node, last); } - var ef = []; - for(var i = 0; i < fl; i++){ - f = fi[i]; - var map = (f.mapping !== undefined && f.mapping !== null) ? f.mapping : f.name; - ef.push(this.createAccessor(map)); + return node; + }, + + /** + * Deselect a node. + * @param {TreeNode} node The node to unselect + * @param {Boolean} silent True to stop the selectionchange event from firing. + */ + unselect : function(node, silent){ + if(this.selNode == node){ + this.clearSelections(silent); + } + }, + + /** + * Clear all selections + * @param {Boolean} silent True to stop the selectionchange event from firing. + */ + clearSelections : function(silent){ + var n = this.selNode; + if(n){ + n.ui.onSelectedChange(false); + this.selNode = null; + if(silent !== true){ + this.fireEvent('selectionchange', this, null); + } } - this.ef = ef; + return n; + }, + + /** + * Get the selected node + * @return {TreeNode} The selected node + */ + getSelectedNode : function(){ + return this.selNode; + }, + + /** + * Returns true if the node is selected + * @param {TreeNode} node The node to check + * @return {Boolean} + */ + isSelected : function(node){ + return this.selNode == node; }, /** - * Creates a function to return some particular key of data from a response. - * @param {String} key - * @return {Function} - * @private - * @ignore + * Selects the node above the selected node in the tree, intelligently walking the nodes + * @return TreeNode The new selection */ - createAccessor : function(){ - var q = Ext.DomQuery; - return function(key) { - switch(key) { - case this.meta.totalProperty: - return function(root, def){ - return q.selectNumber(key, root, def); - } - break; - case this.meta.successProperty: - return function(root, def) { - var sv = q.selectValue(key, root, true); - var success = sv !== false && sv !== 'false'; - return success; - } - break; - default: - return function(root, def) { - return q.selectValue(key, root, def); - } - break; + selectPrevious : function(/* private */ s){ + if(!(s = s || this.selNode || this.lastSelNode)){ + return null; + } + // Here we pass in the current function to select to indicate the direction we're moving + var ps = s.previousSibling; + if(ps){ + if(!ps.isExpanded() || ps.childNodes.length < 1){ + return this.select(ps, this.selectPrevious); + } else{ + var lc = ps.lastChild; + while(lc && lc.isExpanded() && Ext.fly(lc.ui.wrap).isVisible() && lc.childNodes.length > 0){ + lc = lc.lastChild; + } + return this.select(lc, this.selectPrevious); } - }; - }(), + } else if(s.parentNode && (this.tree.rootVisible || !s.parentNode.isRoot)){ + return this.select(s.parentNode, this.selectPrevious); + } + return null; + }, /** - * extracts values and type-casts a row of data from server, extracted by #extractData - * @param {Hash} data - * @param {Ext.data.Field[]} items - * @param {Number} len - * @private - * @ignore + * Selects the node above the selected node in the tree, intelligently walking the nodes + * @return TreeNode The new selection */ - extractValues : function(data, items, len) { - var f, values = {}; - for(var j = 0; j < len; j++){ - f = items[j]; - var v = this.ef[j](data); - values[f.name] = f.convert((v !== undefined) ? v : f.defaultValue, data); + selectNext : function(/* private */ s){ + if(!(s = s || this.selNode || this.lastSelNode)){ + return null; } - return values; + // Here we pass in the current function to select to indicate the direction we're moving + if(s.firstChild && s.isExpanded() && Ext.fly(s.ui.wrap).isVisible()){ + return this.select(s.firstChild, this.selectNext); + }else if(s.nextSibling){ + return this.select(s.nextSibling, this.selectNext); + }else if(s.parentNode){ + var newS = null; + s.parentNode.bubble(function(){ + if(this.nextSibling){ + newS = this.getOwnerTree().selModel.select(this.nextSibling, this.selectNext); + return false; + } + }); + return newS; + } + return null; + }, + + onKeyDown : function(e){ + var s = this.selNode || this.lastSelNode; + // undesirable, but required + var sm = this; + if(!s){ + return; + } + var k = e.getKey(); + switch(k){ + case e.DOWN: + e.stopEvent(); + this.selectNext(); + break; + case e.UP: + e.stopEvent(); + this.selectPrevious(); + break; + case e.RIGHT: + e.preventDefault(); + if(s.hasChildNodes()){ + if(!s.isExpanded()){ + s.expand(); + }else if(s.firstChild){ + this.select(s.firstChild, e); + } + } + break; + case e.LEFT: + e.preventDefault(); + if(s.hasChildNodes() && s.isExpanded()){ + s.collapse(); + }else if(s.parentNode && (this.tree.rootVisible || s.parentNode != this.tree.getRootNode())){ + this.select(s.parentNode, e); + } + break; + }; } -});/** - * @class Ext.data.XmlStore - * @extends Ext.data.Store - * Small helper class to make creating {@link Ext.data.Store}s from XML data easier. - * A XmlStore will be automatically configured with a {@link Ext.data.XmlReader}. - * A store configuration would be something like: -var store = new Ext.data.XmlStore({ - // store configs - autoDestroy: true, - storeId: 'myStore', - url: 'sheldon.xml', // automatically configures a HttpProxy - // reader configs - record: 'Item', // records will have an "Item" tag - idPath: 'ASIN', - totalRecords: '@TotalResults' - fields: [ - // set up the fields mapping into the xml doc - // The first needs mapping, the others are very basic - {name: 'Author', mapping: 'ItemAttributes > Author'}, - 'Title', 'Manufacturer', 'ProductGroup' - ] -}); - * - * This store is configured to consume a returned object of the form: -<?xml version="1.0" encoding="UTF-8"?> -<ItemSearchResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2009-05-15"> - <Items> - <Request> - <IsValid>True</IsValid> - <ItemSearchRequest> - <Author>Sidney Sheldon</Author> - <SearchIndex>Books</SearchIndex> - </ItemSearchRequest> - </Request> - <TotalResults>203</TotalResults> - <TotalPages>21</TotalPages> - <Item> - <ASIN>0446355453</ASIN> - <DetailPageURL> - http://www.amazon.com/ - </DetailPageURL> - <ItemAttributes> - <Author>Sidney Sheldon</Author> - <Manufacturer>Warner Books</Manufacturer> - <ProductGroup>Book</ProductGroup> - <Title>Master of the Game</Title> - </ItemAttributes> - </Item> - </Items> -</ItemSearchResponse> - * - * An object literal of this form could also be used as the {@link #data} config option. - * Note: Although not listed here, this class accepts all of the configuration options of - * {@link Ext.data.XmlReader XmlReader}. - * @constructor - * @param {Object} config - * @xtype xmlstore - */ -Ext.data.XmlStore = Ext.extend(Ext.data.Store, { - /** - * @cfg {Ext.data.DataReader} reader @hide - */ - constructor: function(config){ - Ext.data.XmlStore.superclass.constructor.call(this, Ext.apply(config, { - reader: new Ext.data.XmlReader(config) - })); - } -}); -Ext.reg('xmlstore', Ext.data.XmlStore);/** - * @class Ext.data.GroupingStore - * @extends Ext.data.Store - * A specialized store implementation that provides for grouping records by one of the available fields. This - * is usually used in conjunction with an {@link Ext.grid.GroupingView} to proved the data model for - * a grouped GridPanel. - * @constructor - * Creates a new GroupingStore. - * @param {Object} config A config object containing the objects needed for the Store to access data, - * and read the data into Records. - * @xtype groupingstore - */ -Ext.data.GroupingStore = Ext.extend(Ext.data.Store, { - - //inherit docs - constructor: function(config){ - Ext.data.GroupingStore.superclass.constructor.call(this, config); - this.applyGroupField(); - }, - - /** - * @cfg {String} groupField - * The field name by which to sort the store's data (defaults to ''). - */ - /** - * @cfg {Boolean} remoteGroup - * True if the grouping should apply on the server side, false if it is local only (defaults to false). If the - * grouping is local, it can be applied immediately to the data. If it is remote, then it will simply act as a - * helper, automatically sending the grouping field name as the 'groupBy' param with each XHR call. - */ - remoteGroup : false, - /** - * @cfg {Boolean} groupOnSort - * True to sort the data on the grouping field when a grouping operation occurs, false to sort based on the - * existing sort info (defaults to false). - */ - groupOnSort:false, - - groupDir : 'ASC', - - /** - * Clears any existing grouping and refreshes the data using the default sort. - */ - clearGrouping : function(){ - this.groupField = false; - - if(this.remoteGroup){ - if(this.baseParams){ - delete this.baseParams.groupBy; - delete this.baseParams.groupDir; - } - var lo = this.lastOptions; - if(lo && lo.params){ - delete lo.params.groupBy; - delete lo.params.groupDir; - } - - this.reload(); - }else{ - this.applySort(); - this.fireEvent('datachanged', this); - } - }, - - /** - * Groups the data by the specified field. - * @param {String} field The field name by which to sort the store's data - * @param {Boolean} forceRegroup (optional) True to force the group to be refreshed even if the field passed - * in is the same as the current grouping field, false to skip grouping on the same field (defaults to false) - */ - groupBy : function(field, forceRegroup, direction){ - direction = direction ? (String(direction).toUpperCase() == 'DESC' ? 'DESC' : 'ASC') : this.groupDir; - if(this.groupField == field && this.groupDir == direction && !forceRegroup){ - return; // already grouped by this field - } - this.groupField = field; - this.groupDir = direction; - this.applyGroupField(); - if(this.groupOnSort){ - this.sort(field, direction); - return; - } - if(this.remoteGroup){ - this.reload(); - }else{ - var si = this.sortInfo || {}; - if(forceRegroup || si.field != field || si.direction != direction){ - this.applySort(); - }else{ - this.sortData(field, direction); - } - this.fireEvent('datachanged', this); - } - }, - - // private - applyGroupField: function(){ - if(this.remoteGroup){ - if(!this.baseParams){ - this.baseParams = {}; - } - Ext.apply(this.baseParams, { - groupBy : this.groupField, - groupDir : this.groupDir - }); - - var lo = this.lastOptions; - if(lo && lo.params){ - Ext.apply(lo.params, { - groupBy : this.groupField, - groupDir : this.groupDir - }); - } - } - }, - - // private - applySort : function(){ - Ext.data.GroupingStore.superclass.applySort.call(this); - if(!this.groupOnSort && !this.remoteGroup){ - var gs = this.getGroupState(); - if(gs && (gs != this.sortInfo.field || this.groupDir != this.sortInfo.direction)){ - this.sortData(this.groupField, this.groupDir); - } - } - }, - - // private - applyGrouping : function(alwaysFireChange){ - if(this.groupField !== false){ - this.groupBy(this.groupField, true, this.groupDir); - return true; - }else{ - if(alwaysFireChange === true){ - this.fireEvent('datachanged', this); - } - return false; - } - }, - - // private - getGroupState : function(){ - return this.groupOnSort && this.groupField !== false ? - (this.sortInfo ? this.sortInfo.field : undefined) : this.groupField; - } -}); -Ext.reg('groupingstore', Ext.data.GroupingStore);/** - * @class Ext.data.DirectProxy - * @extends Ext.data.DataProxy - */ -Ext.data.DirectProxy = function(config){ - Ext.apply(this, config); - if(typeof this.paramOrder == 'string'){ - this.paramOrder = this.paramOrder.split(/[\s,|]/); - } - Ext.data.DirectProxy.superclass.constructor.call(this, config); -}; - -Ext.extend(Ext.data.DirectProxy, Ext.data.DataProxy, { - /** - * @cfg {Array/String} paramOrder Defaults to undefined. A list of params to be executed - * server side. Specify the params in the order in which they must be executed on the server-side - * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, - * comma, or pipe. For example, - * any of the following would be acceptable: -paramOrder: ['param1','param2','param3'] -paramOrder: 'param1 param2 param3' -paramOrder: 'param1,param2,param3' -paramOrder: 'param1|param2|param' - - */ - paramOrder: undefined, - - /** - * @cfg {Boolean} paramsAsHash - * Send parameters as a collection of named arguments (defaults to true). Providing a - * {@link #paramOrder} nullifies this configuration. - */ - paramsAsHash: true, - - /** - * @cfg {Function} directFn - * Function to call when executing a request. directFn is a simple alternative to defining the api configuration-parameter - * for Store's which will not implement a full CRUD api. - */ - directFn : undefined, - - /** - * DirectProxy implementation of {@link Ext.data.DataProxy#doRequest} - * @param {String} action The crud action type (create, read, update, destroy) - * @param {Ext.data.Record/Ext.data.Record[]} rs If action is load, rs will be null - * @param {Object} params An object containing properties which are to be used as HTTP parameters - * for the request to the remote server. - * @param {Ext.data.DataReader} reader The Reader object which converts the data - * object into a block of Ext.data.Records. - * @param {Function} callback - * A function to be called after the request. - * The callback is passed the following arguments: - * r : Ext.data.Record[] The block of Ext.data.Records. - * options: Options object from the action request - * success: Boolean success indicator - * @param {Object} scope The scope (this reference) in which the callback function is executed. Defaults to the browser window. - * @param {Object} arg An optional argument which is passed to the callback as its second parameter. - * @protected - */ - doRequest : function(action, rs, params, reader, callback, scope, options) { - var args = [], - directFn = this.api[action] || this.directFn; - - switch (action) { - case Ext.data.Api.actions.create: - args.push(params.jsonData); // <-- create(Hash) - break; - case Ext.data.Api.actions.read: - // If the method has no parameters, ignore the paramOrder/paramsAsHash. - if(directFn.directCfg.method.len > 0){ - if(this.paramOrder){ - for(var i = 0, len = this.paramOrder.length; i < len; i++){ - args.push(params[this.paramOrder[i]]); - } - }else if(this.paramsAsHash){ - args.push(params); - } - } - break; - case Ext.data.Api.actions.update: - args.push(params.jsonData); // <-- update(Hash/Hash[]) - break; - case Ext.data.Api.actions.destroy: - args.push(params.jsonData); // <-- destroy(Int/Int[]) - break; - } - - var trans = { - params : params || {}, - request: { - callback : callback, - scope : scope, - arg : options - }, - reader: reader - }; - - args.push(this.createCallback(action, rs, trans), this); - directFn.apply(window, args); - }, - - // private - createCallback : function(action, rs, trans) { - return function(result, res) { - if (!res.status) { - // @deprecated fire loadexception - if (action === Ext.data.Api.actions.read) { - this.fireEvent("loadexception", this, trans, res, null); - } - this.fireEvent('exception', this, 'remote', action, trans, res, null); - trans.request.callback.call(trans.request.scope, null, trans.request.arg, false); - return; - } - if (action === Ext.data.Api.actions.read) { - this.onRead(action, trans, result, res); - } else { - this.onWrite(action, trans, result, res, rs); - } - }; - }, - /** - * Callback for read actions - * @param {String} action [Ext.data.Api.actions.create|read|update|destroy] - * @param {Object} trans The request transaction object - * @param {Object} result Data object picked out of the server-response. - * @param {Object} res The server response - * @protected - */ - onRead : function(action, trans, result, res) { - var records; - try { - records = trans.reader.readRecords(result); - } - catch (ex) { - // @deprecated: Fire old loadexception for backwards-compat. - this.fireEvent("loadexception", this, trans, res, ex); - - this.fireEvent('exception', this, 'response', action, trans, res, ex); - trans.request.callback.call(trans.request.scope, null, trans.request.arg, false); - return; - } - this.fireEvent("load", this, res, trans.request.arg); - trans.request.callback.call(trans.request.scope, records, trans.request.arg, true); - }, - /** - * Callback for write actions - * @param {String} action [{@link Ext.data.Api#actions create|read|update|destroy}] - * @param {Object} trans The request transaction object - * @param {Object} result Data object picked out of the server-response. - * @param {Object} res The server response - * @param {Ext.data.Record/[Ext.data.Record]} rs The Store resultset associated with the action. - * @protected - */ - onWrite : function(action, trans, result, res, rs) { - var data = trans.reader.extractData(result, false); - this.fireEvent("write", this, action, data, res, rs, trans.request.arg); - trans.request.callback.call(trans.request.scope, data, res, true); - } -}); - -/** - * @class Ext.data.DirectStore - * @extends Ext.data.Store - * Small helper class to create an {@link Ext.data.Store} configured with an - * {@link Ext.data.DirectProxy} and {@link Ext.data.JsonReader} to make interacting - * with an {@link Ext.Direct} Server-side {@link Ext.direct.Provider Provider} easier. - * To create a different proxy/reader combination create a basic {@link Ext.data.Store} - * configured as needed. - * - * *Note: Although they are not listed, this class inherits all of the config options of: - * - * {@link Ext.data.Store Store} - * - * - * - * {@link Ext.data.JsonReader JsonReader} - * - * {@link Ext.data.JsonReader#root root} - * {@link Ext.data.JsonReader#idProperty idProperty} - * {@link Ext.data.JsonReader#totalProperty totalProperty} - * - * - * {@link Ext.data.DirectProxy DirectProxy} - * - * {@link Ext.data.DirectProxy#directFn directFn} - * {@link Ext.data.DirectProxy#paramOrder paramOrder} - * {@link Ext.data.DirectProxy#paramsAsHash paramsAsHash} - * - * - * - * @xtype directstore - * - * @constructor - * @param {Object} config - */ -Ext.data.DirectStore = Ext.extend(Ext.data.Store, { - constructor : function(config){ - // each transaction upon a singe record will generate a distinct Direct transaction since Direct queues them into one Ajax request. - var c = Ext.apply({}, { - batchTransactions: false - }, config); - Ext.data.DirectStore.superclass.constructor.call(this, Ext.apply(c, { - proxy: Ext.isDefined(c.proxy) ? c.proxy : new Ext.data.DirectProxy(Ext.copyTo({}, c, 'paramOrder,paramsAsHash,directFn,api')), - reader: (!Ext.isDefined(c.reader) && c.fields) ? new Ext.data.JsonReader(Ext.copyTo({}, c, 'totalProperty,root,idProperty'), c.fields) : c.reader - })); - } -}); -Ext.reg('directstore', Ext.data.DirectStore); -/** - * @class Ext.Direct - * @extends Ext.util.Observable - * Overview - * - * Ext.Direct aims to streamline communication between the client and server - * by providing a single interface that reduces the amount of common code - * typically required to validate data and handle returned data packets - * (reading data, error conditions, etc). - * - * The Ext.direct namespace includes several classes for a closer integration - * with the server-side. The Ext.data namespace also includes classes for working - * with Ext.data.Stores which are backed by data from an Ext.Direct method. - * - * Specification - * - * For additional information consult the - * Ext.Direct Specification. - * - * Providers - * - * Ext.Direct uses a provider architecture, where one or more providers are - * used to transport data to and from the server. There are several providers - * that exist in the core at the moment: - * - * {@link Ext.direct.JsonProvider JsonProvider} for simple JSON operations - * {@link Ext.direct.PollingProvider PollingProvider} for repeated requests - * {@link Ext.direct.RemotingProvider RemotingProvider} exposes server side - * on the client. - * - * - * A provider does not need to be invoked directly, providers are added via - * {@link Ext.Direct}.{@link Ext.Direct#add add}. - * - * Router - * - * Ext.Direct utilizes a "router" on the server to direct requests from the client - * to the appropriate server-side method. Because the Ext.Direct API is completely - * platform-agnostic, you could completely swap out a Java based server solution - * and replace it with one that uses C# without changing the client side JavaScript - * at all. - * - * Server side events - * - * Custom events from the server may be handled by the client by adding - * listeners, for example: - * -{"type":"event","name":"message","data":"Successfully polled at: 11:19:30 am"} - -// add a handler for a 'message' event sent by the server -Ext.Direct.on('message', function(e){ - out.append(String.format('<p><i>{0}</i></p>', e.data)); - out.el.scrollTo('t', 100000, true); -}); - * - * @singleton - */ -Ext.Direct = Ext.extend(Ext.util.Observable, { - /** - * Each event type implements a getData() method. The default event types are: - * - * event : Ext.Direct.Event - * exception : Ext.Direct.ExceptionEvent - * rpc : Ext.Direct.RemotingEvent - * - * @property eventTypes - * @type Object - */ - - /** - * Four types of possible exceptions which can occur: - * - * Ext.Direct.exceptions.TRANSPORT : 'xhr' - * Ext.Direct.exceptions.PARSE : 'parse' - * Ext.Direct.exceptions.LOGIN : 'login' - * Ext.Direct.exceptions.SERVER : 'exception' - * - * @property exceptions - * @type Object - */ - exceptions: { - TRANSPORT: 'xhr', - PARSE: 'parse', - LOGIN: 'login', - SERVER: 'exception' - }, - - // private - constructor: function(){ - this.addEvents( - /** - * @event event - * Fires after an event. - * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred. - * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}. - */ - 'event', - /** - * @event exception - * Fires after an event exception. - * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred. - */ - 'exception' - ); - this.transactions = {}; - this.providers = {}; - }, - - /** - * Adds an Ext.Direct Provider and creates the proxy or stub methods to execute server-side methods. - * If the provider is not already connected, it will auto-connect. - * -var pollProv = new Ext.direct.PollingProvider({ - url: 'php/poll2.php' -}); - -Ext.Direct.addProvider( - { - "type":"remoting", // create a {@link Ext.direct.RemotingProvider} - "url":"php\/router.php", // url to connect to the Ext.Direct server-side router. - "actions":{ // each property within the actions object represents a Class - "TestAction":[ // array of methods within each server side Class - { - "name":"doEcho", // name of method - "len":1 - },{ - "name":"multiply", - "len":1 - },{ - "name":"doForm", - "formHandler":true, // handle form on server with Ext.Direct.Transaction - "len":1 - }] - }, - "namespace":"myApplication",// namespace to create the Remoting Provider in - },{ - type: 'polling', // create a {@link Ext.direct.PollingProvider} - url: 'php/poll.php' - }, - pollProv // reference to previously created instance -); - * - * @param {Object/Array} provider Accepts either an Array of Provider descriptions (an instance - * or config object for a Provider) or any number of Provider descriptions as arguments. Each - * Provider description instructs Ext.Direct how to create client-side stub methods. - */ - addProvider : function(provider){ - var a = arguments; - if(a.length > 1){ - for(var i = 0, len = a.length; i < len; i++){ - this.addProvider(a[i]); - } - return; - } - - // if provider has not already been instantiated - if(!provider.events){ - provider = new Ext.Direct.PROVIDERS[provider.type](provider); - } - provider.id = provider.id || Ext.id(); - this.providers[provider.id] = provider; - - provider.on('data', this.onProviderData, this); - provider.on('exception', this.onProviderException, this); - - - if(!provider.isConnected()){ - provider.connect(); - } - - return provider; - }, - - /** - * Retrieve a {@link Ext.direct.Provider provider} by the - * {@link Ext.direct.Provider#id id} specified when the provider is - * {@link #addProvider added}. - * @param {String} id Unique identifier assigned to the provider when calling {@link #addProvider} - */ - getProvider : function(id){ - return this.providers[id]; - }, - - removeProvider : function(id){ - var provider = id.id ? id : this.providers[id.id]; - provider.un('data', this.onProviderData, this); - provider.un('exception', this.onProviderException, this); - delete this.providers[provider.id]; - return provider; - }, - - addTransaction: function(t){ - this.transactions[t.tid] = t; - return t; - }, - - removeTransaction: function(t){ - delete this.transactions[t.tid || t]; - return t; - }, - - getTransaction: function(tid){ - return this.transactions[tid.tid || tid]; - }, - - onProviderData : function(provider, e){ - if(Ext.isArray(e)){ - for(var i = 0, len = e.length; i < len; i++){ - this.onProviderData(provider, e[i]); - } - return; - } - if(e.name && e.name != 'event' && e.name != 'exception'){ - this.fireEvent(e.name, e); - }else if(e.type == 'exception'){ - this.fireEvent('exception', e); - } - this.fireEvent('event', e, provider); - }, - - createEvent : function(response, extraProps){ - return new Ext.Direct.eventTypes[response.type](Ext.apply(response, extraProps)); - } -}); -// overwrite impl. with static instance -Ext.Direct = new Ext.Direct(); - -Ext.Direct.TID = 1; -Ext.Direct.PROVIDERS = {};/** - * @class Ext.Direct.Transaction - * @extends Object - * Supporting Class for Ext.Direct (not intended to be used directly). - * @constructor - * @param {Object} config - */ -Ext.Direct.Transaction = function(config){ - Ext.apply(this, config); - this.tid = ++Ext.Direct.TID; - this.retryCount = 0; -}; -Ext.Direct.Transaction.prototype = { - send: function(){ - this.provider.queueTransaction(this); - }, - - retry: function(){ - this.retryCount++; - this.send(); - }, - - getProvider: function(){ - return this.provider; - } -};Ext.Direct.Event = function(config){ - Ext.apply(this, config); -} -Ext.Direct.Event.prototype = { - status: true, - getData: function(){ - return this.data; - } -}; - -Ext.Direct.RemotingEvent = Ext.extend(Ext.Direct.Event, { - type: 'rpc', - getTransaction: function(){ - return this.transaction || Ext.Direct.getTransaction(this.tid); - } -}); - -Ext.Direct.ExceptionEvent = Ext.extend(Ext.Direct.RemotingEvent, { - status: false, - type: 'exception' -}); - -Ext.Direct.eventTypes = { - 'rpc': Ext.Direct.RemotingEvent, - 'event': Ext.Direct.Event, - 'exception': Ext.Direct.ExceptionEvent -}; - -/** - * @class Ext.direct.Provider - * @extends Ext.util.Observable - * Ext.direct.Provider is an abstract class meant to be extended. - * - * For example ExtJs implements the following subclasses: - * -Provider -| -+---{@link Ext.direct.JsonProvider JsonProvider} - | - +---{@link Ext.direct.PollingProvider PollingProvider} - | - +---{@link Ext.direct.RemotingProvider RemotingProvider} - * - * @abstract - */ -Ext.direct.Provider = Ext.extend(Ext.util.Observable, { - /** - * @cfg {String} id - * The unique id of the provider (defaults to an {@link Ext#id auto-assigned id}). - * You should assign an id if you need to be able to access the provider later and you do - * not have an object reference available, for example: - * -Ext.Direct.addProvider( - { - type: 'polling', - url: 'php/poll.php', - id: 'poll-provider' - } -); - -var p = {@link Ext.Direct Ext.Direct}.{@link Ext.Direct#getProvider getProvider}('poll-provider'); -p.disconnect(); - * - */ - - /** - * @cfg {Number} priority - * Priority of the request. Lower is higher priority, 0 means "duplex" (always on). - * All Providers default to 1 except for PollingProvider which defaults to 3. - */ - priority: 1, - - /** - * @cfg {String} type - * Required, undefined by default. The type of provider specified - * to {@link Ext.Direct Ext.Direct}.{@link Ext.Direct#addProvider addProvider} to create a - * new Provider. Acceptable values by default are: - * polling : {@link Ext.direct.PollingProvider PollingProvider} - * remoting : {@link Ext.direct.RemotingProvider RemotingProvider} - * - */ - - // private - constructor : function(config){ - Ext.apply(this, config); - this.addEvents( - /** - * @event connect - * Fires when the Provider connects to the server-side - * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}. - */ - 'connect', - /** - * @event disconnect - * Fires when the Provider disconnects from the server-side - * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}. - */ - 'disconnect', - /** - * @event data - * Fires when the Provider receives data from the server-side - * @param {Ext.direct.Provider} provider The {@link Ext.direct.Provider Provider}. - * @param {event} e The {@link Ext.Direct#eventTypes Ext.Direct.Event type} that occurred. - */ - 'data', - /** - * @event exception - * Fires when the Provider receives an exception from the server-side - */ - 'exception' - ); - Ext.direct.Provider.superclass.constructor.call(this, config); - }, - - /** - * Returns whether or not the server-side is currently connected. - * Abstract method for subclasses to implement. - */ - isConnected: function(){ - return false; - }, - - /** - * Abstract methods for subclasses to implement. - */ - connect: Ext.emptyFn, - - /** - * Abstract methods for subclasses to implement. - */ - disconnect: Ext.emptyFn -}); -/** - * @class Ext.direct.JsonProvider - * @extends Ext.direct.Provider - */ -Ext.direct.JsonProvider = Ext.extend(Ext.direct.Provider, { - parseResponse: function(xhr){ - if(!Ext.isEmpty(xhr.responseText)){ - if(typeof xhr.responseText == 'object'){ - return xhr.responseText; - } - return Ext.decode(xhr.responseText); - } - return null; - }, - - getEvents: function(xhr){ - var data = null; - try{ - data = this.parseResponse(xhr); - }catch(e){ - var event = new Ext.Direct.ExceptionEvent({ - data: e, - xhr: xhr, - code: Ext.Direct.exceptions.PARSE, - message: 'Error parsing json response: \n\n ' + data - }) - return [event]; - } - var events = []; - if(Ext.isArray(data)){ - for(var i = 0, len = data.length; i < len; i++){ - events.push(Ext.Direct.createEvent(data[i])); - } - }else{ - events.push(Ext.Direct.createEvent(data)); - } - return events; - } -});/** - * @class Ext.direct.PollingProvider - * @extends Ext.direct.JsonProvider - * - * Provides for repetitive polling of the server at distinct {@link #interval intervals}. - * The initial request for data originates from the client, and then is responded to by the - * server. - * - * All configurations for the PollingProvider should be generated by the server-side - * API portion of the Ext.Direct stack. - * - * An instance of PollingProvider may be created directly via the new keyword or by simply - * specifying type = 'polling'. For example: - * -var pollA = new Ext.direct.PollingProvider({ - type:'polling', - url: 'php/pollA.php', -}); -Ext.Direct.addProvider(pollA); -pollA.disconnect(); - -Ext.Direct.addProvider( - { - type:'polling', - url: 'php/pollB.php', - id: 'pollB-provider' - } -); -var pollB = Ext.Direct.getProvider('pollB-provider'); - * - */ -Ext.direct.PollingProvider = Ext.extend(Ext.direct.JsonProvider, { - /** - * @cfg {Number} priority - * Priority of the request (defaults to 3). See {@link Ext.direct.Provider#priority}. - */ - // override default priority - priority: 3, - - /** - * @cfg {Number} interval - * How often to poll the server-side in milliseconds (defaults to 3000 - every - * 3 seconds). - */ - interval: 3000, - - /** - * @cfg {Object} baseParams An object containing properties which are to be sent as parameters - * on every polling request - */ - - /** - * @cfg {String/Function} url - * The url which the PollingProvider should contact with each request. This can also be - * an imported Ext.Direct method which will accept the baseParams as its only argument. - */ - - // private - constructor : function(config){ - Ext.direct.PollingProvider.superclass.constructor.call(this, config); - this.addEvents( - /** - * @event beforepoll - * Fired immediately before a poll takes place, an event handler can return false - * in order to cancel the poll. - * @param {Ext.direct.PollingProvider} - */ - 'beforepoll', - /** - * @event poll - * This event has not yet been implemented. - * @param {Ext.direct.PollingProvider} - */ - 'poll' - ); - }, - - // inherited - isConnected: function(){ - return !!this.pollTask; - }, - - /** - * Connect to the server-side and begin the polling process. To handle each - * response subscribe to the data event. - */ - connect: function(){ - if(this.url && !this.pollTask){ - this.pollTask = Ext.TaskMgr.start({ - run: function(){ - if(this.fireEvent('beforepoll', this) !== false){ - if(typeof this.url == 'function'){ - this.url(this.baseParams); - }else{ - Ext.Ajax.request({ - url: this.url, - callback: this.onData, - scope: this, - params: this.baseParams - }); - } - } - }, - interval: this.interval, - scope: this - }); - this.fireEvent('connect', this); - }else if(!this.url){ - throw 'Error initializing PollingProvider, no url configured.'; - } - }, - - /** - * Disconnect from the server-side and stop the polling process. The disconnect - * event will be fired on a successful disconnect. - */ - disconnect: function(){ - if(this.pollTask){ - Ext.TaskMgr.stop(this.pollTask); - delete this.pollTask; - this.fireEvent('disconnect', this); - } - }, - - // private - onData: function(opt, success, xhr){ - if(success){ - var events = this.getEvents(xhr); - for(var i = 0, len = events.length; i < len; i++){ - var e = events[i]; - this.fireEvent('data', this, e); - } - }else{ - var e = new Ext.Direct.ExceptionEvent({ - data: e, - code: Ext.Direct.exceptions.TRANSPORT, - message: 'Unable to connect to the server.', - xhr: xhr - }); - this.fireEvent('data', this, e); - } - } -}); - -Ext.Direct.PROVIDERS['polling'] = Ext.direct.PollingProvider;/** - * @class Ext.direct.RemotingProvider - * @extends Ext.direct.JsonProvider - * - * The {@link Ext.direct.RemotingProvider RemotingProvider} exposes access to - * server side methods on the client (a remote procedure call (RPC) type of - * connection where the client can initiate a procedure on the server). - * - * This allows for code to be organized in a fashion that is maintainable, - * while providing a clear path between client and server, something that is - * not always apparent when using URLs. - * - * To accomplish this the server-side needs to describe what classes and methods - * are available on the client-side. This configuration will typically be - * outputted by the server-side Ext.Direct stack when the API description is built. - */ -Ext.direct.RemotingProvider = Ext.extend(Ext.direct.JsonProvider, { - /** - * @cfg {Object} actions - * Object literal defining the server side actions and methods. For example, if - * the Provider is configured with: - * -"actions":{ // each property within the 'actions' object represents a server side Class - "TestAction":[ // array of methods within each server side Class to be - { // stubbed out on client - "name":"doEcho", - "len":1 - },{ - "name":"multiply",// name of method - "len":2 // The number of parameters that will be used to create an - // array of data to send to the server side function. - // Ensure the server sends back a Number, not a String. - },{ - "name":"doForm", - "formHandler":true, // direct the client to use specialized form handling method - "len":1 - }] -} - * - * Note that a Store is not required, a server method can be called at any time. - * In the following example a client side handler is used to call the - * server side method "multiply" in the server-side "TestAction" Class: - * -TestAction.multiply( - 2, 4, // pass two arguments to server, so specify len=2 - // callback function after the server is called - // result: the result returned by the server - // e: Ext.Direct.RemotingEvent object - function(result, e){ - var t = e.getTransaction(); - var action = t.action; // server side Class called - var method = t.method; // server side method called - if(e.status){ - var answer = Ext.encode(result); // 8 - - }else{ - var msg = e.message; // failure message - } - } -); - * - * In the example above, the server side "multiply" function will be passed two - * arguments (2 and 4). The "multiply" method should return the value 8 which will be - * available as the result in the example above. - */ - - /** - * @cfg {String/Object} namespace - * Namespace for the Remoting Provider (defaults to the browser global scope of window). - * Explicitly specify the namespace Object, or specify a String to have a - * {@link Ext#namespace namespace created} implicitly. - */ - - /** - * @cfg {String} url - * Required. The url to connect to the {@link Ext.Direct} server-side router. - */ - - /** - * @cfg {String} enableUrlEncode - * Specify which param will hold the arguments for the method. - * Defaults to 'data'. - */ - - /** - * @cfg {Number/Boolean} enableBuffer - * true or false to enable or disable combining of method - * calls. If a number is specified this is the amount of time in milliseconds - * to wait before sending a batched request (defaults to 10). - * Calls which are received within the specified timeframe will be - * concatenated together and sent in a single request, optimizing the - * application by reducing the amount of round trips that have to be made - * to the server. - */ - enableBuffer: 10, - - /** - * @cfg {Number} maxRetries - * Number of times to re-attempt delivery on failure of a call. Defaults to 1. - */ - maxRetries: 1, - - /** - * @cfg {Number} timeout - * The timeout to use for each request. Defaults to undefined. - */ - timeout: undefined, - - constructor : function(config){ - Ext.direct.RemotingProvider.superclass.constructor.call(this, config); - this.addEvents( - /** - * @event beforecall - * Fires immediately before the client-side sends off the RPC call. - * By returning false from an event handler you can prevent the call from - * executing. - * @param {Ext.direct.RemotingProvider} provider - * @param {Ext.Direct.Transaction} transaction - */ - 'beforecall', - /** - * @event call - * Fires immediately after the request to the server-side is sent. This does - * NOT fire after the response has come back from the call. - * @param {Ext.direct.RemotingProvider} provider - * @param {Ext.Direct.Transaction} transaction - */ - 'call' - ); - this.namespace = (Ext.isString(this.namespace)) ? Ext.ns(this.namespace) : this.namespace || window; - this.transactions = {}; - this.callBuffer = []; - }, - - // private - initAPI : function(){ - var o = this.actions; - for(var c in o){ - var cls = this.namespace[c] || (this.namespace[c] = {}), - ms = o[c]; - for(var i = 0, len = ms.length; i < len; i++){ - var m = ms[i]; - cls[m.name] = this.createMethod(c, m); - } - } - }, - - // inherited - isConnected: function(){ - return !!this.connected; - }, - - connect: function(){ - if(this.url){ - this.initAPI(); - this.connected = true; - this.fireEvent('connect', this); - }else if(!this.url){ - throw 'Error initializing RemotingProvider, no url configured.'; - } - }, - - disconnect: function(){ - if(this.connected){ - this.connected = false; - this.fireEvent('disconnect', this); - } - }, - - onData: function(opt, success, xhr){ - if(success){ - var events = this.getEvents(xhr); - for(var i = 0, len = events.length; i < len; i++){ - var e = events[i], - t = this.getTransaction(e); - this.fireEvent('data', this, e); - if(t){ - this.doCallback(t, e, true); - Ext.Direct.removeTransaction(t); - } - } - }else{ - var ts = [].concat(opt.ts); - for(var i = 0, len = ts.length; i < len; i++){ - var t = this.getTransaction(ts[i]); - if(t && t.retryCount < this.maxRetries){ - t.retry(); - }else{ - var e = new Ext.Direct.ExceptionEvent({ - data: e, - transaction: t, - code: Ext.Direct.exceptions.TRANSPORT, - message: 'Unable to connect to the server.', - xhr: xhr - }); - this.fireEvent('data', this, e); - if(t){ - this.doCallback(t, e, false); - Ext.Direct.removeTransaction(t); - } - } - } - } - }, - - getCallData: function(t){ - return { - action: t.action, - method: t.method, - data: t.data, - type: 'rpc', - tid: t.tid - }; - }, - - doSend : function(data){ - var o = { - url: this.url, - callback: this.onData, - scope: this, - ts: data, - timeout: this.timeout - }, callData; - - if(Ext.isArray(data)){ - callData = []; - for(var i = 0, len = data.length; i < len; i++){ - callData.push(this.getCallData(data[i])); - } - }else{ - callData = this.getCallData(data); - } - - if(this.enableUrlEncode){ - var params = {}; - params[Ext.isString(this.enableUrlEncode) ? this.enableUrlEncode : 'data'] = Ext.encode(callData); - o.params = params; - }else{ - o.jsonData = callData; - } - Ext.Ajax.request(o); - }, - - combineAndSend : function(){ - var len = this.callBuffer.length; - if(len > 0){ - this.doSend(len == 1 ? this.callBuffer[0] : this.callBuffer); - this.callBuffer = []; - } - }, - - queueTransaction: function(t){ - if(t.form){ - this.processForm(t); - return; - } - this.callBuffer.push(t); - if(this.enableBuffer){ - if(!this.callTask){ - this.callTask = new Ext.util.DelayedTask(this.combineAndSend, this); - } - this.callTask.delay(Ext.isNumber(this.enableBuffer) ? this.enableBuffer : 10); - }else{ - this.combineAndSend(); - } - }, - - doCall : function(c, m, args){ - var data = null, hs = args[m.len], scope = args[m.len+1]; - - if(m.len !== 0){ - data = args.slice(0, m.len); - } - - var t = new Ext.Direct.Transaction({ - provider: this, - args: args, - action: c, - method: m.name, - data: data, - cb: scope && Ext.isFunction(hs) ? hs.createDelegate(scope) : hs - }); - - if(this.fireEvent('beforecall', this, t) !== false){ - Ext.Direct.addTransaction(t); - this.queueTransaction(t); - this.fireEvent('call', this, t); - } - }, - - doForm : function(c, m, form, callback, scope){ - var t = new Ext.Direct.Transaction({ - provider: this, - action: c, - method: m.name, - args:[form, callback, scope], - cb: scope && Ext.isFunction(callback) ? callback.createDelegate(scope) : callback, - isForm: true - }); - - if(this.fireEvent('beforecall', this, t) !== false){ - Ext.Direct.addTransaction(t); - var isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data', - params = { - extTID: t.tid, - extAction: c, - extMethod: m.name, - extType: 'rpc', - extUpload: String(isUpload) - }; - - // change made from typeof callback check to callback.params - // to support addl param passing in DirectSubmit EAC 6/2 - Ext.apply(t, { - form: Ext.getDom(form), - isUpload: isUpload, - params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params - }); - this.fireEvent('call', this, t); - this.processForm(t); - } - }, - - processForm: function(t){ - Ext.Ajax.request({ - url: this.url, - params: t.params, - callback: this.onData, - scope: this, - form: t.form, - isUpload: t.isUpload, - ts: t - }); - }, - - createMethod : function(c, m){ - var f; - if(!m.formHandler){ - f = function(){ - this.doCall(c, m, Array.prototype.slice.call(arguments, 0)); - }.createDelegate(this); - }else{ - f = function(form, callback, scope){ - this.doForm(c, m, form, callback, scope); - }.createDelegate(this); - } - f.directCfg = { - action: c, - method: m - }; - return f; - }, - - getTransaction: function(opt){ - return opt && opt.tid ? Ext.Direct.getTransaction(opt.tid) : null; - }, - - doCallback: function(t, e){ - var fn = e.status ? 'success' : 'failure'; - if(t && t.cb){ - var hs = t.cb, - result = Ext.isDefined(e.result) ? e.result : e.data; - if(Ext.isFunction(hs)){ - hs(result, e); - } else{ - Ext.callback(hs[fn], hs.scope, [result, e]); - Ext.callback(hs.callback, hs.scope, [result, e]); - } - } - } -}); -Ext.Direct.PROVIDERS['remoting'] = Ext.direct.RemotingProvider;/*! - * Ext JS Library 3.1.1 - * Copyright(c) 2006-2010 Ext JS, LLC - * licensing@extjs.com - * http://www.extjs.com/license - */ -/** - * @class Ext.Resizable - * @extends Ext.util.Observable - * Applies drag handles to an element to make it resizable. The drag handles are inserted into the element - * and positioned absolute. Some elements, such as a textarea or image, don't support this. To overcome that, you can wrap - * the textarea in a div and set 'resizeChild' to true (or to the id of the element), or set wrap:true in your config and - * the element will be wrapped for you automatically. - * Here is the list of valid resize handles: - * -Value Description ------- ------------------- - 'n' north - 's' south - 'e' east - 'w' west - 'nw' northwest - 'sw' southwest - 'se' southeast - 'ne' northeast - 'all' all - - * Here's an example showing the creation of a typical Resizable: - * -var resizer = new Ext.Resizable('element-id', { - handles: 'all', - minWidth: 200, - minHeight: 100, - maxWidth: 500, - maxHeight: 400, - pinned: true -}); -resizer.on('resize', myHandler); - - * To hide a particular handle, set its display to none in CSS, or through script: - * resizer.east.setDisplayed(false); - * @constructor - * Create a new resizable component - * @param {Mixed} el The id or element to resize - * @param {Object} config configuration options - */ -Ext.Resizable = Ext.extend(Ext.util.Observable, { - - constructor: function(el, config){ - this.el = Ext.get(el); - if(config && config.wrap){ - config.resizeChild = this.el; - this.el = this.el.wrap(typeof config.wrap == 'object' ? config.wrap : {cls:'xresizable-wrap'}); - this.el.id = this.el.dom.id = config.resizeChild.id + '-rzwrap'; - this.el.setStyle('overflow', 'hidden'); - this.el.setPositioning(config.resizeChild.getPositioning()); - config.resizeChild.clearPositioning(); - if(!config.width || !config.height){ - var csize = config.resizeChild.getSize(); - this.el.setSize(csize.width, csize.height); - } - if(config.pinned && !config.adjustments){ - config.adjustments = 'auto'; - } - } - - /** - * The proxy Element that is resized in place of the real Element during the resize operation. - * This may be queried using {@link Ext.Element#getBox} to provide the new area to resize to. - * Read only. - * @type Ext.Element. - * @property proxy - */ - this.proxy = this.el.createProxy({tag: 'div', cls: 'x-resizable-proxy', id: this.el.id + '-rzproxy'}, Ext.getBody()); - this.proxy.unselectable(); - this.proxy.enableDisplayMode('block'); - - Ext.apply(this, config); - - if(this.pinned){ - this.disableTrackOver = true; - this.el.addClass('x-resizable-pinned'); - } - // if the element isn't positioned, make it relative - var position = this.el.getStyle('position'); - if(position != 'absolute' && position != 'fixed'){ - this.el.setStyle('position', 'relative'); - } - if(!this.handles){ // no handles passed, must be legacy style - this.handles = 's,e,se'; - if(this.multiDirectional){ - this.handles += ',n,w'; - } - } - if(this.handles == 'all'){ - this.handles = 'n s e w ne nw se sw'; - } - var hs = this.handles.split(/\s*?[,;]\s*?| /); - var ps = Ext.Resizable.positions; - for(var i = 0, len = hs.length; i < len; i++){ - if(hs[i] && ps[hs[i]]){ - var pos = ps[hs[i]]; - this[pos] = new Ext.Resizable.Handle(this, pos, this.disableTrackOver, this.transparent, this.handleCls); - } - } - // legacy - this.corner = this.southeast; - - if(this.handles.indexOf('n') != -1 || this.handles.indexOf('w') != -1){ - this.updateBox = true; - } - - this.activeHandle = null; - - if(this.resizeChild){ - if(typeof this.resizeChild == 'boolean'){ - this.resizeChild = Ext.get(this.el.dom.firstChild, true); - }else{ - this.resizeChild = Ext.get(this.resizeChild, true); - } - } - - if(this.adjustments == 'auto'){ - var rc = this.resizeChild; - var hw = this.west, he = this.east, hn = this.north, hs = this.south; - if(rc && (hw || hn)){ - rc.position('relative'); - rc.setLeft(hw ? hw.el.getWidth() : 0); - rc.setTop(hn ? hn.el.getHeight() : 0); - } - this.adjustments = [ - (he ? -he.el.getWidth() : 0) + (hw ? -hw.el.getWidth() : 0), - (hn ? -hn.el.getHeight() : 0) + (hs ? -hs.el.getHeight() : 0) -1 - ]; - } - - if(this.draggable){ - this.dd = this.dynamic ? - this.el.initDD(null) : this.el.initDDProxy(null, {dragElId: this.proxy.id}); - this.dd.setHandleElId(this.resizeChild ? this.resizeChild.id : this.el.id); - if(this.constrainTo){ - this.dd.constrainTo(this.constrainTo); - } - } - - this.addEvents( - /** - * @event beforeresize - * Fired before resize is allowed. Set {@link #enabled} to false to cancel resize. - * @param {Ext.Resizable} this - * @param {Ext.EventObject} e The mousedown event - */ - 'beforeresize', - /** - * @event resize - * Fired after a resize. - * @param {Ext.Resizable} this - * @param {Number} width The new width - * @param {Number} height The new height - * @param {Ext.EventObject} e The mouseup event - */ - 'resize' - ); - - if(this.width !== null && this.height !== null){ - this.resizeTo(this.width, this.height); - }else{ - this.updateChildSize(); - } - if(Ext.isIE){ - this.el.dom.style.zoom = 1; - } - Ext.Resizable.superclass.constructor.call(this); - }, - - /** - * @cfg {Array/String} adjustments String 'auto' or an array [width, height] with values to be added to the - * resize operation's new size (defaults to [0, 0]) - */ - adjustments : [0, 0], - /** - * @cfg {Boolean} animate True to animate the resize (not compatible with dynamic sizing, defaults to false) - */ - animate : false, - /** - * @cfg {Mixed} constrainTo Constrain the resize to a particular element - */ - /** - * @cfg {Boolean} disableTrackOver True to disable mouse tracking. This is only applied at config time. (defaults to false) - */ - disableTrackOver : false, - /** - * @cfg {Boolean} draggable Convenience to initialize drag drop (defaults to false) - */ - draggable: false, - /** - * @cfg {Number} duration Animation duration if animate = true (defaults to 0.35) - */ - duration : 0.35, - /** - * @cfg {Boolean} dynamic True to resize the element while dragging instead of using a proxy (defaults to false) - */ - dynamic : false, - /** - * @cfg {String} easing Animation easing if animate = true (defaults to 'easingOutStrong') - */ - easing : 'easeOutStrong', - /** - * @cfg {Boolean} enabled False to disable resizing (defaults to true) - */ - enabled : true, - /** - * @property enabled Writable. False if resizing is disabled. - * @type Boolean - */ - /** - * @cfg {String} handles String consisting of the resize handles to display (defaults to undefined). - * Specify either 'all' or any of 'n s e w ne nw se sw'. - */ - handles : false, - /** - * @cfg {Boolean} multiDirectional Deprecated. Deprecated style of adding multi-direction resize handles. - */ - multiDirectional : false, - /** - * @cfg {Number} height The height of the element in pixels (defaults to null) - */ - height : null, - /** - * @cfg {Number} width The width of the element in pixels (defaults to null) - */ - width : null, - /** - * @cfg {Number} heightIncrement The increment to snap the height resize in pixels - * (only applies if {@link #dynamic}==true). Defaults to 0. - */ - heightIncrement : 0, - /** - * @cfg {Number} widthIncrement The increment to snap the width resize in pixels - * (only applies if {@link #dynamic}==true). Defaults to 0. - */ - widthIncrement : 0, - /** - * @cfg {Number} minHeight The minimum height for the element (defaults to 5) - */ - minHeight : 5, - /** - * @cfg {Number} minWidth The minimum width for the element (defaults to 5) - */ - minWidth : 5, - /** - * @cfg {Number} maxHeight The maximum height for the element (defaults to 10000) - */ - maxHeight : 10000, - /** - * @cfg {Number} maxWidth The maximum width for the element (defaults to 10000) - */ - maxWidth : 10000, - /** - * @cfg {Number} minX The minimum x for the element (defaults to 0) - */ - minX: 0, - /** - * @cfg {Number} minY The minimum x for the element (defaults to 0) - */ - minY: 0, - /** - * @cfg {Boolean} pinned True to ensure that the resize handles are always visible, false to display them only when the - * user mouses over the resizable borders. This is only applied at config time. (defaults to false) - */ - pinned : false, - /** - * @cfg {Boolean} preserveRatio True to preserve the original ratio between height - * and width during resize (defaults to false) - */ - preserveRatio : false, - /** - * @cfg {Boolean/String/Element} resizeChild True to resize the first child, or id/element to resize (defaults to false) - */ - resizeChild : false, - /** - * @cfg {Boolean} transparent True for transparent handles. This is only applied at config time. (defaults to false) - */ - transparent: false, - /** - * @cfg {Ext.lib.Region} resizeRegion Constrain the resize to a particular region - */ - /** - * @cfg {Boolean} wrap True to wrap an element with a div if needed (required for textareas and images, defaults to false) - * in favor of the handles config option (defaults to false) - */ - /** - * @cfg {String} handleCls A css class to add to each handle. Defaults to ''. - */ - - - /** - * Perform a manual resize and fires the 'resize' event. - * @param {Number} width - * @param {Number} height - */ - resizeTo : function(width, height){ - this.el.setSize(width, height); - this.updateChildSize(); - this.fireEvent('resize', this, width, height, null); - }, - - // private - startSizing : function(e, handle){ - this.fireEvent('beforeresize', this, e); - if(this.enabled){ // 2nd enabled check in case disabled before beforeresize handler - - if(!this.overlay){ - this.overlay = this.el.createProxy({tag: 'div', cls: 'x-resizable-overlay', html: ' '}, Ext.getBody()); - this.overlay.unselectable(); - this.overlay.enableDisplayMode('block'); - this.overlay.on({ - scope: this, - mousemove: this.onMouseMove, - mouseup: this.onMouseUp - }); - } - this.overlay.setStyle('cursor', handle.el.getStyle('cursor')); - - this.resizing = true; - this.startBox = this.el.getBox(); - this.startPoint = e.getXY(); - this.offsets = [(this.startBox.x + this.startBox.width) - this.startPoint[0], - (this.startBox.y + this.startBox.height) - this.startPoint[1]]; - - this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); - this.overlay.show(); - - if(this.constrainTo) { - var ct = Ext.get(this.constrainTo); - this.resizeRegion = ct.getRegion().adjust( - ct.getFrameWidth('t'), - ct.getFrameWidth('l'), - -ct.getFrameWidth('b'), - -ct.getFrameWidth('r') - ); - } - - this.proxy.setStyle('visibility', 'hidden'); // workaround display none - this.proxy.show(); - this.proxy.setBox(this.startBox); - if(!this.dynamic){ - this.proxy.setStyle('visibility', 'visible'); - } - } - }, - - // private - onMouseDown : function(handle, e){ - if(this.enabled){ - e.stopEvent(); - this.activeHandle = handle; - this.startSizing(e, handle); - } - }, - - // private - onMouseUp : function(e){ - this.activeHandle = null; - var size = this.resizeElement(); - this.resizing = false; - this.handleOut(); - this.overlay.hide(); - this.proxy.hide(); - this.fireEvent('resize', this, size.width, size.height, e); - }, - - // private - updateChildSize : function(){ - if(this.resizeChild){ - var el = this.el; - var child = this.resizeChild; - var adj = this.adjustments; - if(el.dom.offsetWidth){ - var b = el.getSize(true); - child.setSize(b.width+adj[0], b.height+adj[1]); - } - // Second call here for IE - // The first call enables instant resizing and - // the second call corrects scroll bars if they - // exist - if(Ext.isIE){ - setTimeout(function(){ - if(el.dom.offsetWidth){ - var b = el.getSize(true); - child.setSize(b.width+adj[0], b.height+adj[1]); - } - }, 10); - } - } - }, - - // private - snap : function(value, inc, min){ - if(!inc || !value){ - return value; - } - var newValue = value; - var m = value % inc; - if(m > 0){ - if(m > (inc/2)){ - newValue = value + (inc-m); - }else{ - newValue = value - m; - } - } - return Math.max(min, newValue); - }, - - /** - * Performs resizing of the associated Element. This method is called internally by this - * class, and should not be called by user code. - * If a Resizable is being used to resize an Element which encapsulates a more complex UI - * component such as a Panel, this method may be overridden by specifying an implementation - * as a config option to provide appropriate behaviour at the end of the resize operation on - * mouseup, for example resizing the Panel, and relaying the Panel's content. - * The new area to be resized to is available by examining the state of the {@link #proxy} - * Element. Example: - -new Ext.Panel({ - title: 'Resize me', - x: 100, - y: 100, - renderTo: Ext.getBody(), - floating: true, - frame: true, - width: 400, - height: 200, - listeners: { - render: function(p) { - new Ext.Resizable(p.getEl(), { - handles: 'all', - pinned: true, - transparent: true, - resizeElement: function() { - var box = this.proxy.getBox(); - p.updateBox(box); - if (p.layout) { - p.doLayout(); - } - return box; - } - }); - } - } -}).show(); - - */ - resizeElement : function(){ - var box = this.proxy.getBox(); - if(this.updateBox){ - this.el.setBox(box, false, this.animate, this.duration, null, this.easing); - }else{ - this.el.setSize(box.width, box.height, this.animate, this.duration, null, this.easing); - } - this.updateChildSize(); - if(!this.dynamic){ - this.proxy.hide(); - } - if(this.draggable && this.constrainTo){ - this.dd.resetConstraints(); - this.dd.constrainTo(this.constrainTo); - } - return box; - }, - - // private - constrain : function(v, diff, m, mx){ - if(v - diff < m){ - diff = v - m; - }else if(v - diff > mx){ - diff = v - mx; - } - return diff; - }, - - // private - onMouseMove : function(e){ - if(this.enabled && this.activeHandle){ - try{// try catch so if something goes wrong the user doesn't get hung - - if(this.resizeRegion && !this.resizeRegion.contains(e.getPoint())) { - return; - } - - //var curXY = this.startPoint; - var curSize = this.curSize || this.startBox, - x = this.startBox.x, y = this.startBox.y, - ox = x, - oy = y, - w = curSize.width, - h = curSize.height, - ow = w, - oh = h, - mw = this.minWidth, - mh = this.minHeight, - mxw = this.maxWidth, - mxh = this.maxHeight, - wi = this.widthIncrement, - hi = this.heightIncrement, - eventXY = e.getXY(), - diffX = -(this.startPoint[0] - Math.max(this.minX, eventXY[0])), - diffY = -(this.startPoint[1] - Math.max(this.minY, eventXY[1])), - pos = this.activeHandle.position, - tw, - th; - - switch(pos){ - case 'east': - w += diffX; - w = Math.min(Math.max(mw, w), mxw); - break; - case 'south': - h += diffY; - h = Math.min(Math.max(mh, h), mxh); - break; - case 'southeast': - w += diffX; - h += diffY; - w = Math.min(Math.max(mw, w), mxw); - h = Math.min(Math.max(mh, h), mxh); - break; - case 'north': - diffY = this.constrain(h, diffY, mh, mxh); - y += diffY; - h -= diffY; - break; - case 'west': - diffX = this.constrain(w, diffX, mw, mxw); - x += diffX; - w -= diffX; - break; - case 'northeast': - w += diffX; - w = Math.min(Math.max(mw, w), mxw); - diffY = this.constrain(h, diffY, mh, mxh); - y += diffY; - h -= diffY; - break; - case 'northwest': - diffX = this.constrain(w, diffX, mw, mxw); - diffY = this.constrain(h, diffY, mh, mxh); - y += diffY; - h -= diffY; - x += diffX; - w -= diffX; - break; - case 'southwest': - diffX = this.constrain(w, diffX, mw, mxw); - h += diffY; - h = Math.min(Math.max(mh, h), mxh); - x += diffX; - w -= diffX; - break; - } - - var sw = this.snap(w, wi, mw); - var sh = this.snap(h, hi, mh); - if(sw != w || sh != h){ - switch(pos){ - case 'northeast': - y -= sh - h; - break; - case 'north': - y -= sh - h; - break; - case 'southwest': - x -= sw - w; - break; - case 'west': - x -= sw - w; - break; - case 'northwest': - x -= sw - w; - y -= sh - h; - break; - } - w = sw; - h = sh; - } - - if(this.preserveRatio){ - switch(pos){ - case 'southeast': - case 'east': - h = oh * (w/ow); - h = Math.min(Math.max(mh, h), mxh); - w = ow * (h/oh); - break; - case 'south': - w = ow * (h/oh); - w = Math.min(Math.max(mw, w), mxw); - h = oh * (w/ow); - break; - case 'northeast': - w = ow * (h/oh); - w = Math.min(Math.max(mw, w), mxw); - h = oh * (w/ow); - break; - case 'north': - tw = w; - w = ow * (h/oh); - w = Math.min(Math.max(mw, w), mxw); - h = oh * (w/ow); - x += (tw - w) / 2; - break; - case 'southwest': - h = oh * (w/ow); - h = Math.min(Math.max(mh, h), mxh); - tw = w; - w = ow * (h/oh); - x += tw - w; - break; - case 'west': - th = h; - h = oh * (w/ow); - h = Math.min(Math.max(mh, h), mxh); - y += (th - h) / 2; - tw = w; - w = ow * (h/oh); - x += tw - w; - break; - case 'northwest': - tw = w; - th = h; - h = oh * (w/ow); - h = Math.min(Math.max(mh, h), mxh); - w = ow * (h/oh); - y += th - h; - x += tw - w; - break; - - } - } - this.proxy.setBounds(x, y, w, h); - if(this.dynamic){ - this.resizeElement(); - } - }catch(ex){} - } - }, - - // private - handleOver : function(){ - if(this.enabled){ - this.el.addClass('x-resizable-over'); - } - }, - - // private - handleOut : function(){ - if(!this.resizing){ - this.el.removeClass('x-resizable-over'); - } - }, - - /** - * Returns the element this component is bound to. - * @return {Ext.Element} - */ - getEl : function(){ - return this.el; - }, - - /** - * Returns the resizeChild element (or null). - * @return {Ext.Element} - */ - getResizeChild : function(){ - return this.resizeChild; - }, - - /** - * Destroys this resizable. If the element was wrapped and - * removeEl is not true then the element remains. - * @param {Boolean} removeEl (optional) true to remove the element from the DOM - */ - destroy : function(removeEl){ - Ext.destroy(this.dd, this.overlay, this.proxy); - this.overlay = null; - this.proxy = null; - - var ps = Ext.Resizable.positions; - for(var k in ps){ - if(typeof ps[k] != 'function' && this[ps[k]]){ - this[ps[k]].destroy(); - } - } - if(removeEl){ - this.el.update(''); - Ext.destroy(this.el); - this.el = null; - } - this.purgeListeners(); - }, - - syncHandleHeight : function(){ - var h = this.el.getHeight(true); - if(this.west){ - this.west.el.setHeight(h); - } - if(this.east){ - this.east.el.setHeight(h); - } - } -}); - -// private -// hash to map config positions to true positions -Ext.Resizable.positions = { - n: 'north', s: 'south', e: 'east', w: 'west', se: 'southeast', sw: 'southwest', nw: 'northwest', ne: 'northeast' -}; - -Ext.Resizable.Handle = Ext.extend(Object, { - constructor : function(rz, pos, disableTrackOver, transparent, cls){ - if(!this.tpl){ - // only initialize the template if resizable is used - var tpl = Ext.DomHelper.createTemplate( - {tag: 'div', cls: 'x-resizable-handle x-resizable-handle-{0}'} - ); - tpl.compile(); - Ext.Resizable.Handle.prototype.tpl = tpl; - } - this.position = pos; - this.rz = rz; - this.el = this.tpl.append(rz.el.dom, [this.position], true); - this.el.unselectable(); - if(transparent){ - this.el.setOpacity(0); - } - if(!Ext.isEmpty(cls)){ - this.el.addClass(cls); - } - this.el.on('mousedown', this.onMouseDown, this); - if(!disableTrackOver){ - this.el.on({ - scope: this, - mouseover: this.onMouseOver, - mouseout: this.onMouseOut - }); - } - }, - - // private - afterResize : function(rz){ - // do nothing - }, - // private - onMouseDown : function(e){ - this.rz.onMouseDown(this, e); - }, - // private - onMouseOver : function(e){ - this.rz.handleOver(this, e); - }, - // private - onMouseOut : function(e){ - this.rz.handleOut(this, e); - }, - // private - destroy : function(){ - Ext.destroy(this.el); - this.el = null; - } -}); +}); + /** - * @class Ext.Window - * @extends Ext.Panel - * A specialized panel intended for use as an application window. Windows are floated, {@link #resizable}, and - * {@link #draggable} by default. Windows can be {@link #maximizable maximized} to fill the viewport, - * restored to their prior size, and can be {@link #minimize}d. - * Windows can also be linked to a {@link Ext.WindowGroup} or managed by the {@link Ext.WindowMgr} to provide - * grouping, activation, to front, to back and other application-specific behavior. - * By default, Windows will be rendered to document.body. To {@link #constrain} a Window to another element - * specify {@link Ext.Component#renderTo renderTo}. - * Note: By default, the {@link #closable close} header tool destroys the Window resulting in - * destruction of any child Components. This makes the Window object, and all its descendants unusable. To enable - * re-use of a Window, use {@link #closeAction closeAction: 'hide'}. - * @constructor - * @param {Object} config The config object - * @xtype window + * @class Ext.tree.MultiSelectionModel + * @extends Ext.util.Observable + * Multi selection for a TreePanel. */ -Ext.Window = Ext.extend(Ext.Panel, { - /** - * @cfg {Number} x - * The X position of the left edge of the window on initial showing. Defaults to centering the Window within - * the width of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to). - */ +Ext.tree.MultiSelectionModel = function(config){ + this.selNodes = []; + this.selMap = {}; + this.addEvents( + /** + * @event selectionchange + * Fires when the selected nodes change + * @param {MultiSelectionModel} this + * @param {Array} nodes Array of the selected nodes + */ + 'selectionchange' + ); + Ext.apply(this, config); + Ext.tree.MultiSelectionModel.superclass.constructor.call(this); +}; + +Ext.extend(Ext.tree.MultiSelectionModel, Ext.util.Observable, { + init : function(tree){ + this.tree = tree; + tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); + tree.on('click', this.onNodeClick, this); + }, + + onNodeClick : function(node, e){ + if(e.ctrlKey && this.isSelected(node)){ + this.unselect(node); + }else{ + this.select(node, e, e.ctrlKey); + } + }, + /** - * @cfg {Number} y - * The Y position of the top edge of the window on initial showing. Defaults to centering the Window within - * the height of the Window's container {@link Ext.Element Element) (The Element that the Window is rendered to). + * Select a node. + * @param {TreeNode} node The node to select + * @param {EventObject} e (optional) An event associated with the selection + * @param {Boolean} keepExisting True to retain existing selections + * @return {TreeNode} The selected node */ + select : function(node, e, keepExisting){ + if(keepExisting !== true){ + this.clearSelections(true); + } + if(this.isSelected(node)){ + this.lastSelNode = node; + return node; + } + this.selNodes.push(node); + this.selMap[node.id] = node; + this.lastSelNode = node; + node.ui.onSelectedChange(true); + this.fireEvent('selectionchange', this, this.selNodes); + return node; + }, + /** - * @cfg {Boolean} modal - * True to make the window modal and mask everything behind it when displayed, false to display it without - * restricting access to other UI elements (defaults to false). + * Deselect a node. + * @param {TreeNode} node The node to unselect */ + unselect : function(node){ + if(this.selMap[node.id]){ + node.ui.onSelectedChange(false); + var sn = this.selNodes; + var index = sn.indexOf(node); + if(index != -1){ + this.selNodes.splice(index, 1); + } + delete this.selMap[node.id]; + this.fireEvent('selectionchange', this, this.selNodes); + } + }, + /** - * @cfg {String/Element} animateTarget - * Id or element from which the window should animate while opening (defaults to null with no animation). + * Clear all selections */ + clearSelections : function(suppressEvent){ + var sn = this.selNodes; + if(sn.length > 0){ + for(var i = 0, len = sn.length; i < len; i++){ + sn[i].ui.onSelectedChange(false); + } + this.selNodes = []; + this.selMap = {}; + if(suppressEvent !== true){ + this.fireEvent('selectionchange', this, this.selNodes); + } + } + }, + /** - * @cfg {String} resizeHandles - * A valid {@link Ext.Resizable} handles config string (defaults to 'all'). Only applies when resizable = true. + * Returns true if the node is selected + * @param {TreeNode} node The node to check + * @return {Boolean} */ + isSelected : function(node){ + return this.selMap[node.id] ? true : false; + }, + /** - * @cfg {Ext.WindowGroup} manager - * A reference to the WindowGroup that should manage this window (defaults to {@link Ext.WindowMgr}). + * Returns an array of the selected nodes + * @return {Array} */ - /** - * @cfg {String/Number/Component} defaultButton - * Specifies a Component to receive focus when this Window is focussed. - * This may be one of: - * The index of a footer Button. - * The id of a Component. - * A Component. - * - */ - /** - * @cfg {Function} onEsc - * Allows override of the built-in processing for the escape key. Default action - * is to close the Window (performing whatever action is specified in {@link #closeAction}. - * To prevent the Window closing when the escape key is pressed, specify this as - * Ext.emptyFn (See {@link Ext#emptyFn}). + getSelectedNodes : function(){ + return this.selNodes; + }, + + onKeyDown : Ext.tree.DefaultSelectionModel.prototype.onKeyDown, + + selectNext : Ext.tree.DefaultSelectionModel.prototype.selectNext, + + selectPrevious : Ext.tree.DefaultSelectionModel.prototype.selectPrevious +});/** + * @class Ext.data.Tree + * @extends Ext.util.Observable + * Represents a tree data structure and bubbles all the events for its nodes. The nodes + * in the tree have most standard DOM functionality. + * @constructor + * @param {Node} root (optional) The root node + */ +Ext.data.Tree = function(root){ + this.nodeHash = {}; + /** + * The root node for this tree + * @type Node */ + this.root = null; + if(root){ + this.setRootNode(root); + } + this.addEvents( + /** + * @event append + * Fires when a new child node is appended to a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The newly appended node + * @param {Number} index The index of the newly appended node + */ + "append", + /** + * @event remove + * Fires when a child node is removed from a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node removed + */ + "remove", + /** + * @event move + * Fires when a node is moved to a new location in the tree + * @param {Tree} tree The owner tree + * @param {Node} node The node moved + * @param {Node} oldParent The old parent of this node + * @param {Node} newParent The new parent of this node + * @param {Number} index The index it was moved to + */ + "move", + /** + * @event insert + * Fires when a new child node is inserted in a node in this tree. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node inserted + * @param {Node} refNode The child node the node was inserted before + */ + "insert", + /** + * @event beforeappend + * Fires before a new child is appended to a node in this tree, return false to cancel the append. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be appended + */ + "beforeappend", + /** + * @event beforeremove + * Fires before a child is removed from a node in this tree, return false to cancel the remove. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be removed + */ + "beforeremove", + /** + * @event beforemove + * Fires before a node is moved to a new location in the tree. Return false to cancel the move. + * @param {Tree} tree The owner tree + * @param {Node} node The node being moved + * @param {Node} oldParent The parent of the node + * @param {Node} newParent The new parent the node is moving to + * @param {Number} index The index it is being moved to + */ + "beforemove", + /** + * @event beforeinsert + * Fires before a new child is inserted in a node in this tree, return false to cancel the insert. + * @param {Tree} tree The owner tree + * @param {Node} parent The parent node + * @param {Node} node The child node to be inserted + * @param {Node} refNode The child node the node is being inserted before + */ + "beforeinsert" + ); + + Ext.data.Tree.superclass.constructor.call(this); +}; + +Ext.extend(Ext.data.Tree, Ext.util.Observable, { /** - * @cfg {Boolean} collapsed - * True to render the window collapsed, false to render it expanded (defaults to false). Note that if - * {@link #expandOnShow} is true (the default) it will override the collapsed config and the window - * will always be expanded when shown. + * @cfg {String} pathSeparator + * The token used to separate paths in node ids (defaults to '/'). */ + pathSeparator: "/", + + // private + proxyNodeEvent : function(){ + return this.fireEvent.apply(this, arguments); + }, + /** - * @cfg {Boolean} maximized - * True to initially display the window in a maximized state. (Defaults to false). + * Returns the root node for this tree. + * @return {Node} */ + getRootNode : function(){ + return this.root; + }, /** - * @cfg {String} baseCls - * The base CSS class to apply to this panel's element (defaults to 'x-window'). - */ - baseCls : 'x-window', + * Sets the root node for this tree. + * @param {Node} node + * @return {Node} + */ + setRootNode : function(node){ + this.root = node; + node.ownerTree = this; + node.isRoot = true; + this.registerNode(node); + return node; + }, + /** - * @cfg {Boolean} resizable - * True to allow user resizing at each edge and corner of the window, false to disable resizing (defaults to true). + * Gets a node in this tree by its id. + * @param {String} id + * @return {Node} */ - resizable : true, + getNodeById : function(id){ + return this.nodeHash[id]; + }, + + // private + registerNode : function(node){ + this.nodeHash[node.id] = node; + }, + + // private + unregisterNode : function(node){ + delete this.nodeHash[node.id]; + }, + + toString : function(){ + return "[Tree"+(this.id?" "+this.id:"")+"]"; + } +}); + +/** + * @class Ext.data.Node + * @extends Ext.util.Observable + * @cfg {Boolean} leaf true if this node is a leaf and does not have children + * @cfg {String} id The id for this node. If one is not specified, one is generated. + * @constructor + * @param {Object} attributes The attributes/config for the node + */ +Ext.data.Node = function(attributes){ /** - * @cfg {Boolean} draggable - * True to allow the window to be dragged by the header bar, false to disable dragging (defaults to true). Note - * that by default the window will be centered in the viewport, so if dragging is disabled the window may need - * to be positioned programmatically after render (e.g., myWindow.setPosition(100, 100);). + * The attributes supplied for the node. You can use this property to access any custom attributes you supplied. + * @type {Object} */ - draggable : true, + this.attributes = attributes || {}; + this.leaf = this.attributes.leaf; /** - * @cfg {Boolean} closable - * True to display the 'close' tool button and allow the user to close the window, false to - * hide the button and disallow closing the window (defaults to true). - * By default, when close is requested by either clicking the close button in the header - * or pressing ESC when the Window has focus, the {@link #close} method will be called. This - * will {@link Ext.Component#destroy destroy} the Window and its content meaning that - * it may not be reused. - * To make closing a Window hide the Window so that it may be reused, set - * {@link #closeAction} to 'hide'. + * The node id. @type String */ - closable : true, + this.id = this.attributes.id; + if(!this.id){ + this.id = Ext.id(null, "xnode-"); + this.attributes.id = this.id; + } /** - * @cfg {String} closeAction - * The action to take when the close header tool is clicked: - * - * '{@link #close}' : Default - * {@link #close remove} the window from the DOM and {@link Ext.Component#destroy destroy} - * it and all descendant Components. The window will not be available to be - * redisplayed via the {@link #show} method. - * - * '{@link #hide}' : - * {@link #hide} the window by setting visibility to hidden and applying negative offsets. - * The window will be available to be redisplayed via the {@link #show} method. - * - * - * Note: This setting does not affect the {@link #close} method - * which will always {@link Ext.Component#destroy destroy} the window. To - * programatically hide a window, call {@link #hide}. + * All child nodes of this node. @type Array */ - closeAction : 'close', + this.childNodes = []; + if(!this.childNodes.indexOf){ // indexOf is a must + this.childNodes.indexOf = function(o){ + for(var i = 0, len = this.length; i < len; i++){ + if(this[i] == o){ + return i; + } + } + return -1; + }; + } /** - * @cfg {Boolean} constrain - * True to constrain the window within its containing element, false to allow it to fall outside of its - * containing element. By default the window will be rendered to document.body. To render and constrain the - * window within another element specify {@link #renderTo}. - * (defaults to false). Optionally the header only can be constrained using {@link #constrainHeader}. + * The parent node for this node. @type Node */ - constrain : false, + this.parentNode = null; /** - * @cfg {Boolean} constrainHeader - * True to constrain the window header within its containing element (allowing the window body to fall outside - * of its containing element) or false to allow the header to fall outside its containing element (defaults to - * false). Optionally the entire window can be constrained using {@link #constrain}. + * The first direct child node of this node, or null if this node has no child nodes. @type Node */ - constrainHeader : false, + this.firstChild = null; /** - * @cfg {Boolean} plain - * True to render the window body with a transparent background so that it will blend into the framing - * elements, false to add a lighter background color to visually highlight the body element and separate it - * more distinctly from the surrounding frame (defaults to false). + * The last direct child node of this node, or null if this node has no child nodes. @type Node */ - plain : false, + this.lastChild = null; /** - * @cfg {Boolean} minimizable - * True to display the 'minimize' tool button and allow the user to minimize the window, false to hide the button - * and disallow minimizing the window (defaults to false). Note that this button provides no implementation -- - * the behavior of minimizing a window is implementation-specific, so the minimize event must be handled and a - * custom minimize behavior implemented for this option to be useful. + * The node immediately preceding this node in the tree, or null if there is no sibling node. @type Node */ - minimizable : false, + this.previousSibling = null; /** - * @cfg {Boolean} maximizable - * True to display the 'maximize' tool button and allow the user to maximize the window, false to hide the button - * and disallow maximizing the window (defaults to false). Note that when a window is maximized, the tool button - * will automatically change to a 'restore' button with the appropriate behavior already built-in that will - * restore the window to its previous size. + * The node immediately following this node in the tree, or null if there is no sibling node. @type Node */ - maximizable : false, + this.nextSibling = null; + + this.addEvents({ + /** + * @event append + * Fires when a new child node is appended + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The newly appended node + * @param {Number} index The index of the newly appended node + */ + "append" : true, + /** + * @event remove + * Fires when a child node is removed + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The removed node + */ + "remove" : true, + /** + * @event move + * Fires when this node is moved to a new location in the tree + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} oldParent The old parent of this node + * @param {Node} newParent The new parent of this node + * @param {Number} index The index it was moved to + */ + "move" : true, + /** + * @event insert + * Fires when a new child node is inserted. + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The child node inserted + * @param {Node} refNode The child node the node was inserted before + */ + "insert" : true, + /** + * @event beforeappend + * Fires before a new child is appended, return false to cancel the append. + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The child node to be appended + */ + "beforeappend" : true, + /** + * @event beforeremove + * Fires before a child is removed, return false to cancel the remove. + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The child node to be removed + */ + "beforeremove" : true, + /** + * @event beforemove + * Fires before this node is moved to a new location in the tree. Return false to cancel the move. + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} oldParent The parent of this node + * @param {Node} newParent The new parent this node is moving to + * @param {Number} index The index it is being moved to + */ + "beforemove" : true, + /** + * @event beforeinsert + * Fires before a new child is inserted, return false to cancel the insert. + * @param {Tree} tree The owner tree + * @param {Node} this This node + * @param {Node} node The child node to be inserted + * @param {Node} refNode The child node the node is being inserted before + */ + "beforeinsert" : true + }); + this.listeners = this.attributes.listeners; + Ext.data.Node.superclass.constructor.call(this); +}; + +Ext.extend(Ext.data.Node, Ext.util.Observable, { + // private + fireEvent : function(evtName){ + // first do standard event for this node + if(Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false){ + return false; + } + // then bubble it up to the tree if the event wasn't cancelled + var ot = this.getOwnerTree(); + if(ot){ + if(ot.proxyNodeEvent.apply(ot, arguments) === false){ + return false; + } + } + return true; + }, + /** - * @cfg {Number} minHeight - * The minimum height in pixels allowed for this window (defaults to 100). Only applies when resizable = true. + * Returns true if this node is a leaf + * @return {Boolean} */ - minHeight : 100, + isLeaf : function(){ + return this.leaf === true; + }, + + // private + setFirstChild : function(node){ + this.firstChild = node; + }, + + //private + setLastChild : function(node){ + this.lastChild = node; + }, + + /** - * @cfg {Number} minWidth - * The minimum width in pixels allowed for this window (defaults to 200). Only applies when resizable = true. + * Returns true if this node is the last child of its parent + * @return {Boolean} */ - minWidth : 200, + isLast : function(){ + return (!this.parentNode ? true : this.parentNode.lastChild == this); + }, + /** - * @cfg {Boolean} expandOnShow - * True to always expand the window when it is displayed, false to keep it in its current state (which may be - * {@link #collapsed}) when displayed (defaults to true). + * Returns true if this node is the first child of its parent + * @return {Boolean} + */ + isFirst : function(){ + return (!this.parentNode ? true : this.parentNode.firstChild == this); + }, + + /** + * Returns true if this node has one or more child nodes, else false. + * @return {Boolean} */ - expandOnShow : true, + hasChildNodes : function(){ + return !this.isLeaf() && this.childNodes.length > 0; + }, - // inherited docs, same default - collapsible : false, + /** + * Returns true if this node has one or more child nodes, or if the expandable + * node attribute is explicitly specified as true (see {@link #attributes}), otherwise returns false. + * @return {Boolean} + */ + isExpandable : function(){ + return this.attributes.expandable || this.hasChildNodes(); + }, /** - * @cfg {Boolean} initHidden - * True to hide the window until show() is explicitly called (defaults to true). - * @deprecated + * Insert node(s) as the last child node of this node. + * @param {Node/Array} node The node or Array of nodes to append + * @return {Node} The appended node if single append, or null if an array was passed */ - initHidden : undefined, + appendChild : function(node){ + var multi = false; + if(Ext.isArray(node)){ + multi = node; + }else if(arguments.length > 1){ + multi = arguments; + } + // if passed an array or multiple args do them one by one + if(multi){ + for(var i = 0, len = multi.length; i < len; i++) { + this.appendChild(multi[i]); + } + }else{ + if(this.fireEvent("beforeappend", this.ownerTree, this, node) === false){ + return false; + } + var index = this.childNodes.length; + var oldParent = node.parentNode; + // it's a move, make sure we move it cleanly + if(oldParent){ + if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index) === false){ + return false; + } + oldParent.removeChild(node); + } + index = this.childNodes.length; + if(index === 0){ + this.setFirstChild(node); + } + this.childNodes.push(node); + node.parentNode = this; + var ps = this.childNodes[index-1]; + if(ps){ + node.previousSibling = ps; + ps.nextSibling = node; + }else{ + node.previousSibling = null; + } + node.nextSibling = null; + this.setLastChild(node); + node.setOwnerTree(this.getOwnerTree()); + this.fireEvent("append", this.ownerTree, this, node, index); + if(oldParent){ + node.fireEvent("move", this.ownerTree, node, oldParent, this, index); + } + return node; + } + }, /** - * @cfg {Boolean} hidden - * Render this component hidden (default is true). If true, the - * {@link #hide} method will be called internally. + * Removes a child node from this node. + * @param {Node} node The node to remove + * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. + * @return {Node} The removed node */ - hidden : true, + removeChild : function(node, destroy){ + var index = this.childNodes.indexOf(node); + if(index == -1){ + return false; + } + if(this.fireEvent("beforeremove", this.ownerTree, this, node) === false){ + return false; + } - // The following configs are set to provide the basic functionality of a window. - // Changing them would require additional code to handle correctly and should - // usually only be done in subclasses that can provide custom behavior. Changing them - // may have unexpected or undesirable results. - /** @cfg {String} elements @hide */ - elements : 'header,body', - /** @cfg {Boolean} frame @hide */ - frame : true, - /** @cfg {Boolean} floating @hide */ - floating : true, + // remove it from childNodes collection + this.childNodes.splice(index, 1); - // private - initComponent : function(){ - this.initTools(); - Ext.Window.superclass.initComponent.call(this); - this.addEvents( - /** - * @event activate - * Fires after the window has been visually activated via {@link #setActive}. - * @param {Ext.Window} this - */ - /** - * @event deactivate - * Fires after the window has been visually deactivated via {@link #setActive}. - * @param {Ext.Window} this - */ - /** - * @event resize - * Fires after the window has been resized. - * @param {Ext.Window} this - * @param {Number} width The window's new width - * @param {Number} height The window's new height - */ - 'resize', - /** - * @event maximize - * Fires after the window has been maximized. - * @param {Ext.Window} this - */ - 'maximize', - /** - * @event minimize - * Fires after the window has been minimized. - * @param {Ext.Window} this - */ - 'minimize', - /** - * @event restore - * Fires after the window has been restored to its original size after being maximized. - * @param {Ext.Window} this - */ - 'restore' - ); - // for backwards compat, this should be removed at some point - if(Ext.isDefined(this.initHidden)){ - this.hidden = this.initHidden; + // update siblings + if(node.previousSibling){ + node.previousSibling.nextSibling = node.nextSibling; } - if(this.hidden === false){ - this.hidden = true; - this.show(); + if(node.nextSibling){ + node.nextSibling.previousSibling = node.previousSibling; + } + + // update child refs + if(this.firstChild == node){ + this.setFirstChild(node.nextSibling); + } + if(this.lastChild == node){ + this.setLastChild(node.previousSibling); } + + this.fireEvent("remove", this.ownerTree, this, node); + if(destroy){ + node.destroy(true); + }else{ + node.clear(); + } + return node; }, // private - getState : function(){ - return Ext.apply(Ext.Window.superclass.getState.call(this) || {}, this.getBox(true)); + clear : function(destroy){ + // clear any references from the node + this.setOwnerTree(null, destroy); + this.parentNode = this.previousSibling = this.nextSibling = null; + if(destroy){ + this.firstChild = this.lastChild = null; + } }, - // private - onRender : function(ct, position){ - Ext.Window.superclass.onRender.call(this, ct, position); + /** + * Destroys the node. + */ + destroy : function(/* private */ silent){ + /* + * Silent is to be used in a number of cases + * 1) When setRootNode is called. + * 2) When destroy on the tree is called + * 3) For destroying child nodes on a node + */ + if(silent === true){ + this.purgeListeners(); + this.clear(true); + Ext.each(this.childNodes, function(n){ + n.destroy(true); + }); + this.childNodes = null; + }else{ + this.remove(true); + } + }, - if(this.plain){ - this.el.addClass('x-window-plain'); + /** + * Inserts the first node before the second node in this nodes childNodes collection. + * @param {Node} node The node to insert + * @param {Node} refNode The node to insert before (if null the node is appended) + * @return {Node} The inserted node + */ + insertBefore : function(node, refNode){ + if(!refNode){ // like standard Dom, refNode can be null for append + return this.appendChild(node); + } + // nothing to do + if(node == refNode){ + return false; } - // this element allows the Window to be focused for keyboard events - this.focusEl = this.el.createChild({ - tag: 'a', href:'#', cls:'x-dlg-focus', - tabIndex:'-1', html: ' '}); - this.focusEl.swallowEvent('click', true); + if(this.fireEvent("beforeinsert", this.ownerTree, this, node, refNode) === false){ + return false; + } + var index = this.childNodes.indexOf(refNode); + var oldParent = node.parentNode; + var refIndex = index; - this.proxy = this.el.createProxy('x-window-proxy'); - this.proxy.enableDisplayMode('block'); + // when moving internally, indexes will change after remove + if(oldParent == this && this.childNodes.indexOf(node) < index){ + refIndex--; + } - if(this.modal){ - this.mask = this.container.createChild({cls:'ext-el-mask'}, this.el.dom); - this.mask.enableDisplayMode('block'); - this.mask.hide(); - this.mon(this.mask, 'click', this.focus, this); + // it's a move, make sure we move it cleanly + if(oldParent){ + if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index, refNode) === false){ + return false; + } + oldParent.removeChild(node); } - if(this.maximizable){ - this.mon(this.header, 'dblclick', this.toggleMaximize, this); + if(refIndex === 0){ + this.setFirstChild(node); + } + this.childNodes.splice(refIndex, 0, node); + node.parentNode = this; + var ps = this.childNodes[refIndex-1]; + if(ps){ + node.previousSibling = ps; + ps.nextSibling = node; + }else{ + node.previousSibling = null; + } + node.nextSibling = refNode; + refNode.previousSibling = node; + node.setOwnerTree(this.getOwnerTree()); + this.fireEvent("insert", this.ownerTree, this, node, refNode); + if(oldParent){ + node.fireEvent("move", this.ownerTree, node, oldParent, this, refIndex, refNode); } + return node; }, - // private - initEvents : function(){ - Ext.Window.superclass.initEvents.call(this); - if(this.animateTarget){ - this.setAnimateTarget(this.animateTarget); + /** + * Removes this node from its parent + * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. + * @return {Node} this + */ + remove : function(destroy){ + if (this.parentNode) { + this.parentNode.removeChild(this, destroy); } + return this; + }, - if(this.resizable){ - this.resizer = new Ext.Resizable(this.el, { - minWidth: this.minWidth, - minHeight:this.minHeight, - handles: this.resizeHandles || 'all', - pinned: true, - resizeElement : this.resizerAction, - handleCls: 'x-window-handle' - }); - this.resizer.window = this; - this.mon(this.resizer, 'beforeresize', this.beforeResize, this); + /** + * Removes all child nodes from this node. + * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. + * @return {Node} this + */ + removeAll : function(destroy){ + var cn = this.childNodes, + n; + while((n = cn[0])){ + this.removeChild(n, destroy); } + return this; + }, - if(this.draggable){ - this.header.addClass('x-window-draggable'); - } - this.mon(this.el, 'mousedown', this.toFront, this); - this.manager = this.manager || Ext.WindowMgr; - this.manager.register(this); - if(this.maximized){ - this.maximized = false; - this.maximize(); - } - if(this.closable){ - var km = this.getKeyMap(); - km.on(27, this.onEsc, this); - km.disable(); - } + /** + * Returns the child node at the specified index. + * @param {Number} index + * @return {Node} + */ + item : function(index){ + return this.childNodes[index]; }, - initDraggable : function(){ - /** - * If this Window is configured {@link #draggable}, this property will contain - * an instance of {@link Ext.dd.DD} which handles dragging the Window's DOM Element. - * @type Ext.dd.DD - * @property dd - */ - this.dd = new Ext.Window.DD(this); + /** + * Replaces one child node in this node with another. + * @param {Node} newChild The replacement node + * @param {Node} oldChild The node to replace + * @return {Node} The replaced node + */ + replaceChild : function(newChild, oldChild){ + var s = oldChild ? oldChild.nextSibling : null; + this.removeChild(oldChild); + this.insertBefore(newChild, s); + return oldChild; }, - // private - onEsc : function(k, e){ - e.stopEvent(); - this[this.closeAction](); + /** + * Returns the index of a child node + * @param {Node} node + * @return {Number} The index of the node or -1 if it was not found + */ + indexOf : function(child){ + return this.childNodes.indexOf(child); }, - // private - beforeDestroy : function(){ - if (this.rendered){ - this.hide(); - if(this.doAnchor){ - Ext.EventManager.removeResizeListener(this.doAnchor, this); - Ext.EventManager.un(window, 'scroll', this.doAnchor, this); + /** + * Returns the tree this node is in. + * @return {Tree} + */ + getOwnerTree : function(){ + // if it doesn't have one, look for one + if(!this.ownerTree){ + var p = this; + while(p){ + if(p.ownerTree){ + this.ownerTree = p.ownerTree; + break; + } + p = p.parentNode; } - Ext.destroy( - this.focusEl, - this.resizer, - this.dd, - this.proxy, - this.mask - ); } - Ext.Window.superclass.beforeDestroy.call(this); + return this.ownerTree; + }, + + /** + * Returns depth of this node (the root node has a depth of 0) + * @return {Number} + */ + getDepth : function(){ + var depth = 0; + var p = this; + while(p.parentNode){ + ++depth; + p = p.parentNode; + } + return depth; }, // private - onDestroy : function(){ - if(this.manager){ - this.manager.unregister(this); + setOwnerTree : function(tree, destroy){ + // if it is a move, we need to update everyone + if(tree != this.ownerTree){ + if(this.ownerTree){ + this.ownerTree.unregisterNode(this); + } + this.ownerTree = tree; + // If we're destroying, we don't need to recurse since it will be called on each child node + if(destroy !== true){ + Ext.each(this.childNodes, function(n){ + n.setOwnerTree(tree); + }); + } + if(tree){ + tree.registerNode(this); + } + } + }, + + /** + * Changes the id of this node. + * @param {String} id The new id for the node. + */ + setId: function(id){ + if(id !== this.id){ + var t = this.ownerTree; + if(t){ + t.unregisterNode(this); + } + this.id = this.attributes.id = id; + if(t){ + t.registerNode(this); + } + this.onIdChange(id); } - Ext.Window.superclass.onDestroy.call(this); }, // private - initTools : function(){ - if(this.minimizable){ - this.addTool({ - id: 'minimize', - handler: this.minimize.createDelegate(this, []) - }); + onIdChange: Ext.emptyFn, + + /** + * Returns the path for this node. The path can be used to expand or select this node programmatically. + * @param {String} attr (optional) The attr to use for the path (defaults to the node's id) + * @return {String} The path + */ + getPath : function(attr){ + attr = attr || "id"; + var p = this.parentNode; + var b = [this.attributes[attr]]; + while(p){ + b.unshift(p.attributes[attr]); + p = p.parentNode; } - if(this.maximizable){ - this.addTool({ - id: 'maximize', - handler: this.maximize.createDelegate(this, []) - }); - this.addTool({ - id: 'restore', - handler: this.restore.createDelegate(this, []), - hidden:true - }); + var sep = this.getOwnerTree().pathSeparator; + return sep + b.join(sep); + }, + + /** + * Bubbles up the tree from this node, calling the specified function with each node. The arguments to the function + * will be the args provided or the current node. If the function returns false at any point, + * the bubble is stopped. + * @param {Function} fn The function to call + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. + * @param {Array} args (optional) The args to call the function with (default to passing the current Node) + */ + bubble : function(fn, scope, args){ + var p = this; + while(p){ + if(fn.apply(scope || p, args || [p]) === false){ + break; + } + p = p.parentNode; } - if(this.closable){ - this.addTool({ - id: 'close', - handler: this[this.closeAction].createDelegate(this, []) - }); + }, + + /** + * Cascades down the tree from this node, calling the specified function with each node. The arguments to the function + * will be the args provided or the current node. If the function returns false at any point, + * the cascade is stopped on that branch. + * @param {Function} fn The function to call + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. + * @param {Array} args (optional) The args to call the function with (default to passing the current Node) + */ + cascade : function(fn, scope, args){ + if(fn.apply(scope || this, args || [this]) !== false){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++) { + cs[i].cascade(fn, scope, args); + } } }, - // private - resizerAction : function(){ - var box = this.proxy.getBox(); - this.proxy.hide(); - this.window.handleResize(box); - return box; + /** + * Interates the child nodes of this node, calling the specified function with each node. The arguments to the function + * will be the args provided or the current node. If the function returns false at any point, + * the iteration stops. + * @param {Function} fn The function to call + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node in the iteration. + * @param {Array} args (optional) The args to call the function with (default to passing the current Node) + */ + eachChild : function(fn, scope, args){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++) { + if(fn.apply(scope || this, args || [cs[i]]) === false){ + break; + } + } }, - // private - beforeResize : function(){ - this.resizer.minHeight = Math.max(this.minHeight, this.getFrameHeight() + 40); // 40 is a magic minimum content size? - this.resizer.minWidth = Math.max(this.minWidth, this.getFrameWidth() + 40); - this.resizeBox = this.el.getBox(); + /** + * Finds the first child that has the attribute with the specified value. + * @param {String} attribute The attribute name + * @param {Mixed} value The value to search for + * @param {Boolean} deep (Optional) True to search through nodes deeper than the immediate children + * @return {Node} The found child or null if none was found + */ + findChild : function(attribute, value, deep){ + return this.findChildBy(function(){ + return this.attributes[attribute] == value; + }, null, deep); }, - // private - updateHandles : function(){ - if(Ext.isIE && this.resizer){ - this.resizer.syncHandleHeight(); - this.el.repaint(); + /** + * Finds the first child by a custom function. The child matches if the function passed returns true. + * @param {Function} fn A function which must return true if the passed Node is the required Node. + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the Node being tested. + * @param {Boolean} deep (Optional) True to search through nodes deeper than the immediate children + * @return {Node} The found child or null if none was found + */ + findChildBy : function(fn, scope, deep){ + var cs = this.childNodes, + len = cs.length, + i = 0, + n, + res; + for(; i < len; i++){ + n = cs[i]; + if(fn.call(scope || n, n) === true){ + return n; + }else if (deep){ + res = n.findChildBy(fn, scope, deep); + if(res != null){ + return res; + } + } + } + return null; }, - // private - handleResize : function(box){ - var rz = this.resizeBox; - if(rz.x != box.x || rz.y != box.y){ - this.updateBox(box); - }else{ - this.setSize(box); + /** + * Sorts this nodes children using the supplied sort function. + * @param {Function} fn A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order. + * @param {Object} scope (optional)The scope (this reference) in which the function is executed. Defaults to the browser window. + */ + sort : function(fn, scope){ + var cs = this.childNodes; + var len = cs.length; + if(len > 0){ + var sortFn = scope ? function(){fn.apply(scope, arguments);} : fn; + cs.sort(sortFn); + for(var i = 0; i < len; i++){ + var n = cs[i]; + n.previousSibling = cs[i-1]; + n.nextSibling = cs[i+1]; + if(i === 0){ + this.setFirstChild(n); + } + if(i == len-1){ + this.setLastChild(n); + } + } } - this.focus(); - this.updateHandles(); - this.saveState(); - this.doLayout(); }, - /** - * Focuses the window. If a defaultButton is set, it will receive focus, otherwise the - * window itself will receive focus. - */ - focus : function(){ - var f = this.focusEl, db = this.defaultButton, t = typeof db; - if(Ext.isDefined(db)){ - if(Ext.isNumber(db) && this.fbar){ - f = this.fbar.items.get(db); - }else if(Ext.isString(db)){ - f = Ext.getCmp(db); - }else{ - f = db; - } - } - f = f || this.focusEl; - f.focus.defer(10, f); - }, + /** + * Returns true if this node is an ancestor (at any point) of the passed node. + * @param {Node} node + * @return {Boolean} + */ + contains : function(node){ + return node.isAncestor(this); + }, + + /** + * Returns true if the passed node is an ancestor (at any point) of this node. + * @param {Node} node + * @return {Boolean} + */ + isAncestor : function(node){ + var p = this.parentNode; + while(p){ + if(p == node){ + return true; + } + p = p.parentNode; + } + return false; + }, + + toString : function(){ + return "[Node"+(this.id?" "+this.id:"")+"]"; + } +});/** + * @class Ext.tree.TreeNode + * @extends Ext.data.Node + * @cfg {String} text The text for this node + * @cfg {Boolean} expanded true to start the node expanded + * @cfg {Boolean} allowDrag False to make this node undraggable if {@link #draggable} = true (defaults to true) + * @cfg {Boolean} allowDrop False if this node cannot have child nodes dropped on it (defaults to true) + * @cfg {Boolean} disabled true to start the node disabled + * @cfg {String} icon The path to an icon for the node. The preferred way to do this + * is to use the cls or iconCls attributes and add the icon via a CSS background image. + * @cfg {String} cls A css class to be added to the node + * @cfg {String} iconCls A css class to be added to the nodes icon element for applying css background images + * @cfg {String} href URL of the link used for the node (defaults to #) + * @cfg {String} hrefTarget target frame for the link + * @cfg {Boolean} hidden True to render hidden. (Defaults to false). + * @cfg {String} qtip An Ext QuickTip for the node + * @cfg {Boolean} expandable If set to true, the node will always show a plus/minus icon, even when empty + * @cfg {String} qtipCfg An Ext QuickTip config for the node (used instead of qtip) + * @cfg {Boolean} singleClickExpand True for single click expand on this node + * @cfg {Function} uiProvider A UI class to use for this node (defaults to Ext.tree.TreeNodeUI) + * @cfg {Boolean} checked True to render a checked checkbox for this node, false to render an unchecked checkbox + * (defaults to undefined with no checkbox rendered) + * @cfg {Boolean} draggable True to make this node draggable (defaults to false) + * @cfg {Boolean} isTarget False to not allow this node to act as a drop target (defaults to true) + * @cfg {Boolean} allowChildren False to not allow this node to have child nodes (defaults to true) + * @cfg {Boolean} editable False to not allow this node to be edited by an {@link Ext.tree.TreeEditor} (defaults to true) + * @constructor + * @param {Object/String} attributes The attributes/config for the node or just a string with the text for the node + */ +Ext.tree.TreeNode = function(attributes){ + attributes = attributes || {}; + if(Ext.isString(attributes)){ + attributes = {text: attributes}; + } + this.childrenRendered = false; + this.rendered = false; + Ext.tree.TreeNode.superclass.constructor.call(this, attributes); + this.expanded = attributes.expanded === true; + this.isTarget = attributes.isTarget !== false; + this.draggable = attributes.draggable !== false && attributes.allowDrag !== false; + this.allowChildren = attributes.allowChildren !== false && attributes.allowDrop !== false; + + /** + * Read-only. The text for this node. To change it use {@link #setText}. + * @type String + */ + this.text = attributes.text; + /** + * True if this node is disabled. + * @type Boolean + */ + this.disabled = attributes.disabled === true; + /** + * True if this node is hidden. + * @type Boolean + */ + this.hidden = attributes.hidden === true; + + this.addEvents( + /** + * @event textchange + * Fires when the text for this node is changed + * @param {Node} this This node + * @param {String} text The new text + * @param {String} oldText The old text + */ + 'textchange', + /** + * @event beforeexpand + * Fires before this node is expanded, return false to cancel. + * @param {Node} this This node + * @param {Boolean} deep + * @param {Boolean} anim + */ + 'beforeexpand', + /** + * @event beforecollapse + * Fires before this node is collapsed, return false to cancel. + * @param {Node} this This node + * @param {Boolean} deep + * @param {Boolean} anim + */ + 'beforecollapse', + /** + * @event expand + * Fires when this node is expanded + * @param {Node} this This node + */ + 'expand', + /** + * @event disabledchange + * Fires when the disabled status of this node changes + * @param {Node} this This node + * @param {Boolean} disabled + */ + 'disabledchange', + /** + * @event collapse + * Fires when this node is collapsed + * @param {Node} this This node + */ + 'collapse', + /** + * @event beforeclick + * Fires before click processing. Return false to cancel the default action. + * @param {Node} this This node + * @param {Ext.EventObject} e The event object + */ + 'beforeclick', + /** + * @event click + * Fires when this node is clicked + * @param {Node} this This node + * @param {Ext.EventObject} e The event object + */ + 'click', + /** + * @event checkchange + * Fires when a node with a checkbox's checked property changes + * @param {Node} this This node + * @param {Boolean} checked + */ + 'checkchange', + /** + * @event beforedblclick + * Fires before double click processing. Return false to cancel the default action. + * @param {Node} this This node + * @param {Ext.EventObject} e The event object + */ + 'beforedblclick', + /** + * @event dblclick + * Fires when this node is double clicked + * @param {Node} this This node + * @param {Ext.EventObject} e The event object + */ + 'dblclick', + /** + * @event contextmenu + * Fires when this node is right clicked + * @param {Node} this This node + * @param {Ext.EventObject} e The event object + */ + 'contextmenu', + /** + * @event beforechildrenrendered + * Fires right before the child nodes for this node are rendered + * @param {Node} this This node + */ + 'beforechildrenrendered' + ); + + var uiClass = this.attributes.uiProvider || this.defaultUI || Ext.tree.TreeNodeUI; /** - * Sets the target element from which the window should animate while opening. - * @param {String/Element} el The target element or id + * Read-only. The UI for this node + * @type TreeNodeUI */ - setAnimateTarget : function(el){ - el = Ext.get(el); - this.animateTarget = el; - }, - - // private - beforeShow : function(){ - delete this.el.lastXY; - delete this.el.lastLT; - if(this.x === undefined || this.y === undefined){ - var xy = this.el.getAlignToXY(this.container, 'c-c'); - var pos = this.el.translatePoints(xy[0], xy[1]); - this.x = this.x === undefined? pos.left : this.x; - this.y = this.y === undefined? pos.top : this.y; - } - this.el.setLeftTop(this.x, this.y); - - if(this.expandOnShow){ - this.expand(false); - } - - if(this.modal){ - Ext.getBody().addClass('x-body-masked'); - this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); - this.mask.show(); - } - }, - + this.ui = new uiClass(this); +}; +Ext.extend(Ext.tree.TreeNode, Ext.data.Node, { + preventHScroll : true, /** - * Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden. - * @param {String/Element} animateTarget (optional) The target element or id from which the window should - * animate while opening (defaults to null with no animation) - * @param {Function} callback (optional) A callback function to call after the window is displayed - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Window. - * @return {Ext.Window} this + * Returns true if this node is expanded + * @return {Boolean} */ - show : function(animateTarget, cb, scope){ - if(!this.rendered){ - this.render(Ext.getBody()); - } - if(this.hidden === false){ - this.toFront(); - return this; - } - if(this.fireEvent('beforeshow', this) === false){ - return this; - } - if(cb){ - this.on('show', cb, scope, {single:true}); - } - this.hidden = false; - if(Ext.isDefined(animateTarget)){ - this.setAnimateTarget(animateTarget); - } - this.beforeShow(); - if(this.animateTarget){ - this.animShow(); - }else{ - this.afterShow(); - } - return this; + isExpanded : function(){ + return this.expanded; }, - // private - afterShow : function(isAnim){ - if (this.isDestroyed){ - return false; - } - this.proxy.hide(); - this.el.setStyle('display', 'block'); - this.el.show(); - if(this.maximized){ - this.fitContainer(); - } - if(Ext.isMac && Ext.isGecko2){ // work around stupid FF 2.0/Mac scroll bar bug - this.cascade(this.setAutoScroll); - } - - if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){ - Ext.EventManager.onWindowResize(this.onWindowResize, this); - } - this.doConstrain(); - this.doLayout(); - if(this.keyMap){ - this.keyMap.enable(); - } - this.toFront(); - this.updateHandles(); - if(isAnim && (Ext.isIE || Ext.isWebKit)){ - var sz = this.getSize(); - this.onResize(sz.width, sz.height); - } - this.onShow(); - this.fireEvent('show', this); +/** + * Returns the UI object for this node. + * @return {TreeNodeUI} The object which is providing the user interface for this tree + * node. Unless otherwise specified in the {@link #uiProvider}, this will be an instance + * of {@link Ext.tree.TreeNodeUI} + */ + getUI : function(){ + return this.ui; }, - // private - animShow : function(){ - this.proxy.show(); - this.proxy.setBox(this.animateTarget.getBox()); - this.proxy.setOpacity(0); - var b = this.getBox(); - this.el.setStyle('display', 'none'); - this.proxy.shift(Ext.apply(b, { - callback: this.afterShow.createDelegate(this, [true], false), - scope: this, - easing: 'easeNone', - duration: 0.25, - opacity: 0.5 - })); + getLoader : function(){ + var owner; + return this.loader || ((owner = this.getOwnerTree()) && owner.loader ? owner.loader : (this.loader = new Ext.tree.TreeLoader())); }, - /** - * Hides the window, setting it to invisible and applying negative offsets. - * @param {String/Element} animateTarget (optional) The target element or id to which the window should - * animate while hiding (defaults to null with no animation) - * @param {Function} callback (optional) A callback function to call after the window is hidden - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Window. - * @return {Ext.Window} this - */ - hide : function(animateTarget, cb, scope){ - if(this.hidden || this.fireEvent('beforehide', this) === false){ - return this; - } - if(cb){ - this.on('hide', cb, scope, {single:true}); - } - this.hidden = true; - if(animateTarget !== undefined){ - this.setAnimateTarget(animateTarget); - } - if(this.modal){ - this.mask.hide(); - Ext.getBody().removeClass('x-body-masked'); + // private override + setFirstChild : function(node){ + var of = this.firstChild; + Ext.tree.TreeNode.superclass.setFirstChild.call(this, node); + if(this.childrenRendered && of && node != of){ + of.renderIndent(true, true); } - if(this.animateTarget){ - this.animHide(); - }else{ - this.el.hide(); - this.afterHide(); + if(this.rendered){ + this.renderIndent(true, true); } - return this; }, - // private - afterHide : function(){ - this.proxy.hide(); - if(this.monitorResize || this.modal || this.constrain || this.constrainHeader){ - Ext.EventManager.removeResizeListener(this.onWindowResize, this); + // private override + setLastChild : function(node){ + var ol = this.lastChild; + Ext.tree.TreeNode.superclass.setLastChild.call(this, node); + if(this.childrenRendered && ol && node != ol){ + ol.renderIndent(true, true); } - if(this.keyMap){ - this.keyMap.disable(); + if(this.rendered){ + this.renderIndent(true, true); } - this.onHide(); - this.fireEvent('hide', this); - }, - - // private - animHide : function(){ - this.proxy.setOpacity(0.5); - this.proxy.show(); - var tb = this.getBox(false); - this.proxy.setBox(tb); - this.el.hide(); - this.proxy.shift(Ext.apply(this.animateTarget.getBox(), { - callback: this.afterHide, - scope: this, - duration: 0.25, - easing: 'easeNone', - opacity: 0 - })); }, - /** - * Method that is called immediately before the show event is fired. - * Defaults to Ext.emptyFn. - */ - onShow : Ext.emptyFn, - - /** - * Method that is called immediately before the hide event is fired. - * Defaults to Ext.emptyFn. - */ - onHide : Ext.emptyFn, - - // private - onWindowResize : function(){ - if(this.maximized){ - this.fitContainer(); + // these methods are overridden to provide lazy rendering support + // private override + appendChild : function(n){ + if(!n.render && !Ext.isArray(n)){ + n = this.getLoader().createNode(n); } - if(this.modal){ - this.mask.setSize('100%', '100%'); - var force = this.mask.dom.offsetHeight; - this.mask.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true)); + var node = Ext.tree.TreeNode.superclass.appendChild.call(this, n); + if(node && this.childrenRendered){ + node.render(); } - this.doConstrain(); + this.ui.updateExpandIcon(); + return node; }, - // private - doConstrain : function(){ - if(this.constrain || this.constrainHeader){ - var offsets; - if(this.constrain){ - offsets = { - right:this.el.shadowOffset, - left:this.el.shadowOffset, - bottom:this.el.shadowOffset - }; - }else { - var s = this.getSize(); - offsets = { - right:-(s.width - 100), - bottom:-(s.height - 25) - }; + // private override + removeChild : function(node, destroy){ + this.ownerTree.getSelectionModel().unselect(node); + Ext.tree.TreeNode.superclass.removeChild.apply(this, arguments); + // only update the ui if we're not destroying + if(!destroy){ + // if it's been rendered remove dom node + if(node.ui.rendered){ + node.ui.remove(); + } + if(this.childNodes.length < 1){ + this.collapse(false, false); + }else{ + this.ui.updateExpandIcon(); } - - var xy = this.el.getConstrainToXY(this.container, true, offsets); - if(xy){ - this.setPosition(xy[0], xy[1]); + if(!this.firstChild && !this.isHiddenRoot()){ + this.childrenRendered = false; } } + return node; }, - // private - used for dragging - ghost : function(cls){ - var ghost = this.createGhost(cls); - var box = this.getBox(true); - ghost.setLeftTop(box.x, box.y); - ghost.setWidth(box.width); - this.el.hide(); - this.activeGhost = ghost; - return ghost; - }, - - // private - unghost : function(show, matchPosition){ - if(!this.activeGhost) { - return; + // private override + insertBefore : function(node, refNode){ + if(!node.render){ + node = this.getLoader().createNode(node); } - if(show !== false){ - this.el.show(); - this.focus(); - if(Ext.isMac && Ext.isGecko2){ // work around stupid FF 2.0/Mac scroll bar bug - this.cascade(this.setAutoScroll); - } + var newNode = Ext.tree.TreeNode.superclass.insertBefore.call(this, node, refNode); + if(newNode && refNode && this.childrenRendered){ + node.render(); } - if(matchPosition !== false){ - this.setPosition(this.activeGhost.getLeft(true), this.activeGhost.getTop(true)); + this.ui.updateExpandIcon(); + return newNode; + }, + + /** + * Sets the text for this node + * @param {String} text + */ + setText : function(text){ + var oldText = this.text; + this.text = this.attributes.text = text; + if(this.rendered){ // event without subscribing + this.ui.onTextChange(this, text, oldText); } - this.activeGhost.hide(); - this.activeGhost.remove(); - delete this.activeGhost; + this.fireEvent('textchange', this, text, oldText); }, /** - * Placeholder method for minimizing the window. By default, this method simply fires the {@link #minimize} event - * since the behavior of minimizing a window is application-specific. To implement custom minimize behavior, - * either the minimize event can be handled or this method can be overridden. - * @return {Ext.Window} this + * Triggers selection of this node */ - minimize : function(){ - this.fireEvent('minimize', this); - return this; + select : function(){ + var t = this.getOwnerTree(); + if(t){ + t.getSelectionModel().select(this); + } }, /** - * Closes the Window, removes it from the DOM, {@link Ext.Component#destroy destroy}s - * the Window object and all its descendant Components. The {@link Ext.Panel#beforeclose beforeclose} - * event is fired before the close happens and will cancel the close action if it returns false. - * Note: This method is not affected by the {@link #closeAction} setting which - * only affects the action triggered when clicking the {@link #closable 'close' tool in the header}. - * To hide the Window without destroying it, call {@link #hide}. + * Triggers deselection of this node + * @param {Boolean} silent (optional) True to stop selection change events from firing. */ - close : function(){ - if(this.fireEvent('beforeclose', this) !== false){ - if(this.hidden){ - this.doClose(); - }else{ - this.hide(null, this.doClose, this); - } + unselect : function(silent){ + var t = this.getOwnerTree(); + if(t){ + t.getSelectionModel().unselect(this, silent); } }, - // private - doClose : function(){ - this.fireEvent('close', this); - this.destroy(); + /** + * Returns true if this node is selected + * @return {Boolean} + */ + isSelected : function(){ + var t = this.getOwnerTree(); + return t ? t.getSelectionModel().isSelected(this) : false; }, /** - * Fits the window within its current container and automatically replaces - * the {@link #maximizable 'maximize' tool button} with the 'restore' tool button. - * Also see {@link #toggleMaximize}. - * @return {Ext.Window} this + * Expand this node. + * @param {Boolean} deep (optional) True to expand all children as well + * @param {Boolean} anim (optional) false to cancel the default animation + * @param {Function} callback (optional) A callback to be called when + * expanding this node completes (does not wait for deep expand to complete). + * Called with 1 parameter, this node. + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. */ - maximize : function(){ - if(!this.maximized){ - this.expand(false); - this.restoreSize = this.getSize(); - this.restorePos = this.getPosition(true); - if (this.maximizable){ - this.tools.maximize.hide(); - this.tools.restore.show(); + expand : function(deep, anim, callback, scope){ + if(!this.expanded){ + if(this.fireEvent('beforeexpand', this, deep, anim) === false){ + return; } - this.maximized = true; - this.el.disableShadow(); - - if(this.dd){ - this.dd.lock(); + if(!this.childrenRendered){ + this.renderChildren(); } - if(this.collapsible){ - this.tools.toggle.hide(); + this.expanded = true; + if(!this.isHiddenRoot() && (this.getOwnerTree().animate && anim !== false) || anim){ + this.ui.animExpand(function(){ + this.fireEvent('expand', this); + this.runCallback(callback, scope || this, [this]); + if(deep === true){ + this.expandChildNodes(true); + } + }.createDelegate(this)); + return; + }else{ + this.ui.expand(); + this.fireEvent('expand', this); + this.runCallback(callback, scope || this, [this]); } - this.el.addClass('x-window-maximized'); - this.container.addClass('x-window-maximized-ct'); + }else{ + this.runCallback(callback, scope || this, [this]); + } + if(deep === true){ + this.expandChildNodes(true); + } + }, - this.setPosition(0, 0); - this.fitContainer(); - this.fireEvent('maximize', this); + runCallback : function(cb, scope, args){ + if(Ext.isFunction(cb)){ + cb.apply(scope, args); } - return this; + }, + + isHiddenRoot : function(){ + return this.isRoot && !this.getOwnerTree().rootVisible; }, /** - * Restores a {@link #maximizable maximized} window back to its original - * size and position prior to being maximized and also replaces - * the 'restore' tool button with the 'maximize' tool button. - * Also see {@link #toggleMaximize}. - * @return {Ext.Window} this + * Collapse this node. + * @param {Boolean} deep (optional) True to collapse all children as well + * @param {Boolean} anim (optional) false to cancel the default animation + * @param {Function} callback (optional) A callback to be called when + * expanding this node completes (does not wait for deep expand to complete). + * Called with 1 parameter, this node. + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. */ - restore : function(){ - if(this.maximized){ - var t = this.tools; - this.el.removeClass('x-window-maximized'); - if(t.restore){ - t.restore.hide(); - } - if(t.maximize){ - t.maximize.show(); + collapse : function(deep, anim, callback, scope){ + if(this.expanded && !this.isHiddenRoot()){ + if(this.fireEvent('beforecollapse', this, deep, anim) === false){ + return; } - this.setPosition(this.restorePos[0], this.restorePos[1]); - this.setSize(this.restoreSize.width, this.restoreSize.height); - delete this.restorePos; - delete this.restoreSize; - this.maximized = false; - this.el.enableShadow(true); - - if(this.dd){ - this.dd.unlock(); + this.expanded = false; + if((this.getOwnerTree().animate && anim !== false) || anim){ + this.ui.animCollapse(function(){ + this.fireEvent('collapse', this); + this.runCallback(callback, scope || this, [this]); + if(deep === true){ + this.collapseChildNodes(true); + } + }.createDelegate(this)); + return; + }else{ + this.ui.collapse(); + this.fireEvent('collapse', this); + this.runCallback(callback, scope || this, [this]); } - if(this.collapsible && t.toggle){ - t.toggle.show(); + }else if(!this.expanded){ + this.runCallback(callback, scope || this, [this]); + } + if(deep === true){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++) { + cs[i].collapse(true, false); } - this.container.removeClass('x-window-maximized-ct'); - - this.doConstrain(); - this.fireEvent('restore', this); } - return this; - }, - - /** - * A shortcut method for toggling between {@link #maximize} and {@link #restore} based on the current maximized - * state of the window. - * @return {Ext.Window} this - */ - toggleMaximize : function(){ - return this[this.maximized ? 'restore' : 'maximize'](); }, // private - fitContainer : function(){ - var vs = this.container.getViewSize(false); - this.setSize(vs.width, vs.height); + delayedExpand : function(delay){ + if(!this.expandProcId){ + this.expandProcId = this.expand.defer(delay, this); + } }, // private - // z-index is managed by the WindowManager and may be overwritten at any time - setZIndex : function(index){ - if(this.modal){ - this.mask.setStyle('z-index', index); - } - this.el.setZIndex(++index); - index += 5; - - if(this.resizer){ - this.resizer.proxy.setStyle('z-index', ++index); + cancelExpand : function(){ + if(this.expandProcId){ + clearTimeout(this.expandProcId); } - - this.lastZIndex = index; + this.expandProcId = false; }, /** - * Aligns the window to the specified element - * @param {Mixed} element The element to align to. - * @param {String} position (optional, defaults to "tl-bl?") The position to align to (see {@link Ext.Element#alignTo} for more details). - * @param {Array} offsets (optional) Offset the positioning by [x, y] - * @return {Ext.Window} this + * Toggles expanded/collapsed state of the node */ - alignTo : function(element, position, offsets){ - var xy = this.el.getAlignToXY(element, position, offsets); - this.setPagePosition(xy[0], xy[1]); - return this; + toggle : function(){ + if(this.expanded){ + this.collapse(); + }else{ + this.expand(); + } }, /** - * Anchors this window to another element and realigns it when the window is resized or scrolled. - * @param {Mixed} element The element to align to. - * @param {String} position The position to align to (see {@link Ext.Element#alignTo} for more details) - * @param {Array} offsets (optional) Offset the positioning by [x, y] - * @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). - * @return {Ext.Window} this + * Ensures all parent nodes are expanded, and if necessary, scrolls + * the node into view. + * @param {Function} callback (optional) A function to call when the node has been made visible. + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. */ - anchorTo : function(el, alignment, offsets, monitorScroll){ - if(this.doAnchor){ - Ext.EventManager.removeResizeListener(this.doAnchor, this); - Ext.EventManager.un(window, 'scroll', this.doAnchor, this); - } - this.doAnchor = function(){ - this.alignTo(el, alignment, offsets); - }; - Ext.EventManager.onWindowResize(this.doAnchor, this); - - var tm = typeof monitorScroll; - if(tm != 'undefined'){ - Ext.EventManager.on(window, 'scroll', this.doAnchor, this, - {buffer: tm == 'number' ? monitorScroll : 50}); - } - return this; + ensureVisible : function(callback, scope){ + var tree = this.getOwnerTree(); + tree.expandPath(this.parentNode ? this.parentNode.getPath() : this.getPath(), false, function(){ + var node = tree.getNodeById(this.id); // Somehow if we don't do this, we lose changes that happened to node in the meantime + tree.getTreeEl().scrollChildIntoView(node.ui.anchor); + this.runCallback(callback, scope || this, [this]); + }.createDelegate(this)); }, /** - * Brings this window to the front of any other visible windows - * @param {Boolean} e (optional) Specify false to prevent the window from being focused. - * @return {Ext.Window} this + * Expand all child nodes + * @param {Boolean} deep (optional) true if the child nodes should also expand their child nodes */ - toFront : function(e){ - if(this.manager.bringToFront(this)){ - if(!e || !e.getTarget().focus){ - this.focus(); - } + expandChildNodes : function(deep){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++) { + cs[i].expand(deep); } - return this; }, /** - * Makes this the active window by showing its shadow, or deactivates it by hiding its shadow. This method also - * fires the {@link #activate} or {@link #deactivate} event depending on which action occurred. This method is - * called internally by {@link Ext.WindowMgr}. - * @param {Boolean} active True to activate the window, false to deactivate it (defaults to false) + * Collapse all child nodes + * @param {Boolean} deep (optional) true if the child nodes should also collapse their child nodes */ - setActive : function(active){ - if(active){ - if(!this.maximized){ - this.el.enableShadow(true); - } - this.fireEvent('activate', this); - }else{ - this.el.disableShadow(); - this.fireEvent('deactivate', this); + collapseChildNodes : function(deep){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++) { + cs[i].collapse(deep); } }, /** - * Sends this window to the back of (lower z-index than) any other visible windows - * @return {Ext.Window} this + * Disables this node */ - toBack : function(){ - this.manager.sendToBack(this); - return this; + disable : function(){ + this.disabled = true; + this.unselect(); + if(this.rendered && this.ui.onDisableChange){ // event without subscribing + this.ui.onDisableChange(this, true); + } + this.fireEvent('disabledchange', this, true); }, /** - * Centers this window in the viewport - * @return {Ext.Window} this + * Enables this node */ - center : function(){ - var xy = this.el.getAlignToXY(this.container, 'c-c'); - this.setPagePosition(xy[0], xy[1]); - return this; - } - - /** - * @cfg {Boolean} autoWidth @hide - **/ -}); -Ext.reg('window', Ext.Window); - -// private - custom Window DD implementation -Ext.Window.DD = function(win){ - this.win = win; - Ext.Window.DD.superclass.constructor.call(this, win.el.id, 'WindowDD-'+win.id); - this.setHandleElId(win.header.id); - this.scroll = false; -}; - -Ext.extend(Ext.Window.DD, Ext.dd.DD, { - moveOnly:true, - headerOffsets:[100, 25], - startDrag : function(){ - var w = this.win; - this.proxy = w.ghost(); - if(w.constrain !== false){ - var so = w.el.shadowOffset; - this.constrainTo(w.container, {right: so, left: so, bottom: so}); - }else if(w.constrainHeader !== false){ - var s = this.proxy.getSize(); - this.constrainTo(w.container, {right: -(s.width-this.headerOffsets[0]), bottom: -(s.height-this.headerOffsets[1])}); + enable : function(){ + this.disabled = false; + if(this.rendered && this.ui.onDisableChange){ // event without subscribing + this.ui.onDisableChange(this, false); } + this.fireEvent('disabledchange', this, false); }, - b4Drag : Ext.emptyFn, - - onDrag : function(e){ - this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY()); - }, - - endDrag : function(e){ - this.win.unghost(); - this.win.saveState(); - } -}); -/** - * @class Ext.WindowGroup - * An object that manages a group of {@link Ext.Window} instances and provides z-order management - * and window activation behavior. - * @constructor - */ -Ext.WindowGroup = function(){ - var list = {}; - var accessList = []; - var front = null; - - // private - var sortWindows = function(d1, d2){ - return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1 : 1; - }; // private - var orderWindows = function(){ - var a = accessList, len = a.length; - if(len > 0){ - a.sort(sortWindows); - var seed = a[0].manager.zseed; - for(var i = 0; i < len; i++){ - var win = a[i]; - if(win && !win.hidden){ - win.setZIndex(seed + (i*10)); - } - } + renderChildren : function(suppressEvent){ + if(suppressEvent !== false){ + this.fireEvent('beforechildrenrendered', this); } - activateLast(); - }; - - // private - var setActiveWin = function(win){ - if(win != front){ - if(front){ - front.setActive(false); - } - front = win; - if(win){ - win.setActive(true); - } + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++){ + cs[i].render(true); } - }; + this.childrenRendered = true; + }, // private - var activateLast = function(){ - for(var i = accessList.length-1; i >=0; --i) { - if(!accessList[i].hidden){ - setActiveWin(accessList[i]); - return; + sort : function(fn, scope){ + Ext.tree.TreeNode.superclass.sort.apply(this, arguments); + if(this.childrenRendered){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++){ + cs[i].render(true); } } - // none to activate - setActiveWin(null); - }; - - return { - /** - * The starting z-index for windows in this WindowGroup (defaults to 9000) - * @type Number The z-index value - */ - zseed : 9000, - - /** - * Registers a {@link Ext.Window Window} with this WindowManager. This should not - * need to be called under normal circumstances. Windows are automatically registered - * with a {@link Ext.Window#manager manager} at construction time. - * Where this may be useful is moving Windows between two WindowManagers. For example, - * to bring the Ext.MessageBox dialog under the same manager as the Desktop's - * WindowManager in the desktop sample app: -var msgWin = Ext.MessageBox.getDialog(); -MyDesktop.getDesktop().getManager().register(msgWin); - - * @param {Window} win The Window to register. - */ - register : function(win){ - if(win.manager){ - win.manager.unregister(win); - } - win.manager = this; - - list[win.id] = win; - accessList.push(win); - win.on('hide', activateLast); - }, - - /** - * Unregisters a {@link Ext.Window Window} from this WindowManager. This should not - * need to be called. Windows are automatically unregistered upon destruction. - * See {@link #register}. - * @param {Window} win The Window to unregister. - */ - unregister : function(win){ - delete win.manager; - delete list[win.id]; - win.un('hide', activateLast); - accessList.remove(win); - }, - - /** - * Gets a registered window by id. - * @param {String/Object} id The id of the window or a {@link Ext.Window} instance - * @return {Ext.Window} - */ - get : function(id){ - return typeof id == "object" ? id : list[id]; - }, - - /** - * Brings the specified window to the front of any other active windows in this WindowGroup. - * @param {String/Object} win The id of the window or a {@link Ext.Window} instance - * @return {Boolean} True if the dialog was brought to the front, else false - * if it was already in front - */ - bringToFront : function(win){ - win = this.get(win); - if(win != front){ - win._lastAccess = new Date().getTime(); - orderWindows(); - return true; - } - return false; - }, - - /** - * Sends the specified window to the back of other active windows in this WindowGroup. - * @param {String/Object} win The id of the window or a {@link Ext.Window} instance - * @return {Ext.Window} The window - */ - sendToBack : function(win){ - win = this.get(win); - win._lastAccess = -(new Date().getTime()); - orderWindows(); - return win; - }, - - /** - * Hides all windows in this WindowGroup. - */ - hideAll : function(){ - for(var id in list){ - if(list[id] && typeof list[id] != "function" && list[id].isVisible()){ - list[id].hide(); - } - } - }, - - /** - * Gets the currently-active window in this WindowGroup. - * @return {Ext.Window} The active window - */ - getActive : function(){ - return front; - }, - - /** - * Returns zero or more windows in this WindowGroup using the custom search function passed to this method. - * The function should accept a single {@link Ext.Window} reference as its only argument and should - * return true if the window matches the search criteria, otherwise it should return false. - * @param {Function} fn The search function - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the Window being tested. - * that gets passed to the function if not specified) - * @return {Array} An array of zero or more matching windows - */ - getBy : function(fn, scope){ - var r = []; - for(var i = accessList.length-1; i >=0; --i) { - var win = accessList[i]; - if(fn.call(scope||win, win) !== false){ - r.push(win); - } - } - return r; - }, + }, - /** - * Executes the specified function once for every window in this WindowGroup, passing each - * window as the only parameter. 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 (this reference) in which the function is executed. Defaults to the current Window in the iteration. - */ - each : function(fn, scope){ - for(var id in list){ - if(list[id] && typeof list[id] != "function"){ - if(fn.call(scope || list[id], list[id]) === false){ - return; - } - } + // private + render : function(bulkRender){ + this.ui.render(bulkRender); + if(!this.rendered){ + // make sure it is registered + this.getOwnerTree().registerNode(this); + this.rendered = true; + if(this.expanded){ + this.expanded = false; + this.expand(false, false); } } - }; -}; - - -/** - * @class Ext.WindowMgr - * @extends Ext.WindowGroup - * The default global window group that is available automatically. To have more than one group of windows - * with separate z-order stacks, create additional instances of {@link Ext.WindowGroup} as needed. - * @singleton - */ -Ext.WindowMgr = new Ext.WindowGroup();/** - * @class Ext.MessageBox - * Utility class for generating different styles of message boxes. The alias Ext.Msg can also be used. - * Note that the MessageBox is asynchronous. Unlike a regular JavaScript alert (which will halt - * browser execution), showing a MessageBox will not cause the code to stop. For this reason, if you have code - * that should only run after some user feedback from the MessageBox, you must use a callback function - * (see the function parameter for {@link #show} for more details). - * Example usage: - * -// Basic alert: -Ext.Msg.alert('Status', 'Changes saved successfully.'); - -// Prompt for user data and process the result using a callback: -Ext.Msg.prompt('Name', 'Please enter your name:', function(btn, text){ - if (btn == 'ok'){ - // process text value and close... - } -}); - -// Show a dialog using config options: -Ext.Msg.show({ - title:'Save Changes?', - msg: 'You are closing a tab that has unsaved changes. Would you like to save your changes?', - buttons: Ext.Msg.YESNOCANCEL, - fn: processResult, - animEl: 'elId', - icon: Ext.MessageBox.QUESTION -}); - - * @singleton - */ -Ext.MessageBox = function(){ - var dlg, opt, mask, waitTimer, - bodyEl, msgEl, textboxEl, textareaEl, progressBar, pp, iconEl, spacerEl, - buttons, activeTextEl, bwidth, bufferIcon = '', iconCls = '', - buttonNames = ['ok', 'yes', 'no', 'cancel']; - - // private - var handleButton = function(button){ - buttons[button].blur(); - if(dlg.isVisible()){ - dlg.hide(); - handleHide(); - Ext.callback(opt.fn, opt.scope||window, [button, activeTextEl.dom.value, opt], 1); - } - }; - - // private - var handleHide = function(){ - if(opt && opt.cls){ - dlg.el.removeClass(opt.cls); - } - progressBar.reset(); - }; - - // private - var handleEsc = function(d, k, e){ - if(opt && opt.closable !== false){ - dlg.hide(); - handleHide(); - } - if(e){ - e.stopEvent(); - } - }; - - // private - var updateButtons = function(b){ - var width = 0, - cfg; - if(!b){ - Ext.each(buttonNames, function(name){ - buttons[name].hide(); - }); - return width; - } - dlg.footer.dom.style.display = ''; - Ext.iterate(buttons, function(name, btn){ - cfg = b[name]; - if(cfg){ - btn.show(); - btn.setText(Ext.isString(cfg) ? cfg : Ext.MessageBox.buttonText[name]); - width += btn.getEl().getWidth() + 15; - }else{ - btn.hide(); - } - }); - return width; - }; - - return { - /** - * Returns a reference to the underlying {@link Ext.Window} element - * @return {Ext.Window} The window - */ - getDialog : function(titleText){ - if(!dlg){ - var btns = []; - - buttons = {}; - Ext.each(buttonNames, function(name){ - btns.push(buttons[name] = new Ext.Button({ - text: this.buttonText[name], - handler: handleButton.createCallback(name), - hideMode: 'offsets' - })); - }, this); - dlg = new Ext.Window({ - autoCreate : true, - title:titleText, - resizable:false, - constrain:true, - constrainHeader:true, - minimizable : false, - maximizable : false, - stateful: false, - modal: true, - shim:true, - buttonAlign:"center", - width:400, - height:100, - minHeight: 80, - plain:true, - footer:true, - closable:true, - close : function(){ - if(opt && opt.buttons && opt.buttons.no && !opt.buttons.cancel){ - handleButton("no"); - }else{ - handleButton("cancel"); - } - }, - fbar: new Ext.Toolbar({ - items: btns, - enableOverflow: false - }) - }); - dlg.render(document.body); - dlg.getEl().addClass('x-window-dlg'); - mask = dlg.mask; - bodyEl = dlg.body.createChild({ - html:' ' - }); - iconEl = Ext.get(bodyEl.dom.firstChild); - var contentEl = bodyEl.dom.childNodes[1]; - msgEl = Ext.get(contentEl.firstChild); - textboxEl = Ext.get(contentEl.childNodes[2].firstChild); - textboxEl.enableDisplayMode(); - textboxEl.addKeyListener([10,13], function(){ - if(dlg.isVisible() && opt && opt.buttons){ - if(opt.buttons.ok){ - handleButton("ok"); - }else if(opt.buttons.yes){ - handleButton("yes"); - } - } - }); - textareaEl = Ext.get(contentEl.childNodes[2].childNodes[1]); - textareaEl.enableDisplayMode(); - progressBar = new Ext.ProgressBar({ - renderTo:bodyEl - }); - bodyEl.createChild({cls:'x-clear'}); - } - return dlg; - }, - - /** - * Updates the message box body text - * @param {String} text (optional) Replaces the message box element's innerHTML with the specified string (defaults to - * the XHTML-compliant non-breaking space character ' ') - * @return {Ext.MessageBox} this - */ - updateText : function(text){ - if(!dlg.isVisible() && !opt.width){ - dlg.setSize(this.maxWidth, 100); // resize first so content is never clipped from previous shows - } - msgEl.update(text || ' '); - - var iw = iconCls != '' ? (iconEl.getWidth() + iconEl.getMargins('lr')) : 0, - mw = msgEl.getWidth() + msgEl.getMargins('lr'), - fw = dlg.getFrameWidth('lr'), - bw = dlg.body.getFrameWidth('lr'), - w; - - if (Ext.isIE && iw > 0){ - //3 pixels get subtracted in the icon CSS for an IE margin issue, - //so we have to add it back here for the overall width to be consistent - iw += 3; - } - w = Math.max(Math.min(opt.width || iw+mw+fw+bw, opt.maxWidth || this.maxWidth), - Math.max(opt.minWidth || this.minWidth, bwidth || 0)); - - if(opt.prompt === true){ - activeTextEl.setWidth(w-iw-fw-bw); - } - if(opt.progress === true || opt.wait === true){ - progressBar.setSize(w-iw-fw-bw); - } - if(Ext.isIE && w == bwidth){ - w += 4; //Add offset when the content width is smaller than the buttons. - } - dlg.setSize(w, 'auto').center(); - return this; - }, - - /** - * Updates a progress-style message box's text and progress bar. Only relevant on message boxes - * initiated via {@link Ext.MessageBox#progress} or {@link Ext.MessageBox#wait}, - * or by calling {@link Ext.MessageBox#show} with progress: true. - * @param {Number} value Any number between 0 and 1 (e.g., .5, defaults to 0) - * @param {String} progressText The progress text to display inside the progress bar (defaults to '') - * @param {String} msg The message box's body text is replaced with the specified string (defaults to undefined - * so that any existing body text will not get overwritten by default unless a new value is passed in) - * @return {Ext.MessageBox} this - */ - updateProgress : function(value, progressText, msg){ - progressBar.updateProgress(value, progressText); - if(msg){ - this.updateText(msg); - } - return this; - }, - - /** - * Returns true if the message box is currently displayed - * @return {Boolean} True if the message box is visible, else false - */ - isVisible : function(){ - return dlg && dlg.isVisible(); - }, - - /** - * Hides the message box if it is displayed - * @return {Ext.MessageBox} this - */ - hide : function(){ - var proxy = dlg ? dlg.activeGhost : null; - if(this.isVisible() || proxy){ - dlg.hide(); - handleHide(); - if (proxy){ - // unghost is a private function, but i saw no better solution - // to fix the locking problem when dragging while it closes - dlg.unghost(false, false); - } - } - return this; - }, - - /** - * Displays a new message box, or reinitializes an existing message box, based on the config options - * passed in. All display functions (e.g. prompt, alert, etc.) on MessageBox call this function internally, - * although those calls are basic shortcuts and do not support all of the config options allowed here. - * @param {Object} config The following config options are supported: - * animEl : String/ElementAn id or Element from which the message box should animate as it - * opens and closes (defaults to undefined) - * buttons : Object/BooleanA button config object (e.g., Ext.MessageBox.OKCANCEL or {ok:'Foo', - * cancel:'Bar'}), or false to not show any buttons (defaults to false) - * closable : BooleanFalse to hide the top-right close button (defaults to true). Note that - * progress and wait dialogs will ignore this property and always hide the close button as they can only - * be closed programmatically. - * cls : StringA custom CSS class to apply to the message box's container element - * defaultTextHeight : NumberThe default height in pixels of the message box's multiline textarea - * if displayed (defaults to 75) - * fn : FunctionA callback function which is called when the dialog is dismissed either - * by clicking on the configured buttons, or on the dialog close button, or by pressing - * the return button to enter input. - * Progress and wait dialogs will ignore this option since they do not respond to user - * actions and can only be closed programmatically, so any required function should be called - * by the same code after it closes the dialog. Parameters passed: - * buttonId : StringThe ID of the button pressed, one of: - * ok - * yes - * no - * cancel - * - * text : StringValue of the input field if either prompt - * or multiline is true - * opt : ObjectThe config object passed to show. - * - * scope : ObjectThe scope of the callback function - * icon : StringA CSS class that provides a background image to be used as the body icon for the - * dialog (e.g. Ext.MessageBox.WARNING or 'custom-class') (defaults to '') - * iconCls : StringThe standard {@link Ext.Window#iconCls} to - * add an optional header icon (defaults to '') - * maxWidth : NumberThe maximum width in pixels of the message box (defaults to 600) - * minWidth : NumberThe minimum width in pixels of the message box (defaults to 100) - * modal : BooleanFalse to allow user interaction with the page while the message box is - * displayed (defaults to true) - * msg : StringA string that will replace the existing message box body text (defaults to the - * XHTML-compliant non-breaking space character ' ') - * multiline : Boolean - * True to prompt the user to enter multi-line text (defaults to false) - * progress : BooleanTrue to display a progress bar (defaults to false) - * progressText : StringThe text to display inside the progress bar if progress = true (defaults to '') - * prompt : BooleanTrue to prompt the user to enter single-line text (defaults to false) - * proxyDrag : BooleanTrue to display a lightweight proxy while dragging (defaults to false) - * title : StringThe title text - * value : StringThe string value to set into the active textbox element if displayed - * wait : BooleanTrue to display a progress bar (defaults to false) - * waitConfig : ObjectA {@link Ext.ProgressBar#waitConfig} object (applies only if wait = true) - * width : NumberThe width of the dialog in pixels - * - * Example usage: - * -Ext.Msg.show({ - title: 'Address', - msg: 'Please enter your address:', - width: 300, - buttons: Ext.MessageBox.OKCANCEL, - multiline: true, - fn: saveAddress, - animEl: 'addAddressBtn', - icon: Ext.MessageBox.INFO -}); - - * @return {Ext.MessageBox} this - */ - show : function(options){ - if(this.isVisible()){ - this.hide(); - } - opt = options; - var d = this.getDialog(opt.title || " "); - - d.setTitle(opt.title || " "); - var allowClose = (opt.closable !== false && opt.progress !== true && opt.wait !== true); - d.tools.close.setDisplayed(allowClose); - activeTextEl = textboxEl; - opt.prompt = opt.prompt || (opt.multiline ? true : false); - if(opt.prompt){ - if(opt.multiline){ - textboxEl.hide(); - textareaEl.show(); - textareaEl.setHeight(Ext.isNumber(opt.multiline) ? opt.multiline : this.defaultTextHeight); - activeTextEl = textareaEl; - }else{ - textboxEl.show(); - textareaEl.hide(); - } - }else{ - textboxEl.hide(); - textareaEl.hide(); - } - activeTextEl.dom.value = opt.value || ""; - if(opt.prompt){ - d.focusEl = activeTextEl; - }else{ - var bs = opt.buttons; - var db = null; - if(bs && bs.ok){ - db = buttons["ok"]; - }else if(bs && bs.yes){ - db = buttons["yes"]; - } - if (db){ - d.focusEl = db; - } - } - if(opt.iconCls){ - d.setIconClass(opt.iconCls); - } - this.setIcon(Ext.isDefined(opt.icon) ? opt.icon : bufferIcon); - bwidth = updateButtons(opt.buttons); - progressBar.setVisible(opt.progress === true || opt.wait === true); - this.updateProgress(0, opt.progressText); - this.updateText(opt.msg); - if(opt.cls){ - d.el.addClass(opt.cls); - } - d.proxyDrag = opt.proxyDrag === true; - d.modal = opt.modal !== false; - d.mask = opt.modal !== false ? mask : false; - if(!d.isVisible()){ - // force it to the end of the z-index stack so it gets a cursor in FF - document.body.appendChild(dlg.el.dom); - d.setAnimateTarget(opt.animEl); - //workaround for window internally enabling keymap in afterShow - d.on('show', function(){ - if(allowClose === true){ - d.keyMap.enable(); - }else{ - d.keyMap.disable(); - } - }, this, {single:true}); - d.show(opt.animEl); - } - if(opt.wait === true){ - progressBar.wait(opt.waitConfig); - } - return this; - }, - - /** - * Adds the specified icon to the dialog. By default, the class 'ext-mb-icon' is applied for default - * styling, and the class passed in is expected to supply the background image url. Pass in empty string ('') - * to clear any existing icon. This method must be called before the MessageBox is shown. - * The following built-in icon classes are supported, but you can also pass in a custom class name: - * -Ext.MessageBox.INFO -Ext.MessageBox.WARNING -Ext.MessageBox.QUESTION -Ext.MessageBox.ERROR - * - * @param {String} icon A CSS classname specifying the icon's background image url, or empty string to clear the icon - * @return {Ext.MessageBox} this - */ - setIcon : function(icon){ - if(!dlg){ - bufferIcon = icon; - return; - } - bufferIcon = undefined; - if(icon && icon != ''){ - iconEl.removeClass('x-hidden'); - iconEl.replaceClass(iconCls, icon); - bodyEl.addClass('x-dlg-icon'); - iconCls = icon; - }else{ - iconEl.replaceClass(iconCls, 'x-hidden'); - bodyEl.removeClass('x-dlg-icon'); - iconCls = ''; - } - return this; - }, - - /** - * Displays a message box with a progress bar. This message box has no buttons and is not closeable by - * the user. You are responsible for updating the progress bar as needed via {@link Ext.MessageBox#updateProgress} - * and closing the message box when the process is complete. - * @param {String} title The title bar text - * @param {String} msg The message box body text - * @param {String} progressText (optional) The text to display inside the progress bar (defaults to '') - * @return {Ext.MessageBox} this - */ - progress : function(title, msg, progressText){ - this.show({ - title : title, - msg : msg, - buttons: false, - progress:true, - closable:false, - minWidth: this.minProgressWidth, - progressText: progressText - }); - return this; - }, - - /** - * Displays a message box with an infinitely auto-updating progress bar. This can be used to block user - * interaction while waiting for a long-running process to complete that does not have defined intervals. - * You are responsible for closing the message box when the process is complete. - * @param {String} msg The message box body text - * @param {String} title (optional) The title bar text - * @param {Object} config (optional) A {@link Ext.ProgressBar#waitConfig} object - * @return {Ext.MessageBox} this - */ - wait : function(msg, title, config){ - this.show({ - title : title, - msg : msg, - buttons: false, - closable:false, - wait:true, - modal:true, - minWidth: this.minProgressWidth, - waitConfig: config - }); - return this; - }, - - /** - * Displays a standard read-only message box with an OK button (comparable to the basic JavaScript alert prompt). - * If a callback function is passed it will be called after the user clicks the button, and the - * id of the button that was clicked will be passed as the only parameter to the callback - * (could also be the top-right close button). - * @param {String} title The title bar text - * @param {String} msg The message box body text - * @param {Function} fn (optional) The callback function invoked after the message box is closed - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. - * @return {Ext.MessageBox} this - */ - alert : function(title, msg, fn, scope){ - this.show({ - title : title, - msg : msg, - buttons: this.OK, - fn: fn, - scope : scope, - minWidth: this.minWidth - }); - return this; - }, - - /** - * Displays a confirmation message box with Yes and No buttons (comparable to JavaScript's confirm). - * If a callback function is passed it will be called after the user clicks either button, - * and the id of the button that was clicked will be passed as the only parameter to the callback - * (could also be the top-right close button). - * @param {String} title The title bar text - * @param {String} msg The message box body text - * @param {Function} fn (optional) The callback function invoked after the message box is closed - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. - * @return {Ext.MessageBox} this - */ - confirm : function(title, msg, fn, scope){ - this.show({ - title : title, - msg : msg, - buttons: this.YESNO, - fn: fn, - scope : scope, - icon: this.QUESTION, - minWidth: this.minWidth - }); - return this; - }, - - /** - * Displays a message box with OK and Cancel buttons prompting the user to enter some text (comparable to JavaScript's prompt). - * The prompt can be a single-line or multi-line textbox. If a callback function is passed it will be called after the user - * clicks either button, and the id of the button that was clicked (could also be the top-right - * close button) and the text that was entered will be passed as the two parameters to the callback. - * @param {String} title The title bar text - * @param {String} msg The message box body text - * @param {Function} fn (optional) The callback function invoked after the message box is closed - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser wnidow. - * @param {Boolean/Number} multiline (optional) True to create a multiline textbox using the defaultTextHeight - * property, or the height in pixels to create the textbox (defaults to false / single-line) - * @param {String} value (optional) Default value of the text input element (defaults to '') - * @return {Ext.MessageBox} this - */ - prompt : function(title, msg, fn, scope, multiline, value){ - this.show({ - title : title, - msg : msg, - buttons: this.OKCANCEL, - fn: fn, - minWidth: this.minPromptWidth, - scope : scope, - prompt:true, - multiline: multiline, - value: value - }); - return this; - }, - - /** - * Button config that displays a single OK button - * @type Object - */ - OK : {ok:true}, - /** - * Button config that displays a single Cancel button - * @type Object - */ - CANCEL : {cancel:true}, - /** - * Button config that displays OK and Cancel buttons - * @type Object - */ - OKCANCEL : {ok:true, cancel:true}, - /** - * Button config that displays Yes and No buttons - * @type Object - */ - YESNO : {yes:true, no:true}, - /** - * Button config that displays Yes, No and Cancel buttons - * @type Object - */ - YESNOCANCEL : {yes:true, no:true, cancel:true}, - /** - * The CSS class that provides the INFO icon image - * @type String - */ - INFO : 'ext-mb-info', - /** - * The CSS class that provides the WARNING icon image - * @type String - */ - WARNING : 'ext-mb-warning', - /** - * The CSS class that provides the QUESTION icon image - * @type String - */ - QUESTION : 'ext-mb-question', - /** - * The CSS class that provides the ERROR icon image - * @type String - */ - ERROR : 'ext-mb-error', - - /** - * The default height in pixels of the message box's multiline textarea if displayed (defaults to 75) - * @type Number - */ - defaultTextHeight : 75, - /** - * The maximum width in pixels of the message box (defaults to 600) - * @type Number - */ - maxWidth : 600, - /** - * The minimum width in pixels of the message box (defaults to 100) - * @type Number - */ - minWidth : 100, - /** - * The minimum width in pixels of the message box if it is a progress-style dialog. This is useful - * for setting a different minimum width than text-only dialogs may need (defaults to 250). - * @type Number - */ - minProgressWidth : 250, - /** - * The minimum width in pixels of the message box if it is a prompt dialog. This is useful - * for setting a different minimum width than text-only dialogs may need (defaults to 250). - * @type Number - */ - minPromptWidth: 250, - /** - * An object containing the default button text strings that can be overriden for localized language support. - * Supported properties are: ok, cancel, yes and no. Generally you should include a locale-specific - * resource file for handling language support across the framework. - * Customize the default text like so: Ext.MessageBox.buttonText.yes = "oui"; //french - * @type Object - */ - buttonText : { - ok : "OK", - cancel : "Cancel", - yes : "Yes", - no : "No" - } - }; -}(); - -/** - * Shorthand for {@link Ext.MessageBox} - */ -Ext.Msg = Ext.MessageBox;/** - * @class Ext.dd.PanelProxy - * A custom drag proxy implementation specific to {@link Ext.Panel}s. This class is primarily used internally - * for the Panel's drag drop implementation, and should never need to be created directly. - * @constructor - * @param panel The {@link Ext.Panel} to proxy for - * @param config Configuration options - */ -Ext.dd.PanelProxy = function(panel, config){ - this.panel = panel; - this.id = this.panel.id +'-ddproxy'; - Ext.apply(this, config); -}; - -Ext.dd.PanelProxy.prototype = { - /** - * @cfg {Boolean} insertProxy True to insert a placeholder proxy element while dragging the panel, - * false to drag with no proxy (defaults to true). - */ - insertProxy : true, - - // private overrides - setStatus : Ext.emptyFn, - reset : Ext.emptyFn, - update : Ext.emptyFn, - stop : Ext.emptyFn, - sync: Ext.emptyFn, - - /** - * Gets the proxy's element - * @return {Element} The proxy's element - */ - getEl : function(){ - return this.ghost; - }, - - /** - * Gets the proxy's ghost element - * @return {Element} The proxy's ghost element - */ - getGhost : function(){ - return this.ghost; - }, - - /** - * Gets the proxy's element - * @return {Element} The proxy's element - */ - getProxy : function(){ - return this.proxy; - }, - - /** - * Hides the proxy - */ - hide : function(){ - if(this.ghost){ - if(this.proxy){ - this.proxy.remove(); - delete this.proxy; - } - this.panel.el.dom.style.display = ''; - this.ghost.remove(); - delete this.ghost; - } - }, - - /** - * Shows the proxy - */ - show : function(){ - if(!this.ghost){ - this.ghost = this.panel.createGhost(undefined, undefined, Ext.getBody()); - this.ghost.setXY(this.panel.el.getXY()) - if(this.insertProxy){ - this.proxy = this.panel.el.insertSibling({cls:'x-panel-dd-spacer'}); - this.proxy.setSize(this.panel.getSize()); - } - this.panel.el.dom.style.display = 'none'; - } - }, - - // private - repair : function(xy, callback, scope){ - this.hide(); - if(typeof callback == "function"){ - callback.call(scope || this); - } - }, - - /** - * Moves the proxy to a different position in the DOM. This is typically called while dragging the Panel - * to keep the proxy sync'd to the Panel's location. - * @param {HTMLElement} parentNode The proxy's parent DOM node - * @param {HTMLElement} before (optional) The sibling node before which the proxy should be inserted (defaults - * to the parent's last child if not specified) - */ - moveProxy : function(parentNode, before){ - if(this.proxy){ - parentNode.insertBefore(this.proxy.dom, before); - } - } -}; - -// private - DD implementation for Panels -Ext.Panel.DD = function(panel, cfg){ - this.panel = panel; - this.dragData = {panel: panel}; - this.proxy = new Ext.dd.PanelProxy(panel, cfg); - Ext.Panel.DD.superclass.constructor.call(this, panel.el, cfg); - var h = panel.header; - if(h){ - this.setHandleElId(h.id); - } - (h ? h : this.panel.body).setStyle('cursor', 'move'); - this.scroll = false; -}; - -Ext.extend(Ext.Panel.DD, Ext.dd.DragSource, { - showFrame: Ext.emptyFn, - startDrag: Ext.emptyFn, - b4StartDrag: function(x, y) { - this.proxy.show(); - }, - b4MouseDown: function(e) { - var x = e.getPageX(); - var y = e.getPageY(); - this.autoOffset(x, y); - }, - onInitDrag : function(x, y){ - this.onStartDrag(x, y); - return true; - }, - createFrame : Ext.emptyFn, - getDragEl : function(e){ - return this.proxy.ghost.dom; - }, - endDrag : function(e){ - this.proxy.hide(); - this.panel.saveState(); - }, - - autoOffset : function(x, y) { - x -= this.startPageX; - y -= this.startPageY; - this.setDelta(x, y); - } -});/** - * @class Ext.state.Provider - * Abstract base class for state provider implementations. This class provides methods - * for encoding and decoding typed variables including dates and defines the - * Provider interface. - */ -Ext.state.Provider = function(){ - /** - * @event statechange - * Fires when a state change occurs. - * @param {Provider} this This state provider - * @param {String} key The state key which was changed - * @param {String} value The encoded value for the state - */ - this.addEvents("statechange"); - this.state = {}; - Ext.state.Provider.superclass.constructor.call(this); -}; -Ext.extend(Ext.state.Provider, Ext.util.Observable, { - /** - * Returns the current value for a key - * @param {String} name The key name - * @param {Mixed} defaultValue A default value to return if the key's value is not found - * @return {Mixed} The state data - */ - get : function(name, defaultValue){ - return typeof this.state[name] == "undefined" ? - defaultValue : this.state[name]; - }, - - /** - * Clears a value from the state - * @param {String} name The key name - */ - clear : function(name){ - delete this.state[name]; - this.fireEvent("statechange", this, name, null); - }, - - /** - * Sets the value for a key - * @param {String} name The key name - * @param {Mixed} value The value to set - */ - set : function(name, value){ - this.state[name] = value; - this.fireEvent("statechange", this, name, value); }, - /** - * Decodes a string previously encoded with {@link #encodeValue}. - * @param {String} value The value to decode - * @return {Mixed} The decoded value - */ - decodeValue : function(cookie){ - var re = /^(a|n|d|b|s|o)\:(.*)$/; - var matches = re.exec(unescape(cookie)); - if(!matches || !matches[1]) return; // non state cookie - var type = matches[1]; - var v = matches[2]; - switch(type){ - case "n": - return parseFloat(v); - case "d": - return new Date(Date.parse(v)); - case "b": - return (v == "1"); - case "a": - var all = []; - if(v != ''){ - Ext.each(v.split('^'), function(val){ - all.push(this.decodeValue(val)); - }, this); - } - return all; - case "o": - var all = {}; - if(v != ''){ - Ext.each(v.split('^'), function(val){ - var kv = val.split('='); - all[kv[0]] = this.decodeValue(kv[1]); - }, this); - } - return all; - default: - return v; + // private + renderIndent : function(deep, refresh){ + if(refresh){ + this.ui.childIndent = null; } - }, - - /** - * Encodes a value including type information. Decode with {@link #decodeValue}. - * @param {Mixed} value The value to encode - * @return {String} The encoded value - */ - encodeValue : function(v){ - var enc; - if(typeof v == "number"){ - enc = "n:" + v; - }else if(typeof v == "boolean"){ - enc = "b:" + (v ? "1" : "0"); - }else if(Ext.isDate(v)){ - enc = "d:" + v.toGMTString(); - }else if(Ext.isArray(v)){ - var flat = ""; - for(var i = 0, len = v.length; i < len; i++){ - flat += this.encodeValue(v[i]); - if(i != len-1) flat += "^"; - } - enc = "a:" + flat; - }else if(typeof v == "object"){ - var flat = ""; - for(var key in v){ - if(typeof v[key] != "function" && v[key] !== undefined){ - flat += key + "=" + this.encodeValue(v[key]) + "^"; - } + this.ui.renderIndent(); + if(deep === true && this.childrenRendered){ + var cs = this.childNodes; + for(var i = 0, len = cs.length; i < len; i++){ + cs[i].renderIndent(true, refresh); } - enc = "o:" + flat.substring(0, flat.length-1); - }else{ - enc = "s:" + v; } - return escape(enc); - } -}); -/** - * @class Ext.state.Manager - * This is the global state manager. By default all components that are "state aware" check this class - * for state information if you don't pass them a custom state provider. In order for this class - * to be useful, it must be initialized with a provider when your application initializes. Example usage: - -// in your initialization function -init : function(){ - Ext.state.Manager.setProvider(new Ext.state.CookieProvider()); - var win = new Window(...); - win.restoreState(); -} - - * @singleton - */ -Ext.state.Manager = function(){ - var provider = new Ext.state.Provider(); - - return { - /** - * Configures the default state provider for your application - * @param {Provider} stateProvider The state provider to set - */ - setProvider : function(stateProvider){ - provider = stateProvider; - }, - - /** - * Returns the current value for a key - * @param {String} name The key name - * @param {Mixed} defaultValue The default value to return if the key lookup does not match - * @return {Mixed} The state data - */ - get : function(key, defaultValue){ - return provider.get(key, defaultValue); - }, - - /** - * Sets the value for a key - * @param {String} name The key name - * @param {Mixed} value The state data - */ - set : function(key, value){ - provider.set(key, value); - }, - - /** - * Clears a value from the state - * @param {String} name The key name - */ - clear : function(key){ - provider.clear(key); - }, - - /** - * Gets the currently configured state provider - * @return {Provider} The state provider - */ - getProvider : function(){ - return provider; - } - }; -}(); -/** - * @class Ext.state.CookieProvider - * @extends Ext.state.Provider - * The default Provider implementation which saves state via cookies. - * Usage: - - var cp = new Ext.state.CookieProvider({ - path: "/cgi-bin/", - expires: new Date(new Date().getTime()+(1000*60*60*24*30)), //30 days - domain: "extjs.com" - }); - Ext.state.Manager.setProvider(cp); - - * @cfg {String} path The path for which the cookie is active (defaults to root '/' which makes it active for all pages in the site) - * @cfg {Date} expires The cookie expiration date (defaults to 7 days from now) - * @cfg {String} domain The domain to save the cookie for. Note that you cannot specify a different domain than - * your page is on, but you can specify a sub-domain, or simply the domain itself like 'extjs.com' to include - * all sub-domains if you need to access cookies across different sub-domains (defaults to null which uses the same - * domain the page is running on including the 'www' like 'www.extjs.com') - * @cfg {Boolean} secure True if the site is using SSL (defaults to false) - * @constructor - * Create a new CookieProvider - * @param {Object} config The configuration object - */ -Ext.state.CookieProvider = function(config){ - Ext.state.CookieProvider.superclass.constructor.call(this); - this.path = "/"; - this.expires = new Date(new Date().getTime()+(1000*60*60*24*7)); //7 days - this.domain = null; - this.secure = false; - Ext.apply(this, config); - this.state = this.readCookies(); -}; - -Ext.extend(Ext.state.CookieProvider, Ext.state.Provider, { - // private - set : function(name, value){ - if(typeof value == "undefined" || value === null){ - this.clear(name); - return; - } - this.setCookie(name, value); - Ext.state.CookieProvider.superclass.set.call(this, name, value); - }, - - // private - clear : function(name){ - this.clearCookie(name); - Ext.state.CookieProvider.superclass.clear.call(this, name); - }, - - // private - readCookies : function(){ - var cookies = {}; - var c = document.cookie + ";"; - var re = /\s?(.*?)=(.*?);/g; - var matches; - while((matches = re.exec(c)) != null){ - var name = matches[1]; - var value = matches[2]; - if(name && name.substring(0,3) == "ys-"){ - cookies[name.substr(3)] = this.decodeValue(value); - } - } - return cookies; - }, - - // private - setCookie : function(name, value){ - document.cookie = "ys-"+ name + "=" + this.encodeValue(value) + - ((this.expires == null) ? "" : ("; expires=" + this.expires.toGMTString())) + - ((this.path == null) ? "" : ("; path=" + this.path)) + - ((this.domain == null) ? "" : ("; domain=" + this.domain)) + - ((this.secure == true) ? "; secure" : ""); - }, - - // private - clearCookie : function(name){ - document.cookie = "ys-" + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" + - ((this.path == null) ? "" : ("; path=" + this.path)) + - ((this.domain == null) ? "" : ("; domain=" + this.domain)) + - ((this.secure == true) ? "; secure" : ""); - } -});/** - * @class Ext.DataView - * @extends Ext.BoxComponent - * A mechanism for displaying data using custom layout templates and formatting. DataView uses an {@link Ext.XTemplate} - * as its internal templating mechanism, and is bound to an {@link Ext.data.Store} - * so that as the data in the store changes the view is automatically updated to reflect the changes. The view also - * provides built-in behavior for many common events that can occur for its contained items including click, doubleclick, - * mouseover, mouseout, etc. as well as a built-in selection model. In order to use these features, an {@link #itemSelector} - * config must be provided for the DataView to determine what nodes it will be working with. - * - * The example below binds a DataView to a {@link Ext.data.Store} and renders it into an {@link Ext.Panel}. - * -var store = new Ext.data.JsonStore({ - url: 'get-images.php', - root: 'images', - fields: [ - 'name', 'url', - {name:'size', type: 'float'}, - {name:'lastmod', type:'date', dateFormat:'timestamp'} - ] -}); -store.load(); + }, -var tpl = new Ext.XTemplate( - '<tpl for=".">', - '<div class="thumb-wrap" id="{name}">', - '<div class="thumb"><img src="{url}" title="{name}"></div>', - '<span class="x-editable">{shortName}</span></div>', - '</tpl>', - '<div class="x-clear"></div>' -); + beginUpdate : function(){ + this.childrenRendered = false; + }, -var panel = new Ext.Panel({ - id:'images-view', - frame:true, - width:535, - autoHeight:true, - collapsible:true, - layout:'fit', - title:'Simple DataView', + endUpdate : function(){ + if(this.expanded && this.rendered){ + this.renderChildren(); + } + }, - items: new Ext.DataView({ - store: store, - tpl: tpl, - autoHeight:true, - multiSelect: true, - overClass:'x-view-over', - itemSelector:'div.thumb-wrap', - emptyText: 'No images to display' - }) + //inherit docs + destroy : function(silent){ + if(silent === true){ + this.unselect(true); + } + Ext.tree.TreeNode.superclass.destroy.call(this, silent); + Ext.destroy(this.ui, this.loader); + this.ui = this.loader = null; + }, + + // private + onIdChange : function(id){ + this.ui.onIdChange(id); + } }); -panel.render(document.body); - + +Ext.tree.TreePanel.nodeTypes.node = Ext.tree.TreeNode;/** + * @class Ext.tree.AsyncTreeNode + * @extends Ext.tree.TreeNode + * @cfg {TreeLoader} loader A TreeLoader to be used by this node (defaults to the loader defined on the tree) * @constructor - * Create a new DataView - * @param {Object} config The config object - * @xtype dataview + * @param {Object/String} attributes The attributes/config for the node or just a string with the text for the node */ -Ext.DataView = Ext.extend(Ext.BoxComponent, { - /** - * @cfg {String/Array} tpl - * The HTML fragment or an array of fragments that will make up the template used by this DataView. This should - * be specified in the same format expected by the constructor of {@link Ext.XTemplate}. - */ - /** - * @cfg {Ext.data.Store} store - * The {@link Ext.data.Store} to bind this DataView to. - */ - /** - * @cfg {String} itemSelector - * This is a required setting. A simple CSS selector (e.g. div.some-class or - * span:first-child) that will be used to determine what nodes this DataView will be - * working with. - */ - /** - * @cfg {Boolean} multiSelect - * True to allow selection of more than one item at a time, false to allow selection of only a single item - * at a time or no selection at all, depending on the value of {@link #singleSelect} (defaults to false). - */ - /** - * @cfg {Boolean} singleSelect - * True to allow selection of exactly one item at a time, false to allow no selection at all (defaults to false). - * Note that if {@link #multiSelect} = true, this value will be ignored. - */ - /** - * @cfg {Boolean} simpleSelect - * True to enable multiselection by clicking on multiple items without requiring the user to hold Shift or Ctrl, - * false to force the user to hold Ctrl or Shift to select more than on item (defaults to false). - */ + Ext.tree.AsyncTreeNode = function(config){ + this.loaded = config && config.loaded === true; + this.loading = false; + Ext.tree.AsyncTreeNode.superclass.constructor.apply(this, arguments); + /** + * @event beforeload + * Fires before this node is loaded, return false to cancel + * @param {Node} this This node + */ + this.addEvents('beforeload', 'load'); /** - * @cfg {String} overClass - * A CSS class to apply to each item in the view on mouseover (defaults to undefined). - */ + * @event load + * Fires when this node is loaded + * @param {Node} this This node + */ /** - * @cfg {String} loadingText - * A string to display during data load operations (defaults to undefined). If specified, this text will be - * displayed in a loading div and the view's contents will be cleared while loading, otherwise the view's - * contents will continue to display normally until the new data is loaded and the contents are replaced. + * The loader used by this node (defaults to using the tree's defined loader) + * @type TreeLoader + * @property loader */ +}; +Ext.extend(Ext.tree.AsyncTreeNode, Ext.tree.TreeNode, { + expand : function(deep, anim, callback, scope){ + if(this.loading){ // if an async load is already running, waiting til it's done + var timer; + var f = function(){ + if(!this.loading){ // done loading + clearInterval(timer); + this.expand(deep, anim, callback, scope); + } + }.createDelegate(this); + timer = setInterval(f, 200); + return; + } + if(!this.loaded){ + if(this.fireEvent("beforeload", this) === false){ + return; + } + this.loading = true; + this.ui.beforeLoad(this); + var loader = this.loader || this.attributes.loader || this.getOwnerTree().getLoader(); + if(loader){ + loader.load(this, this.loadComplete.createDelegate(this, [deep, anim, callback, scope]), this); + return; + } + } + Ext.tree.AsyncTreeNode.superclass.expand.call(this, deep, anim, callback, scope); + }, + /** - * @cfg {String} selectedClass - * A CSS class to apply to each selected item in the view (defaults to 'x-view-selected'). + * Returns true if this node is currently loading + * @return {Boolean} */ - selectedClass : "x-view-selected", + isLoading : function(){ + return this.loading; + }, + + loadComplete : function(deep, anim, callback, scope){ + this.loading = false; + this.loaded = true; + this.ui.afterLoad(this); + this.fireEvent("load", this); + this.expand(deep, anim, callback, scope); + }, + /** - * @cfg {String} emptyText - * The text to display in the view when there is no data to display (defaults to ''). + * Returns true if this node has been loaded + * @return {Boolean} */ - emptyText : "", + isLoaded : function(){ + return this.loaded; + }, + + hasChildNodes : function(){ + if(!this.isLeaf() && !this.loaded){ + return true; + }else{ + return Ext.tree.AsyncTreeNode.superclass.hasChildNodes.call(this); + } + }, /** - * @cfg {Boolean} deferEmptyText True to defer emptyText being applied until the store's first load - */ - deferEmptyText: true, - /** - * @cfg {Boolean} trackOver True to enable mouseenter and mouseleave events + * Trigger a reload for this node + * @param {Function} callback + * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Node. */ - trackOver: false, + reload : function(callback, scope){ + this.collapse(false, false); + while(this.firstChild){ + this.removeChild(this.firstChild).destroy(); + } + this.childrenRendered = false; + this.loaded = false; + if(this.isHiddenRoot()){ + this.expanded = false; + } + this.expand(false, false, callback, scope); + } +}); - //private - last: false, +Ext.tree.TreePanel.nodeTypes.async = Ext.tree.AsyncTreeNode;/** + * @class Ext.tree.TreeNodeUI + * This class provides the default UI implementation for Ext TreeNodes. + * The TreeNode UI implementation is separate from the + * tree implementation, and allows customizing of the appearance of + * tree nodes. + * + * If you are customizing the Tree's user interface, you + * may need to extend this class, but you should never need to instantiate this class. + * + * This class provides access to the user interface components of an Ext TreeNode, through + * {@link Ext.tree.TreeNode#getUI} + */ +Ext.tree.TreeNodeUI = function(node){ + this.node = node; + this.rendered = false; + this.animating = false; + this.wasLeaf = true; + this.ecc = 'x-tree-ec-icon x-tree-elbow'; + this.emptyIcon = Ext.BLANK_IMAGE_URL; +}; +Ext.tree.TreeNodeUI.prototype = { // private - initComponent : function(){ - Ext.DataView.superclass.initComponent.call(this); - if(Ext.isString(this.tpl) || Ext.isArray(this.tpl)){ - this.tpl = new Ext.XTemplate(this.tpl); + removeChild : function(node){ + if(this.rendered){ + this.ctNode.removeChild(node.ui.getEl()); } + }, - this.addEvents( - /** - * @event beforeclick - * Fires before a click is processed. Returns false to cancel the default action. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "beforeclick", - /** - * @event click - * Fires when a template node is clicked. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "click", - /** - * @event mouseenter - * Fires when the mouse enters a template node. trackOver:true or an overClass must be set to enable this event. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "mouseenter", - /** - * @event mouseleave - * Fires when the mouse leaves a template node. trackOver:true or an overClass must be set to enable this event. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "mouseleave", - /** - * @event containerclick - * Fires when a click occurs and it is not on a template node. - * @param {Ext.DataView} this - * @param {Ext.EventObject} e The raw event object - */ - "containerclick", - /** - * @event dblclick - * Fires when a template node is double clicked. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "dblclick", - /** - * @event contextmenu - * Fires when a template node is right clicked. - * @param {Ext.DataView} this - * @param {Number} index The index of the target node - * @param {HTMLElement} node The target node - * @param {Ext.EventObject} e The raw event object - */ - "contextmenu", - /** - * @event containercontextmenu - * Fires when a right click occurs that is not on a template node. - * @param {Ext.DataView} this - * @param {Ext.EventObject} e The raw event object - */ - "containercontextmenu", - /** - * @event selectionchange - * Fires when the selected nodes change. - * @param {Ext.DataView} this - * @param {Array} selections Array of the selected nodes - */ - "selectionchange", - - /** - * @event beforeselect - * Fires before a selection is made. If any handlers return false, the selection is cancelled. - * @param {Ext.DataView} this - * @param {HTMLElement} node The node to be selected - * @param {Array} selections Array of currently selected nodes - */ - "beforeselect" - ); - - this.store = Ext.StoreMgr.lookup(this.store); - this.all = new Ext.CompositeElementLite(); - this.selected = new Ext.CompositeElementLite(); + // private + beforeLoad : function(){ + this.addClass("x-tree-node-loading"); }, // private - afterRender : function(){ - Ext.DataView.superclass.afterRender.call(this); + afterLoad : function(){ + this.removeClass("x-tree-node-loading"); + }, - this.mon(this.getTemplateTarget(), { - "click": this.onClick, - "dblclick": this.onDblClick, - "contextmenu": this.onContextMenu, - scope:this - }); + // private + onTextChange : function(node, text, oldText){ + if(this.rendered){ + this.textNode.innerHTML = text; + } + }, - if(this.overClass || this.trackOver){ - this.mon(this.getTemplateTarget(), { - "mouseover": this.onMouseOver, - "mouseout": this.onMouseOut, - scope:this - }); + // private + onDisableChange : function(node, state){ + this.disabled = state; + if (this.checkbox) { + this.checkbox.disabled = state; + } + if(state){ + this.addClass("x-tree-node-disabled"); + }else{ + this.removeClass("x-tree-node-disabled"); } + }, - if(this.store){ - this.bindStore(this.store, true); + // private + onSelectedChange : function(state){ + if(state){ + this.focus(); + this.addClass("x-tree-selected"); + }else{ + //this.blur(); + this.removeClass("x-tree-selected"); } }, - /** - * Refreshes the view by reloading the data from the store and re-rendering the template. - */ - refresh : function(){ - this.clearSelections(false, true); - var el = this.getTemplateTarget(); - el.update(""); - var records = this.store.getRange(); - if(records.length < 1){ - if(!this.deferEmptyText || this.hasSkippedEmptyText){ - el.update(this.emptyText); + // private + onMove : function(tree, node, oldParent, newParent, index, refNode){ + this.childIndent = null; + if(this.rendered){ + var targetNode = newParent.ui.getContainer(); + if(!targetNode){//target not rendered + this.holder = document.createElement("div"); + this.holder.appendChild(this.wrap); + return; } - this.all.clear(); - }else{ - this.tpl.overwrite(el, this.collectData(records, 0)); - this.all.fill(Ext.query(this.itemSelector, el.dom)); - this.updateIndexes(0); + var insertBefore = refNode ? refNode.ui.getEl() : null; + if(insertBefore){ + targetNode.insertBefore(this.wrap, insertBefore); + }else{ + targetNode.appendChild(this.wrap); + } + this.node.renderIndent(true, oldParent != newParent); } - this.hasSkippedEmptyText = true; }, - getTemplateTarget: function(){ - return this.el; +/** + * Adds one or more CSS classes to the node's UI element. + * Duplicate classes are automatically filtered out. + * @param {String/Array} className The CSS class to add, or an array of classes + */ + addClass : function(cls){ + if(this.elNode){ + Ext.fly(this.elNode).addClass(cls); + } }, - /** - * Function which can be overridden to provide custom formatting for each Record that is used by this - * DataView's {@link #tpl template} to render each node. - * @param {Array/Object} data The raw data object that was used to create the Record. - * @param {Number} recordIndex the index number of the Record being prepared for rendering. - * @param {Record} record The Record being prepared for rendering. - * @return {Array/Object} The formatted data in a format expected by the internal {@link #tpl template}'s overwrite() method. - * (either an array if your params are numeric (i.e. {0}) or an object (i.e. {foo: 'bar'})) - */ - prepareData : function(data){ - return data; +/** + * Removes one or more CSS classes from the node's UI element. + * @param {String/Array} className The CSS class to remove, or an array of classes + */ + removeClass : function(cls){ + if(this.elNode){ + Ext.fly(this.elNode).removeClass(cls); + } }, - /** - * Function which can be overridden which returns the data object passed to this - * DataView's {@link #tpl template} to render the whole DataView. - * This is usually an Array of data objects, each element of which is processed by an - * {@link Ext.XTemplate XTemplate} which uses '<tpl for=".">' to iterate over its supplied - * data object as an Array. However, named properties may be placed into the data object to - * provide non-repeating data such as headings, totals etc. - * @param {Array} records An Array of {@link Ext.data.Record}s to be rendered into the DataView. - * @param {Number} startIndex the index number of the Record being prepared for rendering. - * @return {Array} An Array of data objects to be processed by a repeating XTemplate. May also - * contain named properties. - */ - collectData : function(records, startIndex){ - var r = []; - for(var i = 0, len = records.length; i < len; i++){ - r[r.length] = this.prepareData(records[i].data, startIndex+i, records[i]); + // private + remove : function(){ + if(this.rendered){ + this.holder = document.createElement("div"); + this.holder.appendChild(this.wrap); } - return r; }, // private - bufferRender : function(records){ - var div = document.createElement('div'); - this.tpl.overwrite(div, this.collectData(records)); - return Ext.query(this.itemSelector, div); + fireEvent : function(){ + return this.node.fireEvent.apply(this.node, arguments); }, // private - onUpdate : function(ds, record){ - var index = this.store.indexOf(record); - if(index > -1){ - var sel = this.isSelected(index); - var original = this.all.elements[index]; - var node = this.bufferRender([record], index)[0]; + initEvents : function(){ + this.node.on("move", this.onMove, this); - this.all.replaceElement(index, node, true); - if(sel){ - this.selected.replaceElement(original, node); - this.all.item(index).addClass(this.selectedClass); - } - this.updateIndexes(index, index); + if(this.node.disabled){ + this.onDisableChange(this.node, true); + } + if(this.node.hidden){ + this.hide(); + } + var ot = this.node.getOwnerTree(); + var dd = ot.enableDD || ot.enableDrag || ot.enableDrop; + if(dd && (!this.node.isRoot || ot.rootVisible)){ + Ext.dd.Registry.register(this.elNode, { + node: this.node, + handles: this.getDDHandles(), + isHandle: false + }); } }, // private - onAdd : function(ds, records, index){ - if(this.all.getCount() === 0){ - this.refresh(); + getDDHandles : function(){ + return [this.iconNode, this.textNode, this.elNode]; + }, + +/** + * Hides this node. + */ + hide : function(){ + this.node.hidden = true; + if(this.wrap){ + this.wrap.style.display = "none"; + } + }, + +/** + * Shows this node. + */ + show : function(){ + this.node.hidden = false; + if(this.wrap){ + this.wrap.style.display = ""; + } + }, + + // private + onContextMenu : function(e){ + if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) { + e.preventDefault(); + this.focus(); + this.fireEvent("contextmenu", this.node, e); + } + }, + + // private + onClick : function(e){ + if(this.dropping){ + e.stopEvent(); return; } - var nodes = this.bufferRender(records, index), n, a = this.all.elements; - if(index < this.all.getCount()){ - n = this.all.item(index).insertSibling(nodes, 'before', true); - a.splice.apply(a, [index, 0].concat(nodes)); + if(this.fireEvent("beforeclick", this.node, e) !== false){ + var a = e.getTarget('a'); + if(!this.disabled && this.node.attributes.href && a){ + this.fireEvent("click", this.node, e); + return; + }else if(a && e.ctrlKey){ + e.stopEvent(); + } + e.preventDefault(); + if(this.disabled){ + return; + } + + if(this.node.attributes.singleClickExpand && !this.animating && this.node.isExpandable()){ + this.node.toggle(); + } + + this.fireEvent("click", this.node, e); }else{ - n = this.all.last().insertSibling(nodes, 'after', true); - a.push.apply(a, nodes); + e.stopEvent(); } - this.updateIndexes(index); }, // private - onRemove : function(ds, record, index){ - this.deselect(index); - this.all.removeElement(index, true); - this.updateIndexes(index); - if (this.store.getCount() === 0){ - this.refresh(); + onDblClick : function(e){ + e.preventDefault(); + if(this.disabled){ + return; + } + if(this.fireEvent("beforedblclick", this.node, e) !== false){ + if(this.checkbox){ + this.toggleCheck(); + } + if(!this.animating && this.node.isExpandable()){ + this.node.toggle(); + } + this.fireEvent("dblclick", this.node, e); } }, - /** - * Refreshes an individual node's data from the store. - * @param {Number} index The item's data index in the store - */ - refreshNode : function(index){ - this.onUpdate(this.store, this.store.getAt(index)); + onOver : function(e){ + this.addClass('x-tree-node-over'); + }, + + onOut : function(e){ + this.removeClass('x-tree-node-over'); }, // private - updateIndexes : function(startIndex, endIndex){ - var ns = this.all.elements; - startIndex = startIndex || 0; - endIndex = endIndex || ((endIndex === 0) ? 0 : (ns.length - 1)); - for(var i = startIndex; i <= endIndex; i++){ - ns[i].viewIndex = i; + onCheckChange : function(){ + var checked = this.checkbox.checked; + // fix for IE6 + this.checkbox.defaultChecked = checked; + this.node.attributes.checked = checked; + this.fireEvent('checkchange', this.node, checked); + }, + + // private + ecClick : function(e){ + if(!this.animating && this.node.isExpandable()){ + this.node.toggle(); } }, - - /** - * Returns the store associated with this DataView. - * @return {Ext.data.Store} The store - */ - getStore : function(){ - return this.store; + + // private + startDrop : function(){ + this.dropping = true; }, - /** - * Changes the data store bound to this view and refreshes it. - * @param {Store} store The store to bind to this view - */ - bindStore : function(store, initial){ - if(!initial && this.store){ - if(store !== this.store && this.store.autoDestroy){ - this.store.destroy(); - }else{ - this.store.un("beforeload", this.onBeforeLoad, this); - this.store.un("datachanged", this.refresh, this); - this.store.un("add", this.onAdd, this); - this.store.un("remove", this.onRemove, this); - this.store.un("update", this.onUpdate, this); - this.store.un("clear", this.refresh, this); - } - if(!store){ - this.store = null; - } + // delayed drop so the click event doesn't get fired on a drop + endDrop : function(){ + setTimeout(function(){ + this.dropping = false; + }.createDelegate(this), 50); + }, + + // private + expand : function(){ + this.updateExpandIcon(); + this.ctNode.style.display = ""; + }, + + // private + focus : function(){ + if(!this.node.preventHScroll){ + try{this.anchor.focus(); + }catch(e){} + }else{ + try{ + var noscroll = this.node.getOwnerTree().getTreeEl().dom; + var l = noscroll.scrollLeft; + this.anchor.focus(); + noscroll.scrollLeft = l; + }catch(e){} } - if(store){ - store = Ext.StoreMgr.lookup(store); - store.on({ - scope: this, - beforeload: this.onBeforeLoad, - datachanged: this.refresh, - add: this.onAdd, - remove: this.onRemove, - update: this.onUpdate, - clear: this.refresh - }); + }, + +/** + * Sets the checked status of the tree node to the passed value, or, if no value was passed, + * toggles the checked status. If the node was rendered with no checkbox, this has no effect. + * @param {Boolean} value (optional) The new checked status. + */ + toggleCheck : function(value){ + var cb = this.checkbox; + if(cb){ + cb.checked = (value === undefined ? !cb.checked : value); + this.onCheckChange(); } - this.store = store; - if(store){ - this.refresh(); + }, + + // private + blur : function(){ + try{ + this.anchor.blur(); + }catch(e){} + }, + + // private + animExpand : function(callback){ + var ct = Ext.get(this.ctNode); + ct.stopFx(); + if(!this.node.isExpandable()){ + this.updateExpandIcon(); + this.ctNode.style.display = ""; + Ext.callback(callback); + return; } + this.animating = true; + this.updateExpandIcon(); + + ct.slideIn('t', { + callback : function(){ + this.animating = false; + Ext.callback(callback); + }, + scope: this, + duration: this.node.ownerTree.duration || .25 + }); + }, + + // private + highlight : function(){ + var tree = this.node.getOwnerTree(); + Ext.fly(this.wrap).highlight( + tree.hlColor || "C3DAF9", + {endColor: tree.hlBaseColor} + ); + }, + + // private + collapse : function(){ + this.updateExpandIcon(); + this.ctNode.style.display = "none"; + }, + + // private + animCollapse : function(callback){ + var ct = Ext.get(this.ctNode); + ct.enableDisplayMode('block'); + ct.stopFx(); + + this.animating = true; + this.updateExpandIcon(); + + ct.slideOut('t', { + callback : function(){ + this.animating = false; + Ext.callback(callback); + }, + scope: this, + duration: this.node.ownerTree.duration || .25 + }); + }, + + // private + getContainer : function(){ + return this.ctNode; }, - /** - * Returns the template node the passed child belongs to, or null if it doesn't belong to one. - * @param {HTMLElement} node - * @return {HTMLElement} The template node - */ - findItemFromChild : function(node){ - return Ext.fly(node).findParent(this.itemSelector, this.getTemplateTarget()); +/** + * Returns the element which encapsulates this node. + * @return {HtmlElement} The DOM element. The default implementation uses a <li>. + */ + getEl : function(){ + return this.wrap; }, // private - onClick : function(e){ - var item = e.getTarget(this.itemSelector, this.getTemplateTarget()); - if(item){ - var index = this.indexOf(item); - if(this.onItemClick(item, index, e) !== false){ - this.fireEvent("click", this, index, item, e); + appendDDGhost : function(ghostNode){ + ghostNode.appendChild(this.elNode.cloneNode(true)); + }, + + // private + getDDRepairXY : function(){ + return Ext.lib.Dom.getXY(this.iconNode); + }, + + // private + onRender : function(){ + this.render(); + }, + + // private + render : function(bulkRender){ + var n = this.node, a = n.attributes; + var targetNode = n.parentNode ? + n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom; + + if(!this.rendered){ + this.rendered = true; + + this.renderElements(n, a, targetNode, bulkRender); + + if(a.qtip){ + if(this.textNode.setAttributeNS){ + this.textNode.setAttributeNS("ext", "qtip", a.qtip); + if(a.qtipTitle){ + this.textNode.setAttributeNS("ext", "qtitle", a.qtipTitle); + } + }else{ + this.textNode.setAttribute("ext:qtip", a.qtip); + if(a.qtipTitle){ + this.textNode.setAttribute("ext:qtitle", a.qtipTitle); + } + } + }else if(a.qtipCfg){ + a.qtipCfg.target = Ext.id(this.textNode); + Ext.QuickTips.register(a.qtipCfg); + } + this.initEvents(); + if(!this.node.expanded){ + this.updateExpandIcon(true); } }else{ - if(this.fireEvent("containerclick", this, e) !== false){ - this.onContainerClick(e); + if(bulkRender === true) { + targetNode.appendChild(this.wrap); } } }, - onContainerClick : function(e){ - this.clearSelections(); - }, - // private - onContextMenu : function(e){ - var item = e.getTarget(this.itemSelector, this.getTemplateTarget()); - if(item){ - this.fireEvent("contextmenu", this, this.indexOf(item), item, e); + renderElements : function(n, a, targetNode, bulkRender){ + // add some indent caching, this helps performance when rendering a large tree + this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : ''; + + var cb = Ext.isBoolean(a.checked), + nel, + href = a.href ? a.href : Ext.isGecko ? "" : "#", + buf = ['', + '',this.indentMarkup,"", + '', + '', + cb ? ('' : '/>')) : '', + '',n.text,"", + '', + ""].join(''); + + if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){ + this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf); }else{ - this.fireEvent("containercontextmenu", this, e); + this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf); + } + + this.elNode = this.wrap.childNodes[0]; + this.ctNode = this.wrap.childNodes[1]; + var cs = this.elNode.childNodes; + this.indentNode = cs[0]; + this.ecNode = cs[1]; + this.iconNode = cs[2]; + var index = 3; + if(cb){ + this.checkbox = cs[3]; + // fix for IE6 + this.checkbox.defaultChecked = this.checkbox.checked; + index++; } + this.anchor = cs[index]; + this.textNode = cs[index].firstChild; + }, + +/** + * Returns the <a> element that provides focus for the node's UI. + * @return {HtmlElement} The DOM anchor element. + */ + getAnchor : function(){ + return this.anchor; + }, + +/** + * Returns the text node. + * @return {HtmlNode} The DOM text node. + */ + getTextEl : function(){ + return this.textNode; + }, + +/** + * Returns the icon <img> element. + * @return {HtmlElement} The DOM image element. + */ + getIconEl : function(){ + return this.iconNode; + }, + +/** + * Returns the checked status of the node. If the node was rendered with no + * checkbox, it returns false. + * @return {Boolean} The checked flag. + */ + isChecked : function(){ + return this.checkbox ? this.checkbox.checked : false; }, // private - onDblClick : function(e){ - var item = e.getTarget(this.itemSelector, this.getTemplateTarget()); - if(item){ - this.fireEvent("dblclick", this, this.indexOf(item), item, e); + updateExpandIcon : function(){ + if(this.rendered){ + var n = this.node, + c1, + c2, + cls = n.isLast() ? "x-tree-elbow-end" : "x-tree-elbow", + hasChild = n.hasChildNodes(); + if(hasChild || n.attributes.expandable){ + if(n.expanded){ + cls += "-minus"; + c1 = "x-tree-node-collapsed"; + c2 = "x-tree-node-expanded"; + }else{ + cls += "-plus"; + c1 = "x-tree-node-expanded"; + c2 = "x-tree-node-collapsed"; + } + if(this.wasLeaf){ + this.removeClass("x-tree-node-leaf"); + this.wasLeaf = false; + } + if(this.c1 != c1 || this.c2 != c2){ + Ext.fly(this.elNode).replaceClass(c1, c2); + this.c1 = c1; this.c2 = c2; + } + }else{ + if(!this.wasLeaf){ + Ext.fly(this.elNode).replaceClass("x-tree-node-expanded", "x-tree-node-collapsed"); + delete this.c1; + delete this.c2; + this.wasLeaf = true; + } + } + var ecc = "x-tree-ec-icon "+cls; + if(this.ecc != ecc){ + this.ecNode.className = ecc; + this.ecc = ecc; + } } }, // private - onMouseOver : function(e){ - var item = e.getTarget(this.itemSelector, this.getTemplateTarget()); - if(item && item !== this.lastItem){ - this.lastItem = item; - Ext.fly(item).addClass(this.overClass); - this.fireEvent("mouseenter", this, this.indexOf(item), item, e); + onIdChange: function(id){ + if(this.rendered){ + this.elNode.setAttribute('ext:tree-node-id', id); } }, // private - onMouseOut : function(e){ - if(this.lastItem){ - if(!e.within(this.lastItem, true, true)){ - Ext.fly(this.lastItem).removeClass(this.overClass); - this.fireEvent("mouseleave", this, this.indexOf(this.lastItem), this.lastItem, e); - delete this.lastItem; + getChildIndent : function(){ + if(!this.childIndent){ + var buf = [], + p = this.node; + while(p){ + if(!p.isRoot || (p.isRoot && p.ownerTree.rootVisible)){ + if(!p.isLast()) { + buf.unshift(''); + } else { + buf.unshift(''); + } + } + p = p.parentNode; } + this.childIndent = buf.join(""); } + return this.childIndent; }, // private - onItemClick : function(item, index, e){ - if(this.fireEvent("beforeclick", this, index, item, e) === false){ - return false; - } - if(this.multiSelect){ - this.doMultiSelection(item, index, e); - e.preventDefault(); - }else if(this.singleSelect){ - this.doSingleSelection(item, index, e); - e.preventDefault(); + renderIndent : function(){ + if(this.rendered){ + var indent = "", + p = this.node.parentNode; + if(p){ + indent = p.ui.getChildIndent(); + } + if(this.indentMarkup != indent){ // don't rerender if not required + this.indentNode.innerHTML = indent; + this.indentMarkup = indent; + } + this.updateExpandIcon(); } - return true; }, - // private - doSingleSelection : function(item, index, e){ - if(e.ctrlKey && this.isSelected(index)){ - this.deselect(index); - }else{ - this.select(index, false); + destroy : function(){ + if(this.elNode){ + Ext.dd.Registry.unregister(this.elNode.id); } - }, - // private - doMultiSelection : function(item, index, e){ - if(e.shiftKey && this.last !== false){ - var last = this.last; - this.selectRange(last, index, e.ctrlKey); - this.last = last; // reset the last - }else{ - if((e.ctrlKey||this.simpleSelect) && this.isSelected(index)){ - this.deselect(index); - }else{ - this.select(index, e.ctrlKey || e.shiftKey || this.simpleSelect); + Ext.each(['textnode', 'anchor', 'checkbox', 'indentNode', 'ecNode', 'iconNode', 'elNode', 'ctNode', 'wrap', 'holder'], function(el){ + if(this[el]){ + Ext.fly(this[el]).remove(); + delete this[el]; } + }, this); + delete this.node; + } +}; + +/** + * @class Ext.tree.RootTreeNodeUI + * This class provides the default UI implementation for root Ext TreeNodes. + * The RootTreeNode UI implementation allows customizing the appearance of the root tree node. + * + * If you are customizing the Tree's user interface, you + * may need to extend this class, but you should never need to instantiate this class. + */ +Ext.tree.RootTreeNodeUI = Ext.extend(Ext.tree.TreeNodeUI, { + // private + render : function(){ + if(!this.rendered){ + var targetNode = this.node.ownerTree.innerCt.dom; + this.node.expanded = true; + targetNode.innerHTML = ' '; + this.wrap = this.ctNode = targetNode.firstChild; } }, + collapse : Ext.emptyFn, + expand : Ext.emptyFn +});/** + * @class Ext.tree.TreeLoader + * @extends Ext.util.Observable + * A TreeLoader provides for lazy loading of an {@link Ext.tree.TreeNode}'s child + * nodes from a specified URL. The response must be a JavaScript Array definition + * whose elements are node definition objects. e.g.: + * + [{ + id: 1, + text: 'A leaf Node', + leaf: true + },{ + id: 2, + text: 'A folder Node', + children: [{ + id: 3, + text: 'A child Node', + leaf: true + }] + }] + + * + * A server request is sent, and child nodes are loaded only when a node is expanded. + * The loading node's id is passed to the server under the parameter name "node" to + * enable the server to produce the correct child nodes. + * + * To pass extra parameters, an event handler may be attached to the "beforeload" + * event, and the parameters specified in the TreeLoader's baseParams property: + * + myTreeLoader.on("beforeload", function(treeLoader, node) { + this.baseParams.category = node.attributes.category; + }, this); + + * This would pass an HTTP parameter called "category" to the server containing + * the value of the Node's "category" attribute. + * @constructor + * Creates a new Treeloader. + * @param {Object} config A config object containing config properties. + */ +Ext.tree.TreeLoader = function(config){ + this.baseParams = {}; + Ext.apply(this, config); + + this.addEvents( + /** + * @event beforeload + * Fires before a network request is made to retrieve the Json text which specifies a node's children. + * @param {Object} This TreeLoader object. + * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. + * @param {Object} callback The callback function specified in the {@link #load} call. + */ + "beforeload", + /** + * @event load + * Fires when the node has been successfuly loaded. + * @param {Object} This TreeLoader object. + * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. + * @param {Object} response The response object containing the data from the server. + */ + "load", + /** + * @event loadexception + * Fires if the network request failed. + * @param {Object} This TreeLoader object. + * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. + * @param {Object} response The response object containing the data from the server. + */ + "loadexception" + ); + Ext.tree.TreeLoader.superclass.constructor.call(this); + if(Ext.isString(this.paramOrder)){ + this.paramOrder = this.paramOrder.split(/[\s,|]/); + } +}; +Ext.extend(Ext.tree.TreeLoader, Ext.util.Observable, { /** - * Gets the number of selected nodes. - * @return {Number} The node count + * @cfg {String} dataUrl The URL from which to request a Json string which + * specifies an array of node definition objects representing the child nodes + * to be loaded. + */ + /** + * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}). */ - getSelectionCount : function(){ - return this.selected.getCount(); - }, - /** - * Gets the currently selected nodes. - * @return {Array} An array of HTMLElements + * @cfg {String} url Equivalent to {@link #dataUrl}. */ - getSelectedNodes : function(){ - return this.selected.elements; - }, - /** - * Gets the indexes of the selected nodes. - * @return {Array} An array of numeric indexes + * @cfg {Boolean} preloadChildren If set to true, the loader recursively loads "children" attributes when doing the first load on nodes. */ - getSelectedIndexes : function(){ - var indexes = [], s = this.selected.elements; - for(var i = 0, len = s.length; i < len; i++){ - indexes.push(s[i].viewIndex); - } - return indexes; - }, + /** + * @cfg {Object} baseParams (optional) An object containing properties which + * specify HTTP parameters to be passed to each request for child nodes. + */ + /** + * @cfg {Object} baseAttrs (optional) An object containing attributes to be added to all nodes + * created by this loader. If the attributes sent by the server have an attribute in this object, + * they take priority. + */ + /** + * @cfg {Object} uiProviders (optional) An object containing properties which + * specify custom {@link Ext.tree.TreeNodeUI} implementations. If the optional + * uiProvider attribute of a returned child node is a string rather + * than a reference to a TreeNodeUI implementation, then that string value + * is used as a property name in the uiProviders object. + */ + uiProviders : {}, /** - * Gets an array of the selected records - * @return {Array} An array of {@link Ext.data.Record} objects - */ - getSelectedRecords : function(){ - var r = [], s = this.selected.elements; - for(var i = 0, len = s.length; i < len; i++){ - r[r.length] = this.store.getAt(s[i].viewIndex); - } - return r; - }, + * @cfg {Boolean} clearOnLoad (optional) Default to true. Remove previously existing + * child nodes before loading. + */ + clearOnLoad : true, /** - * Gets an array of the records from an array of nodes - * @param {Array} nodes The nodes to evaluate - * @return {Array} records The {@link Ext.data.Record} objects + * @cfg {Array/String} paramOrder Defaults to undefined. Only used when using directFn. + * Specifies the params in the order in which they must be passed to the server-side Direct method + * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, + * comma, or pipe. For example, + * any of the following would be acceptable: +nodeParameter: 'node', +paramOrder: ['param1','param2','param3'] +paramOrder: 'node param1 param2 param3' +paramOrder: 'param1,node,param2,param3' +paramOrder: 'param1|param2|param|node' + */ - getRecords : function(nodes){ - var r = [], s = nodes; - for(var i = 0, len = s.length; i < len; i++){ - r[r.length] = this.store.getAt(s[i].viewIndex); - } - return r; - }, + paramOrder: undefined, /** - * Gets a record from a node - * @param {HTMLElement} node The node to evaluate - * @return {Record} record The {@link Ext.data.Record} object + * @cfg {Boolean} paramsAsHash Only used when using directFn. + * Send parameters as a collection of named arguments (defaults to false). Providing a + * {@link #paramOrder} nullifies this configuration. */ - getRecord : function(node){ - return this.store.getAt(node.viewIndex); - }, + paramsAsHash: false, /** - * Clears all selections. - * @param {Boolean} suppressEvent (optional) True to skip firing of the selectionchange event + * @cfg {String} nodeParameter The name of the parameter sent to the server which contains + * the identifier of the node. Defaults to 'node'. */ - clearSelections : function(suppressEvent, skipUpdate){ - if((this.multiSelect || this.singleSelect) && this.selected.getCount() > 0){ - if(!skipUpdate){ - this.selected.removeClass(this.selectedClass); - } - this.selected.clear(); - this.last = false; - if(!suppressEvent){ - this.fireEvent("selectionchange", this, this.selected.elements); - } - } - }, + nodeParameter: 'node', /** - * Returns true if the passed node is selected, else false. - * @param {HTMLElement/Number} node The node or node index to check - * @return {Boolean} True if selected, else false + * @cfg {Function} directFn + * Function to call when executing a request. */ - isSelected : function(node){ - return this.selected.contains(this.getNode(node)); - }, + directFn : undefined, /** - * Deselects a node. - * @param {HTMLElement/Number} node The node to deselect + * Load an {@link Ext.tree.TreeNode} from the URL specified in the constructor. + * This is called automatically when a node is expanded, but may be used to reload + * a node (or append new children if the {@link #clearOnLoad} option is false.) + * @param {Ext.tree.TreeNode} node + * @param {Function} callback Function to call after the node has been loaded. The + * function is passed the TreeNode which was requested to be loaded. + * @param {Object} scope The scope (this reference) in which the callback is executed. + * defaults to the loaded TreeNode. */ - deselect : function(node){ - if(this.isSelected(node)){ - node = this.getNode(node); - this.selected.removeElement(node); - if(this.last == node.viewIndex){ - this.last = false; + load : function(node, callback, scope){ + if(this.clearOnLoad){ + while(node.firstChild){ + node.removeChild(node.firstChild); } - Ext.fly(node).removeClass(this.selectedClass); - this.fireEvent("selectionchange", this, this.selected.elements); + } + if(this.doPreload(node)){ // preloaded json children + this.runCallback(callback, scope || node, [node]); + }else if(this.directFn || this.dataUrl || this.url){ + this.requestData(node, callback, scope || node); } }, - /** - * Selects a set of nodes. - * @param {Array/HTMLElement/String/Number} nodeInfo An HTMLElement template node, index of a template node, - * id of a template node or an array of any of those to select - * @param {Boolean} keepExisting (optional) true to keep existing selections - * @param {Boolean} suppressEvent (optional) true to skip firing of the selectionchange vent - */ - select : function(nodeInfo, keepExisting, suppressEvent){ - if(Ext.isArray(nodeInfo)){ - if(!keepExisting){ - this.clearSelections(true); - } - for(var i = 0, len = nodeInfo.length; i < len; i++){ - this.select(nodeInfo[i], true, true); - } - if(!suppressEvent){ - this.fireEvent("selectionchange", this, this.selected.elements); - } - } else{ - var node = this.getNode(nodeInfo); - if(!keepExisting){ - this.clearSelections(true); - } - if(node && !this.isSelected(node)){ - if(this.fireEvent("beforeselect", this, node, this.selected.elements) !== false){ - Ext.fly(node).addClass(this.selectedClass); - this.selected.add(node); - this.last = node.viewIndex; - if(!suppressEvent){ - this.fireEvent("selectionchange", this, this.selected.elements); + doPreload : function(node){ + if(node.attributes.children){ + if(node.childNodes.length < 1){ // preloaded? + var cs = node.attributes.children; + node.beginUpdate(); + for(var i = 0, len = cs.length; i < len; i++){ + var cn = node.appendChild(this.createNode(cs[i])); + if(this.preloadChildren){ + this.doPreload(cn); } } + node.endUpdate(); } + return true; } + return false; }, - /** - * Selects a range of nodes. All nodes between start and end are selected. - * @param {Number} start The index of the first node in the range - * @param {Number} end The index of the last node in the range - * @param {Boolean} keepExisting (optional) True to retain existing selections - */ - selectRange : function(start, end, keepExisting){ - if(!keepExisting){ - this.clearSelections(true); - } - this.select(this.getNodes(start, end), true); - }, + getParams: function(node){ + var bp = Ext.apply({}, this.baseParams), + np = this.nodeParameter, + po = this.paramOrder; - /** - * Gets a template node. - * @param {HTMLElement/String/Number} nodeInfo An HTMLElement template node, index of a template node or the id of a template node - * @return {HTMLElement} The node or null if it wasn't found - */ - getNode : function(nodeInfo){ - if(Ext.isString(nodeInfo)){ - return document.getElementById(nodeInfo); - }else if(Ext.isNumber(nodeInfo)){ - return this.all.elements[nodeInfo]; + np && (bp[ np ] = node.id); + + if(this.directFn){ + var buf = [node.id]; + if(po){ + // reset 'buf' if the nodeParameter was included in paramOrder + if(np && po.indexOf(np) > -1){ + buf = []; + } + + for(var i = 0, len = po.length; i < len; i++){ + buf.push(bp[ po[i] ]); + } + }else if(this.paramsAsHash){ + buf = [bp]; + } + return buf; + }else{ + return bp; } - return nodeInfo; }, - /** - * Gets a range nodes. - * @param {Number} start (optional) The index of the first node in the range - * @param {Number} end (optional) The index of the last node in the range - * @return {Array} An array of nodes - */ - getNodes : function(start, end){ - var ns = this.all.elements; - start = start || 0; - end = !Ext.isDefined(end) ? Math.max(ns.length - 1, 0) : end; - var nodes = [], i; - if(start <= end){ - for(i = start; i <= end && ns[i]; i++){ - nodes.push(ns[i]); - } - } else{ - for(i = start; i >= end && ns[i]; i--){ - nodes.push(ns[i]); + requestData : function(node, callback, scope){ + if(this.fireEvent("beforeload", this, node, callback) !== false){ + if(this.directFn){ + var args = this.getParams(node); + args.push(this.processDirectResponse.createDelegate(this, [{callback: callback, node: node, scope: scope}], true)); + this.directFn.apply(window, args); + }else{ + this.transId = Ext.Ajax.request({ + method:this.requestMethod, + url: this.dataUrl||this.url, + success: this.handleResponse, + failure: this.handleFailure, + scope: this, + argument: {callback: callback, node: node, scope: scope}, + params: this.getParams(node) + }); } + }else{ + // if the load is cancelled, make sure we notify + // the node that we are done + this.runCallback(callback, scope || node, []); } - return nodes; }, - /** - * Finds the index of the passed node. - * @param {HTMLElement/String/Number} nodeInfo An HTMLElement template node, index of a template node or the id of a template node - * @return {Number} The index of the node or -1 - */ - indexOf : function(node){ - node = this.getNode(node); - if(Ext.isNumber(node.viewIndex)){ - return node.viewIndex; + processDirectResponse: function(result, response, args){ + if(response.status){ + this.handleResponse({ + responseData: Ext.isArray(result) ? result : null, + responseText: result, + argument: args + }); + }else{ + this.handleFailure({ + argument: args + }); } - return this.all.indexOf(node); }, // private - onBeforeLoad : function(){ - if(this.loadingText){ - this.clearSelections(false, true); - this.getTemplateTarget().update(''+this.loadingText+''); - this.all.clear(); + runCallback: function(cb, scope, args){ + if(Ext.isFunction(cb)){ + cb.apply(scope, args); } }, - onDestroy : function(){ - this.all.clear(); - this.selected.clear(); - Ext.DataView.superclass.onDestroy.call(this); - this.bindStore(null); - } -}); - -/** - * Changes the data store bound to this view and refreshes it. (deprecated in favor of bindStore) - * @param {Store} store The store to bind to this view - */ -Ext.DataView.prototype.setStore = Ext.DataView.prototype.bindStore; - -Ext.reg('dataview', Ext.DataView); -/** - * @class Ext.list.ListView - * @extends Ext.DataView - * Ext.list.ListView is a fast and light-weight implentation of a - * {@link Ext.grid.GridPanel Grid} like view with the following characteristics: - * - * resizable columns - * selectable - * column widths are initially proportioned by percentage based on the container - * width and number of columns - * uses templates to render the data in any required format - * no horizontal scrolling - * no editing - * - * Example usage: - * -// consume JSON of this form: -{ - "images":[ - { - "name":"dance_fever.jpg", - "size":2067, - "lastmod":1236974993000, - "url":"images\/thumbs\/dance_fever.jpg" - }, - { - "name":"zack_sink.jpg", - "size":2303, - "lastmod":1236974993000, - "url":"images\/thumbs\/zack_sink.jpg" - } - ] -} -var store = new Ext.data.JsonStore({ - url: 'get-images.php', - root: 'images', - fields: [ - 'name', 'url', - {name:'size', type: 'float'}, - {name:'lastmod', type:'date', dateFormat:'timestamp'} - ] -}); -store.load(); - -var listView = new Ext.list.ListView({ - store: store, - multiSelect: true, - emptyText: 'No images to display', - reserveScrollOffset: true, - columns: [{ - header: 'File', - width: .5, - dataIndex: 'name' - },{ - header: 'Last Modified', - width: .35, - dataIndex: 'lastmod', - tpl: '{lastmod:date("m-d h:i a")}' - },{ - header: 'Size', - dataIndex: 'size', - tpl: '{size:fileSize}', // format using Ext.util.Format.fileSize() - align: 'right' - }] -}); - -// put it in a Panel so it looks pretty -var panel = new Ext.Panel({ - id:'images-view', - width:425, - height:250, - collapsible:true, - layout:'fit', - title:'Simple ListView (0 items selected)', - items: listView -}); -panel.render(document.body); - -// little bit of feedback -listView.on('selectionchange', function(view, nodes){ - var l = nodes.length; - var s = l != 1 ? 's' : ''; - panel.setTitle('Simple ListView ('+l+' item'+s+' selected)'); -}); - * - * @constructor - * @param {Object} config - * @xtype listview - */ -Ext.list.ListView = Ext.extend(Ext.DataView, { - /** - * Set this property to true to disable the header click handler disabling sort - * (defaults to false). - * @type Boolean - * @property disableHeaders - */ - /** - * @cfg {Boolean} hideHeaders - * true to hide the {@link #internalTpl header row} (defaults to false so - * the {@link #internalTpl header row} will be shown). - */ - /** - * @cfg {String} itemSelector - * Defaults to 'dl' to work with the preconfigured {@link Ext.DataView#tpl tpl}. - * This setting specifies the CSS selector (e.g. div.some-class or span:first-child) - * that will be used to determine what nodes the ListView will be working with. - */ - itemSelector: 'dl', - /** - * @cfg {String} selectedClass The CSS class applied to a selected row (defaults to - * 'x-list-selected'). An example overriding the default styling: - - .x-list-selected {background-color: yellow;} - - * @type String - */ - selectedClass:'x-list-selected', - /** - * @cfg {String} overClass The CSS class applied when over a row (defaults to - * 'x-list-over'). An example overriding the default styling: - - .x-list-over {background-color: orange;} - - * @type String - */ - overClass:'x-list-over', - /** - * @cfg {Boolean} reserveScrollOffset - * By default will defer accounting for the configured {@link #scrollOffset} - * for 10 milliseconds. Specify true to account for the configured - * {@link #scrollOffset} immediately. - */ - /** - * @cfg {Number} scrollOffset The amount of space to reserve for the scrollbar (defaults to - * undefined). If an explicit value isn't specified, this will be automatically - * calculated. - */ - scrollOffset : undefined, - /** - * @cfg {Boolean/Object} columnResize - * Specify true or specify a configuration object for {@link Ext.list.ListView.ColumnResizer} - * to enable the columns to be resizable (defaults to true). - */ - columnResize: true, - /** - * @cfg {Array} columns An array of column configuration objects, for example: - * -{ - align: 'right', - dataIndex: 'size', - header: 'Size', - tpl: '{size:fileSize}', - width: .35 -} - * - * Acceptable properties for each column configuration object are: - * - * align : StringSet the CSS text-align property - * of the column. Defaults to 'left'. - * dataIndex : StringSee {@link Ext.grid.Column}. - * {@link Ext.grid.Column#dataIndex dataIndex} for details. - * header : StringSee {@link Ext.grid.Column}. - * {@link Ext.grid.Column#header header} for details. - * tpl : StringSpecify a string to pass as the - * configuration string for {@link Ext.XTemplate}. By default an {@link Ext.XTemplate} - * will be implicitly created using the dataIndex. - * width : NumberPercentage of the container width - * this column should be allocated. Columns that have no width specified will be - * allocated with an equal percentage to fill 100% of the container width. To easily take - * advantage of the full container width, leave the width of at least one column undefined. - * Note that if you do not want to take up the full width of the container, the width of - * every column needs to be explicitly defined. - * - */ - /** - * @cfg {Boolean/Object} columnSort - * Specify true or specify a configuration object for {@link Ext.list.ListView.Sorter} - * to enable the columns to be sortable (defaults to true). - */ - columnSort: true, - /** - * @cfg {String/Array} internalTpl - * The template to be used for the header row. See {@link #tpl} for more details. - */ - - /* - * IE has issues when setting percentage based widths to 100%. Default to 99. - */ - maxWidth: Ext.isIE ? 99 : 100, - - initComponent : function(){ - if(this.columnResize){ - this.colResizer = new Ext.list.ColumnResizer(this.colResizer); - this.colResizer.init(this); - } - if(this.columnSort){ - this.colSorter = new Ext.list.Sorter(this.columnSort); - this.colSorter.init(this); - } - if(!this.internalTpl){ - this.internalTpl = new Ext.XTemplate( - '', - '', - '', - '{header}', - '', - '', - '', - '', - '', - '' - ); - } - if(!this.tpl){ - this.tpl = new Ext.XTemplate( - '', - '', - '', - '', - ' class="{cls}">', - '{[values.tpl.apply(parent)]}', - '', - '', - '', - '', - '' - ); - }; - - var cs = this.columns, - allocatedWidth = 0, - colsWithWidth = 0, - len = cs.length, - columns = []; - - for(var i = 0; i < len; i++){ - var c = cs[i]; - if(!c.isColumn) { - c.xtype = c.xtype ? (/^lv/.test(c.xtype) ? c.xtype : 'lv' + c.xtype) : 'lvcolumn'; - c = Ext.create(c); - } - if(c.width) { - allocatedWidth += c.width*100; - colsWithWidth++; - } - columns.push(c); - } - - cs = this.columns = columns; - - // auto calculate missing column widths - if(colsWithWidth < len){ - var remaining = len - colsWithWidth; - if(allocatedWidth < this.maxWidth){ - var perCol = ((this.maxWidth-allocatedWidth) / remaining)/100; - for(var j = 0; j < len; j++){ - var c = cs[j]; - if(!c.width){ - c.width = perCol; - } - } - } - } - Ext.list.ListView.superclass.initComponent.call(this); - }, - - onRender : function(){ - this.autoEl = { - cls: 'x-list-wrap' - }; - Ext.list.ListView.superclass.onRender.apply(this, arguments); - - this.internalTpl.overwrite(this.el, {columns: this.columns}); - - this.innerBody = Ext.get(this.el.dom.childNodes[1].firstChild); - this.innerHd = Ext.get(this.el.dom.firstChild.firstChild); - - if(this.hideHeaders){ - this.el.dom.firstChild.style.display = 'none'; - } - }, - - getTemplateTarget : function(){ - return this.innerBody; - }, - - /** - * Function which can be overridden which returns the data object passed to this - * view's {@link #tpl template} to render the whole ListView. The returned object - * shall contain the following properties: - * - * columns : StringSee {@link #columns} - * rows : StringSee - * {@link Ext.DataView}.{@link Ext.DataView#collectData collectData} - * - * @param {Array} records An Array of {@link Ext.data.Record}s to be rendered into the DataView. - * @param {Number} startIndex the index number of the Record being prepared for rendering. - * @return {Object} A data object containing properties to be processed by a repeating - * XTemplate as described above. - */ - collectData : function(){ - var rs = Ext.list.ListView.superclass.collectData.apply(this, arguments); - return { - columns: this.columns, - rows: rs - } - }, - - verifyInternalSize : function(){ - if(this.lastSize){ - this.onResize(this.lastSize.width, this.lastSize.height); - } - }, - - // private - onResize : function(w, h){ - var bd = this.innerBody.dom; - var hd = this.innerHd.dom - if(!bd){ - return; - } - var bdp = bd.parentNode; - if(Ext.isNumber(w)){ - var sw = w - Ext.num(this.scrollOffset, Ext.getScrollBarWidth()); - if(this.reserveScrollOffset || ((bdp.offsetWidth - bdp.clientWidth) > 10)){ - bd.style.width = sw + 'px'; - hd.style.width = sw + 'px'; - }else{ - bd.style.width = w + 'px'; - hd.style.width = w + 'px'; - setTimeout(function(){ - if((bdp.offsetWidth - bdp.clientWidth) > 10){ - bd.style.width = sw + 'px'; - hd.style.width = sw + 'px'; - } - }, 10); - } - } - if(Ext.isNumber(h)){ - bdp.style.height = (h - hd.parentNode.offsetHeight) + 'px'; - } - }, - - updateIndexes : function(){ - Ext.list.ListView.superclass.updateIndexes.apply(this, arguments); - this.verifyInternalSize(); - }, - - findHeaderIndex : function(hd){ - hd = hd.dom || hd; - var pn = hd.parentNode, cs = pn.parentNode.childNodes; - for(var i = 0, c; c = cs[i]; i++){ - if(c == pn){ - return i; - } - } - return -1; - }, - - setHdWidths : function(){ - var els = this.innerHd.dom.getElementsByTagName('div'); - for(var i = 0, cs = this.columns, len = cs.length; i < len; i++){ - els[i].style.width = (cs[i].width*100) + '%'; - } - } -}); - -Ext.reg('listview', Ext.list.ListView); - -// Backwards compatibility alias -Ext.ListView = Ext.list.ListView;/** - * @class Ext.list.Column - * This class encapsulates column configuration data to be used in the initialization of a - * {@link Ext.list.ListView ListView}. - * While subclasses are provided to render data in different ways, this class renders a passed - * data field unchanged and is usually used for textual columns. - */ -Ext.list.Column = Ext.extend(Object, { - /** - * @private - * @cfg {Boolean} isColumn - * Used by ListView constructor method to avoid reprocessing a Column - * if isColumn is not set ListView will recreate a new Ext.list.Column - * Defaults to true. - */ - isColumn: true, - - /** - * @cfg {String} align - * Set the CSS text-align property of the column. Defaults to 'left'. - */ - align: 'left', - /** - * @cfg {String} header Optional. The header text to be used as innerHTML - * (html tags are accepted) to display in the ListView. Note: to - * have a clickable header with no text displayed use ' '. - */ - header: '', - - /** - * @cfg {Number} width Optional. Percentage of the container width - * this column should be allocated. Columns that have no width specified will be - * allocated with an equal percentage to fill 100% of the container width. To easily take - * advantage of the full container width, leave the width of at least one column undefined. - * Note that if you do not want to take up the full width of the container, the width of - * every column needs to be explicitly defined. - */ - width: null, + isLoading : function(){ + return !!this.transId; + }, - /** - * @cfg {String} cls Optional. This option can be used to add a CSS class to the cell of each - * row for this column. - */ - cls: '', - - /** - * @cfg {String} tpl Optional. Specify a string to pass as the - * configuration string for {@link Ext.XTemplate}. By default an {@link Ext.XTemplate} - * will be implicitly created using the dataIndex. - */ + abort : function(){ + if(this.isLoading()){ + Ext.Ajax.abort(this.transId); + } + }, /** - * @cfg {String} dataIndex Required. The name of the field in the - * ListViews's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from - * which to draw the column's value. - */ - - constructor : function(c){ - if(!c.tpl){ - c.tpl = new Ext.XTemplate('{' + c.dataIndex + '}'); - } - else if(Ext.isString(c.tpl)){ - c.tpl = new Ext.XTemplate(c.tpl); + * Override this function for custom TreeNode node implementation, or to + * modify the attributes at creation time. + * Example: +new Ext.tree.TreePanel({ + ... + loader: new Ext.tree.TreeLoader({ + url: 'dataUrl', + createNode: function(attr) { +// Allow consolidation consignments to have +// consignments dropped into them. + if (attr.isConsolidation) { + attr.iconCls = 'x-consol', + attr.allowDrop = true; + } + return Ext.tree.TreeLoader.prototype.createNode.call(this, attr); } - - Ext.apply(this, c); - } + }), + ... }); + + * @param attr {Object} The attributes from which to create the new node. + */ + createNode : function(attr){ + // apply baseAttrs, nice idea Corey! + if(this.baseAttrs){ + Ext.applyIf(attr, this.baseAttrs); + } + if(this.applyLoader !== false && !attr.loader){ + attr.loader = this; + } + if(Ext.isString(attr.uiProvider)){ + attr.uiProvider = this.uiProviders[attr.uiProvider] || eval(attr.uiProvider); + } + if(attr.nodeType){ + return new Ext.tree.TreePanel.nodeTypes[attr.nodeType](attr); + }else{ + return attr.leaf ? + new Ext.tree.TreeNode(attr) : + new Ext.tree.AsyncTreeNode(attr); + } + }, -Ext.reg('lvcolumn', Ext.list.Column); + processResponse : function(response, node, callback, scope){ + var json = response.responseText; + try { + var o = response.responseData || Ext.decode(json); + node.beginUpdate(); + for(var i = 0, len = o.length; i < len; i++){ + var n = this.createNode(o[i]); + if(n){ + node.appendChild(n); + } + } + node.endUpdate(); + this.runCallback(callback, scope || node, [node]); + }catch(e){ + this.handleFailure(response); + } + }, -/** - * @class Ext.list.NumberColumn - * @extends Ext.list.Column - * A Column definition class which renders a numeric data field according to a {@link #format} string. See the - * {@link Ext.list.Column#xtype xtype} config option of {@link Ext.list.Column} for more details. - */ -Ext.list.NumberColumn = Ext.extend(Ext.list.Column, { - /** - * @cfg {String} format - * A formatting string as used by {@link Ext.util.Format#number} to format a numeric value for this Column - * (defaults to '0,000.00'). - */ - format: '0,000.00', - - constructor : function(c) { - c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':number("' + (c.format || this.format) + '")}'); - Ext.list.NumberColumn.superclass.constructor.call(this, c); - } -}); + handleResponse : function(response){ + this.transId = false; + var a = response.argument; + this.processResponse(response, a.node, a.callback, a.scope); + this.fireEvent("load", this, a.node, response); + }, -Ext.reg('lvnumbercolumn', Ext.list.NumberColumn); + handleFailure : function(response){ + this.transId = false; + var a = response.argument; + this.fireEvent("loadexception", this, a.node, response); + this.runCallback(a.callback, a.scope || a.node, [a.node]); + }, -/** - * @class Ext.list.DateColumn - * @extends Ext.list.Column - * A Column definition class which renders a passed date according to the default locale, or a configured - * {@link #format}. See the {@link Ext.list.Column#xtype xtype} config option of {@link Ext.list.Column} - * for more details. - */ -Ext.list.DateColumn = Ext.extend(Ext.list.Column, { - format: 'm/d/Y', - constructor : function(c) { - c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':date("' + (c.format || this.format) + '")}'); - Ext.list.DateColumn.superclass.constructor.call(this, c); + destroy : function(){ + this.abort(); + this.purgeListeners(); } -}); -Ext.reg('lvdatecolumn', Ext.list.DateColumn); +});/** + * @class Ext.tree.TreeFilter + * Note this class is experimental and doesn't update the indent (lines) or expand collapse icons of the nodes + * @param {TreePanel} tree + * @param {Object} config (optional) + */ +Ext.tree.TreeFilter = function(tree, config){ + this.tree = tree; + this.filtered = {}; + Ext.apply(this, config); +}; + +Ext.tree.TreeFilter.prototype = { + clearBlank:false, + reverse:false, + autoClear:false, + remove:false, -/** - * @class Ext.list.BooleanColumn - * @extends Ext.list.Column - * A Column definition class which renders boolean data fields. See the {@link Ext.list.Column#xtype xtype} - * config option of {@link Ext.list.Column} for more details. - */ -Ext.list.BooleanColumn = Ext.extend(Ext.list.Column, { - /** - * @cfg {String} trueText - * The string returned by the renderer when the column value is not falsey (defaults to 'true'). - */ - trueText: 'true', - /** - * @cfg {String} falseText - * The string returned by the renderer when the column value is falsey (but not undefined) (defaults to - * 'false'). + /** + * Filter the data by a specific attribute. + * @param {String/RegExp} value Either string that the attribute value + * should start with or a RegExp to test against the attribute + * @param {String} attr (optional) The attribute passed in your node's attributes collection. Defaults to "text". + * @param {TreeNode} startNode (optional) The node to start the filter at. */ - falseText: 'false', + filter : function(value, attr, startNode){ + attr = attr || "text"; + var f; + if(typeof value == "string"){ + var vlen = value.length; + // auto clear empty filter + if(vlen == 0 && this.clearBlank){ + this.clear(); + return; + } + value = value.toLowerCase(); + f = function(n){ + return n.attributes[attr].substr(0, vlen).toLowerCase() == value; + }; + }else if(value.exec){ // regex? + f = function(n){ + return value.test(n.attributes[attr]); + }; + }else{ + throw 'Illegal filter type, must be string or regex'; + } + this.filterBy(f, null, startNode); + }, + /** - * @cfg {String} undefinedText - * The string returned by the renderer when the column value is undefined (defaults to ' '). + * Filter by a function. The passed function will be called with each + * node in the tree (or from the startNode). If the function returns true, the node is kept + * otherwise it is filtered. If a node is filtered, its children are also filtered. + * @param {Function} fn The filter function + * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. */ - undefinedText: ' ', - - constructor : function(c) { - c.tpl = c.tpl || new Ext.XTemplate('{' + c.dataIndex + ':this.format}'); - - var t = this.trueText, f = this.falseText, u = this.undefinedText; - c.tpl.format = function(v){ - if(v === undefined){ - return u; + filterBy : function(fn, scope, startNode){ + startNode = startNode || this.tree.root; + if(this.autoClear){ + this.clear(); + } + var af = this.filtered, rv = this.reverse; + var f = function(n){ + if(n == startNode){ + return true; } - if(!v || v === 'false'){ - return f; + if(af[n.id]){ + return false; } - return t; + var m = fn.call(scope || n, n); + if(!m || rv){ + af[n.id] = n; + n.ui.hide(); + return false; + } + return true; }; - - Ext.list.DateColumn.superclass.constructor.call(this, c); - } -}); + startNode.cascade(f); + if(this.remove){ + for(var id in af){ + if(typeof id != "function"){ + var n = af[id]; + if(n && n.parentNode){ + n.parentNode.removeChild(n); + } + } + } + } + }, -Ext.reg('lvbooleancolumn', Ext.list.BooleanColumn);/** - * @class Ext.list.ColumnResizer - * @extends Ext.util.Observable - * Supporting Class for Ext.list.ListView - * @constructor - * @param {Object} config - */ -Ext.list.ColumnResizer = Ext.extend(Ext.util.Observable, { - /** - * @cfg {Number} minPct The minimum percentage to allot for any column (defaults to .05) - */ - minPct: .05, - - constructor: function(config){ - Ext.apply(this, config); - Ext.list.ColumnResizer.superclass.constructor.call(this); - }, - init : function(listView){ - this.view = listView; - listView.on('render', this.initEvents, this); - }, - - initEvents : function(view){ - view.mon(view.innerHd, 'mousemove', this.handleHdMove, this); - this.tracker = new Ext.dd.DragTracker({ - onBeforeStart: this.onBeforeStart.createDelegate(this), - onStart: this.onStart.createDelegate(this), - onDrag: this.onDrag.createDelegate(this), - onEnd: this.onEnd.createDelegate(this), - tolerance: 3, - autoStart: 300 - }); - this.tracker.initEl(view.innerHd); - view.on('beforedestroy', this.tracker.destroy, this.tracker); - }, - - handleHdMove : function(e, t){ - var hw = 5, - x = e.getPageX(), - hd = e.getTarget('em', 3, true); - if(hd){ - var r = hd.getRegion(), - ss = hd.dom.style, - pn = hd.dom.parentNode; - - if(x - r.left <= hw && pn != pn.parentNode.firstChild){ - this.activeHd = Ext.get(pn.previousSibling.firstChild); - ss.cursor = Ext.isWebKit ? 'e-resize' : 'col-resize'; - } else if(r.right - x <= hw && pn != pn.parentNode.lastChild.previousSibling){ - this.activeHd = hd; - ss.cursor = Ext.isWebKit ? 'w-resize' : 'col-resize'; - } else{ - delete this.activeHd; - ss.cursor = ''; - } - } - }, - - onBeforeStart : function(e){ - this.dragHd = this.activeHd; - return !!this.dragHd; - }, - - onStart: function(e){ - this.view.disableHeaders = true; - this.proxy = this.view.el.createChild({cls:'x-list-resizer'}); - this.proxy.setHeight(this.view.el.getHeight()); - - var x = this.tracker.getXY()[0], - w = this.view.innerHd.getWidth(); - - this.hdX = this.dragHd.getX(); - this.hdIndex = this.view.findHeaderIndex(this.dragHd); - - this.proxy.setX(this.hdX); - this.proxy.setWidth(x-this.hdX); - - this.minWidth = w*this.minPct; - this.maxWidth = w - (this.minWidth*(this.view.columns.length-1-this.hdIndex)); - }, - - onDrag: function(e){ - var cursorX = this.tracker.getXY()[0]; - this.proxy.setWidth((cursorX-this.hdX).constrain(this.minWidth, this.maxWidth)); - }, - - onEnd: function(e){ - /* calculate desired width by measuring proxy and then remove it */ - var nw = this.proxy.getWidth(); - this.proxy.remove(); - - var index = this.hdIndex, - vw = this.view, - cs = vw.columns, - len = cs.length, - w = this.view.innerHd.getWidth(), - minPct = this.minPct * 100, - pct = Math.ceil((nw * vw.maxWidth) / w), - diff = (cs[index].width * 100) - pct, - each = Math.floor(diff / (len-1-index)), - mod = diff - (each * (len-1-index)); - - for(var i = index+1; i < len; i++){ - var cw = (cs[i].width * 100) + each, - ncw = Math.max(minPct, cw); - if(cw != ncw){ - mod += cw - ncw; - } - cs[i].width = ncw / 100; - } - cs[index].width = pct / 100; - cs[index+1].width += (mod / 100); - delete this.dragHd; - vw.setHdWidths(); - vw.refresh(); - setTimeout(function(){ - vw.disableHeaders = false; - }, 100); - } -}); - -// Backwards compatibility alias -Ext.ListView.ColumnResizer = Ext.list.ColumnResizer;/** - * @class Ext.list.Sorter - * @extends Ext.util.Observable - * Supporting Class for Ext.list.ListView - * @constructor - * @param {Object} config - */ -Ext.list.Sorter = Ext.extend(Ext.util.Observable, { - /** - * @cfg {Array} sortClasses - * The CSS classes applied to a header when it is sorted. (defaults to ["sort-asc", "sort-desc"]) - */ - sortClasses : ["sort-asc", "sort-desc"], - - constructor: function(config){ - Ext.apply(this, config); - Ext.list.Sorter.superclass.constructor.call(this); - }, - - init : function(listView){ - this.view = listView; - listView.on('render', this.initEvents, this); - }, - - initEvents : function(view){ - view.mon(view.innerHd, 'click', this.onHdClick, this); - view.innerHd.setStyle('cursor', 'pointer'); - view.mon(view.store, 'datachanged', this.updateSortState, this); - this.updateSortState.defer(10, this, [view.store]); - }, - - updateSortState : function(store){ - var state = store.getSortState(); - if(!state){ - return; - } - this.sortState = state; - var cs = this.view.columns, sortColumn = -1; - for(var i = 0, len = cs.length; i < len; i++){ - if(cs[i].dataIndex == state.field){ - sortColumn = i; - break; - } - } - if(sortColumn != -1){ - var sortDir = state.direction; - this.updateSortIcon(sortColumn, sortDir); - } - }, - - updateSortIcon : function(col, dir){ - var sc = this.sortClasses; - var hds = this.view.innerHd.select('em').removeClass(sc); - hds.item(col).addClass(sc[dir == "DESC" ? 1 : 0]); - }, - - onHdClick : function(e){ - var hd = e.getTarget('em', 3); - if(hd && !this.view.disableHeaders){ - var index = this.view.findHeaderIndex(hd); - this.view.store.sort(this.view.columns[index].dataIndex); - } - } -}); - -// Backwards compatibility alias -Ext.ListView.Sorter = Ext.list.Sorter;/** - * @class Ext.TabPanel - * A basic tab container. TabPanels can be used exactly like a standard {@link Ext.Panel} - * for layout purposes, but also have special support for containing child Components - * ({@link Ext.Container#items items}) that are managed using a - * {@link Ext.layout.CardLayout CardLayout layout manager}, and displayed as separate tabs. - * - * Note: By default, a tab's close tool destroys the child tab Component - * and all its descendants. This makes the child tab Component, and all its descendants unusable. To enable - * re-use of a tab, configure the TabPanel with {@link #autoDestroy autoDestroy: false}. - * - * TabPanel header/footer elements - * TabPanels use their {@link Ext.Panel#header header} or {@link Ext.Panel#footer footer} element - * (depending on the {@link #tabPosition} configuration) to accommodate the tab selector buttons. - * This means that a TabPanel will not display any configured title, and will not display any - * configured header {@link Ext.Panel#tools tools}. - * To display a header, embed the TabPanel in a {@link Ext.Panel Panel} which uses - * {@link Ext.Container#layout layout:'fit'}. - * - * Tab Events - * There is no actual tab class — each tab is simply a {@link Ext.BoxComponent Component} - * such as a {@link Ext.Panel Panel}. However, when rendered in a TabPanel, each child Component - * can fire additional events that only exist for tabs and are not available from other Components. - * These events are: - * - * {@link Ext.Panel#activate activate} : Fires when this Component becomes - * the active tab. - * {@link Ext.Panel#deactivate deactivate} : Fires when the Component that - * was the active tab becomes deactivated. - * {@link Ext.Panel#beforeclose beforeclose} : Fires when the user clicks on the close tool of a closeable tab. - * May be vetoed by returning false from a handler. - * {@link Ext.Panel#close close} : Fires a closeable tab has been closed by the user. - * - * Creating TabPanels from Code - * TabPanels can be created and rendered completely in code, as in this example: - * -var tabs = new Ext.TabPanel({ - renderTo: Ext.getBody(), - activeTab: 0, - items: [{ - title: 'Tab 1', - html: 'A simple tab' - },{ - title: 'Tab 2', - html: 'Another one' - }] -}); - - * Creating TabPanels from Existing Markup - * TabPanels can also be rendered from pre-existing markup in a couple of ways. - * - * - * Pre-Structured Markup - * - * A container div with one or more nested tab divs with class 'x-tab' can be rendered entirely - * from existing markup (See the {@link #autoTabs} example). - * - * - * Un-Structured Markup - * - * A TabPanel can also be rendered from markup that is not strictly structured by simply specifying by id - * which elements should be the container and the tabs. Using this method tab content can be pulled from different - * elements within the page by id regardless of page structure. For example: + /** + * Clears the current filter. Note: with the "remove" option + * set a filter cannot be cleared. + */ + clear : function(){ + var t = this.tree; + var af = this.filtered; + for(var id in af){ + if(typeof id != "function"){ + var n = af[id]; + if(n){ + n.ui.show(); + } + } + } + this.filtered = {}; + } +}; +/** + * @class Ext.tree.TreeSorter + * Provides sorting of nodes in a {@link Ext.tree.TreePanel}. The TreeSorter automatically monitors events on the + * associated TreePanel that might affect the tree's sort order (beforechildrenrendered, append, insert and textchange). + * Example usage: * -var tabs = new Ext.TabPanel({ - renderTo: 'my-tabs', - activeTab: 0, - items:[ - {contentEl:'tab1', title:'Tab 1'}, - {contentEl:'tab2', title:'Tab 2'} - ] +new Ext.tree.TreeSorter(myTree, { + folderSort: true, + dir: "desc", + sortType: function(node) { + // sort by a custom, typed attribute: + return parseInt(node.id, 10); + } }); - -// Note that the tabs do not have to be nested within the container (although they can be) -<div id="my-tabs"></div> -<div id="tab1" class="x-hide-display">A simple tab</div> -<div id="tab2" class="x-hide-display">Another one</div> - * Note that the tab divs in this example contain the class 'x-hide-display' so that they can be rendered - * deferred without displaying outside the tabs. You could alternately set {@link #deferredRender} = false - * to render all content tabs on page load. - * - * - * - * - * @extends Ext.Panel * @constructor - * @param {Object} config The configuration options - * @xtype tabpanel + * @param {TreePanel} tree + * @param {Object} config */ -Ext.TabPanel = Ext.extend(Ext.Panel, { +Ext.tree.TreeSorter = function(tree, config){ /** - * @cfg {Boolean} layoutOnTabChange - * Set to true to force a layout of the active tab when the tab is changed. Defaults to false. - * See {@link Ext.layout.CardLayout}.{@link Ext.layout.CardLayout#layoutOnCardChange layoutOnCardChange}. + * @cfg {Boolean} folderSort True to sort leaf nodes under non-leaf nodes (defaults to false) */ /** - * @cfg {String} tabCls This config option is used on child Components of ths TabPanel. A CSS - * class name applied to the tab strip item representing the child Component, allowing special - * styling to be applied. + * @cfg {String} property The named attribute on the node to sort by (defaults to "text"). Note that this + * property is only used if no {@link #sortType} function is specified, otherwise it is ignored. */ /** - * @cfg {Boolean} deferredRender - * true by default to defer the rendering of child {@link Ext.Container#items items} - * to the browsers DOM until a tab is activated. false will render all contained - * {@link Ext.Container#items items} as soon as the {@link Ext.layout.CardLayout layout} - * is rendered. If there is a significant amount of content or a lot of heavy controls being - * rendered into panels that are not displayed by default, setting this to true might - * improve performance. - * The deferredRender property is internally passed to the layout manager for - * TabPanels ({@link Ext.layout.CardLayout}) as its {@link Ext.layout.CardLayout#deferredRender} - * configuration value. - * Note: leaving deferredRender as true means that the content - * within an unactivated tab will not be available. For example, this means that if the TabPanel - * is within a {@link Ext.form.FormPanel form}, then until a tab is activated, any Fields within - * unactivated tabs will not be rendered, and will therefore not be submitted and will not be - * available to either {@link Ext.form.BasicForm#getValues getValues} or - * {@link Ext.form.BasicForm#setValues setValues}. + * @cfg {String} dir The direction to sort ("asc" or "desc," case-insensitive, defaults to "asc") */ - deferredRender : true, /** - * @cfg {Number} tabWidth The initial width in pixels of each new tab (defaults to 120). + * @cfg {String} leafAttr The attribute used to determine leaf nodes when {@link #folderSort} = true (defaults to "leaf") */ - tabWidth : 120, /** - * @cfg {Number} minTabWidth The minimum width in pixels for each tab when {@link #resizeTabs} = true (defaults to 30). + * @cfg {Boolean} caseSensitive true for case-sensitive sort (defaults to false) */ - minTabWidth : 30, /** - * @cfg {Boolean} resizeTabs True to automatically resize each tab so that the tabs will completely fill the - * tab strip (defaults to false). Setting this to true may cause specific widths that might be set per tab to - * be overridden in order to fit them all into view (although {@link #minTabWidth} will always be honored). + * @cfg {Function} sortType A custom "casting" function used to convert node values before sorting. The function + * will be called with a single parameter (the {@link Ext.tree.TreeNode} being evaluated) and is expected to return + * the node's sort value cast to the specific data type required for sorting. This could be used, for example, when + * a node's text (or other attribute) should be sorted as a date or numeric value. See the class description for + * example usage. Note that if a sortType is specified, any {@link #property} config will be ignored. */ - resizeTabs : false, + + Ext.apply(this, config); + tree.on("beforechildrenrendered", this.doSort, this); + tree.on("append", this.updateSort, this); + tree.on("insert", this.updateSort, this); + tree.on("textchange", this.updateSortParent, this); + + var dsc = this.dir && this.dir.toLowerCase() == "desc"; + var p = this.property || "text"; + var sortType = this.sortType; + var fs = this.folderSort; + var cs = this.caseSensitive === true; + var leafAttr = this.leafAttr || 'leaf'; + + this.sortFn = function(n1, n2){ + if(fs){ + if(n1.attributes[leafAttr] && !n2.attributes[leafAttr]){ + return 1; + } + if(!n1.attributes[leafAttr] && n2.attributes[leafAttr]){ + return -1; + } + } + var v1 = sortType ? sortType(n1) : (cs ? n1.attributes[p] : n1.attributes[p].toUpperCase()); + var v2 = sortType ? sortType(n2) : (cs ? n2.attributes[p] : n2.attributes[p].toUpperCase()); + if(v1 < v2){ + return dsc ? +1 : -1; + }else if(v1 > v2){ + return dsc ? -1 : +1; + }else{ + return 0; + } + }; +}; + +Ext.tree.TreeSorter.prototype = { + doSort : function(node){ + node.sort(this.sortFn); + }, + + compareNodes : function(n1, n2){ + return (n1.text.toUpperCase() > n2.text.toUpperCase() ? 1 : -1); + }, + + updateSort : function(tree, node){ + if(node.childrenRendered){ + this.doSort.defer(1, this, [node]); + } + }, + + updateSortParent : function(node){ + var p = node.parentNode; + if(p && p.childrenRendered){ + this.doSort.defer(1, this, [p]); + } + } +};/** + * @class Ext.tree.TreeDropZone + * @extends Ext.dd.DropZone + * @constructor + * @param {String/HTMLElement/Element} tree The {@link Ext.tree.TreePanel} for which to enable dropping + * @param {Object} config + */ +if(Ext.dd.DropZone){ + +Ext.tree.TreeDropZone = function(tree, config){ /** - * @cfg {Boolean} enableTabScroll True to enable scrolling to tabs that may be invisible due to overflowing the - * overall TabPanel width. Only available with tabPosition:'top' (defaults to false). + * @cfg {Boolean} allowParentInsert + * Allow inserting a dragged node between an expanded parent node and its first child that will become a + * sibling of the parent when dropped (defaults to false) */ - enableTabScroll : false, + this.allowParentInsert = config.allowParentInsert || false; /** - * @cfg {Number} scrollIncrement The number of pixels to scroll each time a tab scroll button is pressed - * (defaults to 100, or if {@link #resizeTabs} = true, the calculated tab width). Only - * applies when {@link #enableTabScroll} = true. + * @cfg {String} allowContainerDrop + * True if drops on the tree container (outside of a specific tree node) are allowed (defaults to false) */ - scrollIncrement : 0, + this.allowContainerDrop = config.allowContainerDrop || false; /** - * @cfg {Number} scrollRepeatInterval Number of milliseconds between each scroll while a tab scroll button is - * continuously pressed (defaults to 400). + * @cfg {String} appendOnly + * True if the tree should only allow append drops (use for trees which are sorted, defaults to false) */ - scrollRepeatInterval : 400, + this.appendOnly = config.appendOnly || false; + + Ext.tree.TreeDropZone.superclass.constructor.call(this, tree.getTreeEl(), config); /** - * @cfg {Float} scrollDuration The number of milliseconds that each scroll animation should last (defaults - * to .35). Only applies when {@link #animScroll} = true. - */ - scrollDuration : 0.35, + * The TreePanel for this drop zone + * @type Ext.tree.TreePanel + * @property + */ + this.tree = tree; /** - * @cfg {Boolean} animScroll True to animate tab scrolling so that hidden tabs slide smoothly into view (defaults - * to true). Only applies when {@link #enableTabScroll} = true. - */ - animScroll : true, + * Arbitrary data that can be associated with this tree and will be included in the event object that gets + * passed to any nodedragover event handler (defaults to {}) + * @type Ext.tree.TreePanel + * @property + */ + this.dragOverData = {}; + // private + this.lastInsertClass = "x-tree-no-status"; +}; + +Ext.extend(Ext.tree.TreeDropZone, Ext.dd.DropZone, { /** - * @cfg {String} tabPosition The position where the tab strip should be rendered (defaults to 'top'). - * The only other supported value is 'bottom'. Note: tab scrolling is only supported for - * tabPosition: 'top'. + * @cfg {String} ddGroup + * A named drag drop group to which this object belongs. If a group is specified, then this object will only + * interact with other drag drop objects in the same group (defaults to 'TreeDD'). */ - tabPosition : 'top', + ddGroup : "TreeDD", + /** - * @cfg {String} baseCls The base CSS class applied to the panel (defaults to 'x-tab-panel'). + * @cfg {String} expandDelay + * The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node + * over the target (defaults to 1000) */ - baseCls : 'x-tab-panel', - /** - * @cfg {Boolean} autoTabs - * true to query the DOM for any divs with a class of 'x-tab' to be automatically converted - * to tabs and added to this panel (defaults to false). Note that the query will be executed within - * the scope of the container element only (so that multiple tab panels from markup can be supported via this - * method). - * This method is only possible when the markup is structured correctly as a container with nested divs - * containing the class 'x-tab'. To create TabPanels without these limitations, or to pull tab content - * from other elements on the page, see the example at the top of the class for generating tabs from markup. - * There are a couple of things to note when using this method: - * When using the autoTabs config (as opposed to passing individual tab configs in the TabPanel's - * {@link #items} collection), you must use {@link #applyTo} to correctly use the specified id - * as the tab container. The autoTabs method replaces existing content with the TabPanel - * components. - * Make sure that you set {@link #deferredRender}: false so that the content elements for each - * tab will be rendered into the TabPanel immediately upon page load, otherwise they will not be transformed - * until each tab is activated and will be visible outside the TabPanel. - * Example usage: - * -var tabs = new Ext.TabPanel({ - applyTo: 'my-tabs', - activeTab: 0, - deferredRender: false, - autoTabs: true + expandDelay : 1000, + + // private + expandNode : function(node){ + if(node.hasChildNodes() && !node.isExpanded()){ + node.expand(false, null, this.triggerCacheRefresh.createDelegate(this)); + } + }, + + // private + queueExpand : function(node){ + this.expandProcId = this.expandNode.defer(this.expandDelay, this, [node]); + }, + + // private + cancelExpand : function(){ + if(this.expandProcId){ + clearTimeout(this.expandProcId); + this.expandProcId = false; + } + }, + + // private + isValidDropPoint : function(n, pt, dd, e, data){ + if(!n || !data){ return false; } + var targetNode = n.node; + var dropNode = data.node; + // default drop rules + if(!(targetNode && targetNode.isTarget && pt)){ + return false; + } + if(pt == "append" && targetNode.allowChildren === false){ + return false; + } + if((pt == "above" || pt == "below") && (targetNode.parentNode && targetNode.parentNode.allowChildren === false)){ + return false; + } + if(dropNode && (targetNode == dropNode || dropNode.contains(targetNode))){ + return false; + } + // reuse the object + var overEvent = this.dragOverData; + overEvent.tree = this.tree; + overEvent.target = targetNode; + overEvent.data = data; + overEvent.point = pt; + overEvent.source = dd; + overEvent.rawEvent = e; + overEvent.dropNode = dropNode; + overEvent.cancel = false; + var result = this.tree.fireEvent("nodedragover", overEvent); + return overEvent.cancel === false && result !== false; + }, + + // private + getDropPoint : function(e, n, dd){ + var tn = n.node; + if(tn.isRoot){ + return tn.allowChildren !== false ? "append" : false; // always append for root + } + var dragEl = n.ddel; + var t = Ext.lib.Dom.getY(dragEl), b = t + dragEl.offsetHeight; + var y = Ext.lib.Event.getPageY(e); + var noAppend = tn.allowChildren === false || tn.isLeaf(); + if(this.appendOnly || tn.parentNode.allowChildren === false){ + return noAppend ? false : "append"; + } + var noBelow = false; + if(!this.allowParentInsert){ + noBelow = tn.hasChildNodes() && tn.isExpanded(); + } + var q = (b - t) / (noAppend ? 2 : 3); + if(y >= t && y < (t + q)){ + return "above"; + }else if(!noBelow && (noAppend || y >= b-q && y <= b)){ + return "below"; + }else{ + return "append"; + } + }, + + // private + onNodeEnter : function(n, dd, e, data){ + this.cancelExpand(); + }, + + onContainerOver : function(dd, e, data) { + if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) { + return this.dropAllowed; + } + return this.dropNotAllowed; + }, + + // private + onNodeOver : function(n, dd, e, data){ + var pt = this.getDropPoint(e, n, dd); + var node = n.node; + + // auto node expand check + if(!this.expandProcId && pt == "append" && node.hasChildNodes() && !n.node.isExpanded()){ + this.queueExpand(node); + }else if(pt != "append"){ + this.cancelExpand(); + } + + // set the insert point style on the target node + var returnCls = this.dropNotAllowed; + if(this.isValidDropPoint(n, pt, dd, e, data)){ + if(pt){ + var el = n.ddel; + var cls; + if(pt == "above"){ + returnCls = n.node.isFirst() ? "x-tree-drop-ok-above" : "x-tree-drop-ok-between"; + cls = "x-tree-drag-insert-above"; + }else if(pt == "below"){ + returnCls = n.node.isLast() ? "x-tree-drop-ok-below" : "x-tree-drop-ok-between"; + cls = "x-tree-drag-insert-below"; + }else{ + returnCls = "x-tree-drop-ok-append"; + cls = "x-tree-drag-append"; + } + if(this.lastInsertClass != cls){ + Ext.fly(el).replaceClass(this.lastInsertClass, cls); + this.lastInsertClass = cls; + } + } + } + return returnCls; + }, + + // private + onNodeOut : function(n, dd, e, data){ + this.cancelExpand(); + this.removeDropIndicators(n); + }, + + // private + onNodeDrop : function(n, dd, e, data){ + var point = this.getDropPoint(e, n, dd); + var targetNode = n.node; + targetNode.ui.startDrop(); + if(!this.isValidDropPoint(n, point, dd, e, data)){ + targetNode.ui.endDrop(); + return false; + } + // first try to find the drop node + var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, point, e) : null); + return this.processDrop(targetNode, data, point, dd, e, dropNode); + }, + + onContainerDrop : function(dd, e, data){ + if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) { + var targetNode = this.tree.getRootNode(); + targetNode.ui.startDrop(); + var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, 'append', e) : null); + return this.processDrop(targetNode, data, 'append', dd, e, dropNode); + } + return false; + }, + + // private + processDrop: function(target, data, point, dd, e, dropNode){ + var dropEvent = { + tree : this.tree, + target: target, + data: data, + point: point, + source: dd, + rawEvent: e, + dropNode: dropNode, + cancel: !dropNode, + dropStatus: false + }; + var retval = this.tree.fireEvent("beforenodedrop", dropEvent); + if(retval === false || dropEvent.cancel === true || !dropEvent.dropNode){ + target.ui.endDrop(); + return dropEvent.dropStatus; + } + + target = dropEvent.target; + if(point == 'append' && !target.isExpanded()){ + target.expand(false, null, function(){ + this.completeDrop(dropEvent); + }.createDelegate(this)); + }else{ + this.completeDrop(dropEvent); + } + return true; + }, + + // private + completeDrop : function(de){ + var ns = de.dropNode, p = de.point, t = de.target; + if(!Ext.isArray(ns)){ + ns = [ns]; + } + var n; + for(var i = 0, len = ns.length; i < len; i++){ + n = ns[i]; + if(p == "above"){ + t.parentNode.insertBefore(n, t); + }else if(p == "below"){ + t.parentNode.insertBefore(n, t.nextSibling); + }else{ + t.appendChild(n); + } + } + n.ui.focus(); + if(Ext.enableFx && this.tree.hlDrop){ + n.ui.highlight(); + } + t.ui.endDrop(); + this.tree.fireEvent("nodedrop", de); + }, + + // private + afterNodeMoved : function(dd, data, e, targetNode, dropNode){ + if(Ext.enableFx && this.tree.hlDrop){ + dropNode.ui.focus(); + dropNode.ui.highlight(); + } + this.tree.fireEvent("nodedrop", this.tree, targetNode, data, dd, e); + }, + + // private + getTree : function(){ + return this.tree; + }, + + // private + removeDropIndicators : function(n){ + if(n && n.ddel){ + var el = n.ddel; + Ext.fly(el).removeClass([ + "x-tree-drag-insert-above", + "x-tree-drag-insert-below", + "x-tree-drag-append"]); + this.lastInsertClass = "_noclass"; + } + }, + + // private + beforeDragDrop : function(target, e, id){ + this.cancelExpand(); + return true; + }, + + // private + afterRepair : function(data){ + if(data && Ext.enableFx){ + data.node.ui.highlight(); + } + this.hideProxy(); + } }); -// This markup will be converted to a TabPanel from the code above -<div id="my-tabs"> - <div class="x-tab" title="Tab 1">A simple tab</div> - <div class="x-tab" title="Tab 2">Another one</div> -</div> - +}/** + * @class Ext.tree.TreeDragZone + * @extends Ext.dd.DragZone + * @constructor + * @param {String/HTMLElement/Element} tree The {@link Ext.tree.TreePanel} for which to enable dragging + * @param {Object} config + */ +if(Ext.dd.DragZone){ +Ext.tree.TreeDragZone = function(tree, config){ + Ext.tree.TreeDragZone.superclass.constructor.call(this, tree.innerCt, config); + /** + * The TreePanel for this drag zone + * @type Ext.tree.TreePanel + * @property + */ + this.tree = tree; +}; + +Ext.extend(Ext.tree.TreeDragZone, Ext.dd.DragZone, { + /** + * @cfg {String} ddGroup + * A named drag drop group to which this object belongs. If a group is specified, then this object will only + * interact with other drag drop objects in the same group (defaults to 'TreeDD'). */ - autoTabs : false, + ddGroup : "TreeDD", + + // private + onBeforeDrag : function(data, e){ + var n = data.node; + return n && n.draggable && !n.disabled; + }, + + // private + onInitDrag : function(e){ + var data = this.dragData; + this.tree.getSelectionModel().select(data.node); + this.tree.eventModel.disable(); + this.proxy.update(""); + data.node.ui.appendDDGhost(this.proxy.ghost.dom); + this.tree.fireEvent("startdrag", this.tree, data.node, e); + }, + + // private + getRepairXY : function(e, data){ + return data.node.ui.getDDRepairXY(); + }, + + // private + onEndDrag : function(data, e){ + this.tree.eventModel.enable.defer(100, this.tree.eventModel); + this.tree.fireEvent("enddrag", this.tree, data.node, e); + }, + + // private + onValidDrop : function(dd, e, id){ + this.tree.fireEvent("dragdrop", this.tree, this.dragData.node, dd, e); + this.hideProxy(); + }, + + // private + beforeInvalidDrop : function(e, id){ + // this scrolls the original position back into view + var sm = this.tree.getSelectionModel(); + sm.clearSelections(); + sm.select(this.dragData.node); + }, + + // private + afterRepair : function(){ + if (Ext.enableFx && this.tree.hlDrop) { + Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9"); + } + this.dragging = false; + } +}); +}/** + * @class Ext.tree.TreeEditor + * @extends Ext.Editor + * Provides editor functionality for inline tree node editing. Any valid {@link Ext.form.Field} subclass can be used + * as the editor field. + * @constructor + * @param {TreePanel} tree + * @param {Object} fieldConfig (optional) Either a prebuilt {@link Ext.form.Field} instance or a Field config object + * that will be applied to the default field instance (defaults to a {@link Ext.form.TextField}). + * @param {Object} config (optional) A TreeEditor config object + */ +Ext.tree.TreeEditor = function(tree, fc, config){ + fc = fc || {}; + var field = fc.events ? fc : new Ext.form.TextField(fc); + + Ext.tree.TreeEditor.superclass.constructor.call(this, field, config); + + this.tree = tree; + + if(!tree.rendered){ + tree.on('render', this.initEditor, this); + }else{ + this.initEditor(tree); + } +}; + +Ext.extend(Ext.tree.TreeEditor, Ext.Editor, { /** - * @cfg {String} autoTabSelector The CSS selector used to search for tabs in existing markup when - * {@link #autoTabs} = true (defaults to 'div.x-tab'). This can be any valid selector - * supported by {@link Ext.DomQuery#select}. Note that the query will be executed within the scope of this - * tab panel only (so that multiple tab panels from markup can be supported on a page). + * @cfg {String} alignment + * The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "l-l"). */ - autoTabSelector : 'div.x-tab', + alignment: "l-l", + // inherit + autoSize: false, /** - * @cfg {String/Number} activeTab A string id or the numeric index of the tab that should be initially - * activated on render (defaults to undefined). + * @cfg {Boolean} hideEl + * True to hide the bound element while the editor is displayed (defaults to false) */ - activeTab : undefined, + hideEl : false, /** - * @cfg {Number} tabMargin The number of pixels of space to calculate into the sizing and scrolling of - * tabs. If you change the margin in CSS, you will need to update this value so calculations are correct - * with either {@link #resizeTabs} or scrolling tabs. (defaults to 2) + * @cfg {String} cls + * CSS class to apply to the editor (defaults to "x-small-editor x-tree-editor") */ - tabMargin : 2, + cls: "x-small-editor x-tree-editor", /** - * @cfg {Boolean} plain true to render the tab strip without a background container image - * (defaults to false). + * @cfg {Boolean} shim + * True to shim the editor if selects/iframes could be displayed beneath it (defaults to false) */ - plain : false, + shim:false, + // inherit + shadow:"frame", /** - * @cfg {Number} wheelIncrement For scrolling tabs, the number of pixels to increment on mouse wheel - * scrolling (defaults to 20). + * @cfg {Number} maxWidth + * The maximum width in pixels of the editor field (defaults to 250). Note that if the maxWidth would exceed + * the containing tree element's size, it will be automatically limited for you to the container width, taking + * scroll and client offsets into account prior to each edit. */ - wheelIncrement : 20, - - /* - * This is a protected property used when concatenating tab ids to the TabPanel id for internal uniqueness. - * It does not generally need to be changed, but can be if external code also uses an id scheme that can - * potentially clash with this one. + maxWidth: 250, + /** + * @cfg {Number} editDelay The number of milliseconds between clicks to register a double-click that will trigger + * editing on the current node (defaults to 350). If two clicks occur on the same node within this time span, + * the editor for the node will display, otherwise it will be processed as a regular click. */ - idDelimiter : '__', - - // private - itemCls : 'x-tab-item', + editDelay : 350, - // private config overrides - elements : 'body', - headerAsText : false, - frame : false, - hideBorders :true, + initEditor : function(tree){ + tree.on({ + scope : this, + beforeclick: this.beforeNodeClick, + dblclick : this.onNodeDblClick + }); + + this.on({ + scope : this, + complete : this.updateNode, + beforestartedit: this.fitToTree, + specialkey : this.onSpecialKey + }); + + this.on('startedit', this.bindScroll, this, {delay:10}); + }, // private - initComponent : function(){ - this.frame = false; - Ext.TabPanel.superclass.initComponent.call(this); - this.addEvents( - /** - * @event beforetabchange - * Fires before the active tab changes. Handlers can return false to cancel the tab change. - * @param {TabPanel} this - * @param {Panel} newTab The tab being activated - * @param {Panel} currentTab The current active tab - */ - 'beforetabchange', - /** - * @event tabchange - * Fires after the active tab has changed. - * @param {TabPanel} this - * @param {Panel} tab The new active tab - */ - 'tabchange', - /** - * @event contextmenu - * Relays the contextmenu event from a tab selector element in the tab strip. - * @param {TabPanel} this - * @param {Panel} tab The target tab - * @param {EventObject} e - */ - 'contextmenu' - ); - /** - * @cfg {Object} layoutConfig - * TabPanel implicitly uses {@link Ext.layout.CardLayout} as its layout manager. - * layoutConfig may be used to configure this layout manager. - * {@link #deferredRender} and {@link #layoutOnTabChange} - * configured on the TabPanel will be applied as configs to the layout manager. - */ - this.setLayout(new Ext.layout.CardLayout(Ext.apply({ - layoutOnCardChange: this.layoutOnTabChange, - deferredRender: this.deferredRender - }, this.layoutConfig))); - - if(this.tabPosition == 'top'){ - this.elements += ',header'; - this.stripTarget = 'header'; - }else { - this.elements += ',footer'; - this.stripTarget = 'footer'; + fitToTree : function(ed, el){ + var td = this.tree.getTreeEl().dom, nd = el.dom; + if(td.scrollLeft > nd.offsetLeft){ // ensure the node left point is visible + td.scrollLeft = nd.offsetLeft; } - if(!this.stack){ - this.stack = Ext.TabPanel.AccessStack(); + var w = Math.min( + this.maxWidth, + (td.clientWidth > 20 ? td.clientWidth : td.offsetWidth) - Math.max(0, nd.offsetLeft-td.scrollLeft) - /*cushion*/5); + this.setSize(w, ''); + }, + + /** + * Edit the text of the passed {@link Ext.tree.TreeNode TreeNode}. + * @param node {Ext.tree.TreeNode} The TreeNode to edit. The TreeNode must be {@link Ext.tree.TreeNode#editable editable}. + */ + triggerEdit : function(node, defer){ + this.completeEdit(); + if(node.attributes.editable !== false){ + /** + * The {@link Ext.tree.TreeNode TreeNode} this editor is bound to. Read-only. + * @type Ext.tree.TreeNode + * @property editNode + */ + this.editNode = node; + if(this.tree.autoScroll){ + Ext.fly(node.ui.getEl()).scrollIntoView(this.tree.body); + } + var value = node.text || ''; + if (!Ext.isGecko && Ext.isEmpty(node.text)){ + node.setText(' '); + } + this.autoEditTimer = this.startEdit.defer(this.editDelay, this, [node.ui.textNode, value]); + return false; } - this.initItems(); }, // private - onRender : function(ct, position){ - Ext.TabPanel.superclass.onRender.call(this, ct, position); + bindScroll : function(){ + this.tree.getTreeEl().on('scroll', this.cancelEdit, this); + }, - if(this.plain){ - var pos = this.tabPosition == 'top' ? 'header' : 'footer'; - this[pos].addClass('x-tab-panel-'+pos+'-plain'); + // private + beforeNodeClick : function(node, e){ + clearTimeout(this.autoEditTimer); + if(this.tree.getSelectionModel().isSelected(node)){ + e.stopEvent(); + return this.triggerEdit(node); } + }, - var st = this[this.stripTarget]; - - this.stripWrap = st.createChild({cls:'x-tab-strip-wrap', cn:{ - tag:'ul', cls:'x-tab-strip x-tab-strip-'+this.tabPosition}}); - - var beforeEl = (this.tabPosition=='bottom' ? this.stripWrap : null); - st.createChild({cls:'x-tab-strip-spacer'}, beforeEl); - this.strip = new Ext.Element(this.stripWrap.dom.firstChild); - - // create an empty span with class x-tab-strip-text to force the height of the header element when there's no tabs. - this.edge = this.strip.createChild({tag:'li', cls:'x-tab-edge', cn: [{tag: 'span', cls: 'x-tab-strip-text', cn: ' '}]}); - this.strip.createChild({cls:'x-clear'}); - - this.body.addClass('x-tab-panel-body-'+this.tabPosition); - - /** - * @cfg {Template/XTemplate} itemTpl (Optional) A {@link Ext.Template Template} or - * {@link Ext.XTemplate XTemplate} which may be provided to process the data object returned from - * {@link #getTemplateArgs} to produce a clickable selector element in the tab strip. - * The main element created should be a <li> element. In order for a click event on - * a selector element to be connected to its item, it must take its id from the TabPanel's - * native {@link #getTemplateArgs}. - * The child element which contains the title text must be marked by the CSS class - * x-tab-strip-inner. - * To enable closability, the created element should contain an element marked by the CSS class - * x-tab-strip-close. - * If a custom itemTpl is supplied, it is the developer's responsibility to create CSS - * style rules to create the desired appearance. - * Below is an example of how to create customized tab selector items: -new Ext.TabPanel({ - renderTo: document.body, - minTabWidth: 115, - tabWidth: 135, - enableTabScroll: true, - width: 600, - height: 250, - defaults: {autoScroll:true}, - itemTpl: new Ext.XTemplate( - '<li class="{cls}" id="{id}" style="overflow:hidden">', - '<tpl if="closable">', - '<a class="x-tab-strip-close"></a>', - '</tpl>', - '<a class="x-tab-right" href="#" style="padding-left:6px">', - '<em class="x-tab-left">', - '<span class="x-tab-strip-inner">', - '<img src="{src}" style="float:left;margin:3px 3px 0 0">', - '<span style="margin-left:20px" class="x-tab-strip-text {iconCls}">{text} {extra}</span>', - '</span>', - '</em>', - '</a>', - '</li>' - ), - getTemplateArgs: function(item) { -// Call the native method to collect the base data. Like the ID! - var result = Ext.TabPanel.prototype.getTemplateArgs.call(this, item); - -// Add stuff used in our template - return Ext.apply(result, { - closable: item.closable, - src: item.iconSrc, - extra: item.extraText || '' - }); + onNodeDblClick : function(node, e){ + clearTimeout(this.autoEditTimer); }, - items: [{ - title: 'New Tab 1', - iconSrc: '../shared/icons/fam/grid.png', - html: 'Tab Body 1', - closable: true - }, { - title: 'New Tab 2', - iconSrc: '../shared/icons/fam/grid.png', - html: 'Tab Body 2', - extraText: 'Extra stuff in the tab button' - }] -}); - - */ - if(!this.itemTpl){ - var tt = new Ext.Template( - '', - '', - '{text}', - '' - ); - tt.disableFormats = true; - tt.compile(); - Ext.TabPanel.prototype.itemTpl = tt; - } - this.items.each(this.initTab, this); + // private + updateNode : function(ed, value){ + this.tree.getTreeEl().un('scroll', this.cancelEdit, this); + this.editNode.setText(value); }, // private - afterRender : function(){ - Ext.TabPanel.superclass.afterRender.call(this); - if(this.autoTabs){ - this.readTabs(false); - } - if(this.activeTab !== undefined){ - var item = Ext.isObject(this.activeTab) ? this.activeTab : this.items.get(this.activeTab); - delete this.activeTab; - this.setActiveTab(item); + onHide : function(){ + Ext.tree.TreeEditor.superclass.onHide.call(this); + if(this.editNode){ + this.editNode.ui.focus.defer(50, this.editNode.ui); } }, // private - initEvents : function(){ - Ext.TabPanel.superclass.initEvents.call(this); - this.mon(this.strip, { - scope: this, - mousedown: this.onStripMouseDown, - contextmenu: this.onStripContextMenu - }); - if(this.enableTabScroll){ - this.mon(this.strip, 'mousewheel', this.onWheel, this); + onSpecialKey : function(field, e){ + var k = e.getKey(); + if(k == e.ESC){ + e.stopEvent(); + this.cancelEdit(); + }else if(k == e.ENTER && !e.hasModifier()){ + e.stopEvent(); + this.completeEdit(); } }, + + onDestroy : function(){ + clearTimeout(this.autoEditTimer); + Ext.tree.TreeEditor.superclass.onDestroy.call(this); + var tree = this.tree; + tree.un('beforeclick', this.beforeNodeClick, this); + tree.un('dblclick', this.onNodeDblClick, this); + } +});/*! SWFObject v2.2 + is released under the MIT License +*/ - // private - findTargets : function(e){ - var item = null, - itemEl = e.getTarget('li:not(.x-tab-edge)', this.strip); +var swfobject = function() { + + var UNDEF = "undefined", + OBJECT = "object", + SHOCKWAVE_FLASH = "Shockwave Flash", + SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash", + FLASH_MIME_TYPE = "application/x-shockwave-flash", + EXPRESS_INSTALL_ID = "SWFObjectExprInst", + ON_READY_STATE_CHANGE = "onreadystatechange", + + win = window, + doc = document, + nav = navigator, + + plugin = false, + domLoadFnArr = [main], + regObjArr = [], + objIdArr = [], + listenersArr = [], + storedAltContent, + storedAltContentId, + storedCallbackFn, + storedCallbackObj, + isDomLoaded = false, + isExpressInstallActive = false, + dynamicStylesheet, + dynamicStylesheetMedia, + autoHideShow = true, + + /* Centralized function for browser feature detection + - User agent string detection is only used when no good alternative is possible + - Is executed directly for optimal performance + */ + ua = function() { + var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF, + u = nav.userAgent.toLowerCase(), + p = nav.platform.toLowerCase(), + windows = p ? /win/.test(p) : /win/.test(u), + mac = p ? /mac/.test(p) : /mac/.test(u), + webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, // returns either the webkit version or false if not webkit + ie = !+"\v1", // feature detection based on Andrea Giammarchi's solution: http://webreflection.blogspot.com/2009/01/32-bytes-to-know-if-your-browser-is-ie.html + playerVersion = [0,0,0], + d = null; + if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) { + d = nav.plugins[SHOCKWAVE_FLASH].description; + if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) { // navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin indicates whether plug-ins are enabled or disabled in Safari 3+ + plugin = true; + ie = false; // cascaded feature detection for Internet Explorer + d = d.replace(/^.*\s+(\S+\s+\S+$)/, "$1"); + playerVersion[0] = parseInt(d.replace(/^(.*)\..*$/, "$1"), 10); + playerVersion[1] = parseInt(d.replace(/^.*\.(.*)\s.*$/, "$1"), 10); + playerVersion[2] = /[a-zA-Z]/.test(d) ? parseInt(d.replace(/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0; + } + } + else if (typeof win.ActiveXObject != UNDEF) { + try { + var a = new ActiveXObject(SHOCKWAVE_FLASH_AX); + if (a) { // a will return null when ActiveX is disabled + d = a.GetVariable("$version"); + if (d) { + ie = true; // cascaded feature detection for Internet Explorer + d = d.split(" ")[1].split(","); + playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)]; + } + } + } + catch(e) {} + } + return { w3:w3cdom, pv:playerVersion, wk:webkit, ie:ie, win:windows, mac:mac }; + }(), + + /* Cross-browser onDomLoad + - Will fire an event as soon as the DOM of a web page is loaded + - Internet Explorer workaround based on Diego Perini's solution: http://javascript.nwbox.com/IEContentLoaded/ + - Regular onload serves as fallback + */ + onDomLoad = function() { + if (!ua.w3) { return; } + if ((typeof doc.readyState != UNDEF && doc.readyState == "complete") || (typeof doc.readyState == UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) { // function is fired after onload, e.g. when script is inserted dynamically + callDomLoadFunctions(); + } + if (!isDomLoaded) { + if (typeof doc.addEventListener != UNDEF) { + doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false); + } + if (ua.ie && ua.win) { + doc.attachEvent(ON_READY_STATE_CHANGE, function() { + if (doc.readyState == "complete") { + doc.detachEvent(ON_READY_STATE_CHANGE, arguments.callee); + callDomLoadFunctions(); + } + }); + if (win == top) { // if not inside an iframe + (function(){ + if (isDomLoaded) { return; } + try { + doc.documentElement.doScroll("left"); + } + catch(e) { + setTimeout(arguments.callee, 0); + return; + } + callDomLoadFunctions(); + })(); + } + } + if (ua.wk) { + (function(){ + if (isDomLoaded) { return; } + if (!/loaded|complete/.test(doc.readyState)) { + setTimeout(arguments.callee, 0); + return; + } + callDomLoadFunctions(); + })(); + } + addLoadEvent(callDomLoadFunctions); + } + }(); + + function callDomLoadFunctions() { + if (isDomLoaded) { return; } + try { // test if we can really add/remove elements to/from the DOM; we don't want to fire it too early + var t = doc.getElementsByTagName("body")[0].appendChild(createElement("span")); + t.parentNode.removeChild(t); + } + catch (e) { return; } + isDomLoaded = true; + var dl = domLoadFnArr.length; + for (var i = 0; i < dl; i++) { + domLoadFnArr[i](); + } + } + + function addDomLoadEvent(fn) { + if (isDomLoaded) { + fn(); + } + else { + domLoadFnArr[domLoadFnArr.length] = fn; // Array.push() is only available in IE5.5+ + } + } + + /* Cross-browser onload + - Based on James Edwards' solution: http://brothercake.com/site/resources/scripts/onload/ + - Will fire an event as soon as a web page including all of its assets are loaded + */ + function addLoadEvent(fn) { + if (typeof win.addEventListener != UNDEF) { + win.addEventListener("load", fn, false); + } + else if (typeof doc.addEventListener != UNDEF) { + doc.addEventListener("load", fn, false); + } + else if (typeof win.attachEvent != UNDEF) { + addListener(win, "onload", fn); + } + else if (typeof win.onload == "function") { + var fnOld = win.onload; + win.onload = function() { + fnOld(); + fn(); + }; + } + else { + win.onload = fn; + } + } + + /* Main function + - Will preferably execute onDomLoad, otherwise onload (as a fallback) + */ + function main() { + if (plugin) { + testPlayerVersion(); + } + else { + matchVersions(); + } + } + + /* Detect the Flash Player version for non-Internet Explorer browsers + - Detecting the plug-in version via the object element is more precise than using the plugins collection item's description: + a. Both release and build numbers can be detected + b. Avoid wrong descriptions by corrupt installers provided by Adobe + c. Avoid wrong descriptions by multiple Flash Player entries in the plugin Array, caused by incorrect browser imports + - Disadvantage of this method is that it depends on the availability of the DOM, while the plugins collection is immediately available + */ + function testPlayerVersion() { + var b = doc.getElementsByTagName("body")[0]; + var o = createElement(OBJECT); + o.setAttribute("type", FLASH_MIME_TYPE); + var t = b.appendChild(o); + if (t) { + var counter = 0; + (function(){ + if (typeof t.GetVariable != UNDEF) { + var d = t.GetVariable("$version"); + if (d) { + d = d.split(" ")[1].split(","); + ua.pv = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)]; + } + } + else if (counter < 10) { + counter++; + setTimeout(arguments.callee, 10); + return; + } + b.removeChild(o); + t = null; + matchVersions(); + })(); + } + else { + matchVersions(); + } + } + + /* Perform Flash Player and SWF version matching; static publishing only + */ + function matchVersions() { + var rl = regObjArr.length; + if (rl > 0) { + for (var i = 0; i < rl; i++) { // for each registered object element + var id = regObjArr[i].id; + var cb = regObjArr[i].callbackFn; + var cbObj = {success:false, id:id}; + if (ua.pv[0] > 0) { + var obj = getElementById(id); + if (obj) { + if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) { // Flash Player version >= published SWF version: Houston, we have a match! + setVisibility(id, true); + if (cb) { + cbObj.success = true; + cbObj.ref = getObjectById(id); + cb(cbObj); + } + } + else if (regObjArr[i].expressInstall && canExpressInstall()) { // show the Adobe Express Install dialog if set by the web page author and if supported + var att = {}; + att.data = regObjArr[i].expressInstall; + att.width = obj.getAttribute("width") || "0"; + att.height = obj.getAttribute("height") || "0"; + if (obj.getAttribute("class")) { att.styleclass = obj.getAttribute("class"); } + if (obj.getAttribute("align")) { att.align = obj.getAttribute("align"); } + // parse HTML object param element's name-value pairs + var par = {}; + var p = obj.getElementsByTagName("param"); + var pl = p.length; + for (var j = 0; j < pl; j++) { + if (p[j].getAttribute("name").toLowerCase() != "movie") { + par[p[j].getAttribute("name")] = p[j].getAttribute("value"); + } + } + showExpressInstall(att, par, id, cb); + } + else { // Flash Player and SWF version mismatch or an older Webkit engine that ignores the HTML object element's nested param elements: display alternative content instead of SWF + displayAltContent(obj); + if (cb) { cb(cbObj); } + } + } + } + else { // if no Flash Player is installed or the fp version cannot be detected we let the HTML object element do its job (either show a SWF or alternative content) + setVisibility(id, true); + if (cb) { + var o = getObjectById(id); // test whether there is an HTML object element or not + if (o && typeof o.SetVariable != UNDEF) { + cbObj.success = true; + cbObj.ref = o; + } + cb(cbObj); + } + } + } + } + } + + function getObjectById(objectIdStr) { + var r = null; + var o = getElementById(objectIdStr); + if (o && o.nodeName == "OBJECT") { + if (typeof o.SetVariable != UNDEF) { + r = o; + } + else { + var n = o.getElementsByTagName(OBJECT)[0]; + if (n) { + r = n; + } + } + } + return r; + } + + /* Requirements for Adobe Express Install + - only one instance can be active at a time + - fp 6.0.65 or higher + - Win/Mac OS only + - no Webkit engines older than version 312 + */ + function canExpressInstall() { + return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312); + } + + /* Show the Adobe Express Install dialog + - Reference: http://www.adobe.com/cfusion/knowledgebase/index.cfm?id=6a253b75 + */ + function showExpressInstall(att, par, replaceElemIdStr, callbackFn) { + isExpressInstallActive = true; + storedCallbackFn = callbackFn || null; + storedCallbackObj = {success:false, id:replaceElemIdStr}; + var obj = getElementById(replaceElemIdStr); + if (obj) { + if (obj.nodeName == "OBJECT") { // static publishing + storedAltContent = abstractAltContent(obj); + storedAltContentId = null; + } + else { // dynamic publishing + storedAltContent = obj; + storedAltContentId = replaceElemIdStr; + } + att.id = EXPRESS_INSTALL_ID; + if (typeof att.width == UNDEF || (!/%$/.test(att.width) && parseInt(att.width, 10) < 310)) { att.width = "310"; } + if (typeof att.height == UNDEF || (!/%$/.test(att.height) && parseInt(att.height, 10) < 137)) { att.height = "137"; } + doc.title = doc.title.slice(0, 47) + " - Flash Player Installation"; + var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn", + fv = "MMredirectURL=" + win.location.toString().replace(/&/g,"%26") + "&MMplayerType=" + pt + "&MMdoctitle=" + doc.title; + if (typeof par.flashvars != UNDEF) { + par.flashvars += "&" + fv; + } + else { + par.flashvars = fv; + } + // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, + // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work + if (ua.ie && ua.win && obj.readyState != 4) { + var newObj = createElement("div"); + replaceElemIdStr += "SWFObjectNew"; + newObj.setAttribute("id", replaceElemIdStr); + obj.parentNode.insertBefore(newObj, obj); // insert placeholder div that will be replaced by the object element that loads expressinstall.swf + obj.style.display = "none"; + (function(){ + if (obj.readyState == 4) { + obj.parentNode.removeChild(obj); + } + else { + setTimeout(arguments.callee, 10); + } + })(); + } + createSWF(att, par, replaceElemIdStr); + } + } + + /* Functions to abstract and display alternative content + */ + function displayAltContent(obj) { + if (ua.ie && ua.win && obj.readyState != 4) { + // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, + // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work + var el = createElement("div"); + obj.parentNode.insertBefore(el, obj); // insert placeholder div that will be replaced by the alternative content + el.parentNode.replaceChild(abstractAltContent(obj), el); + obj.style.display = "none"; + (function(){ + if (obj.readyState == 4) { + obj.parentNode.removeChild(obj); + } + else { + setTimeout(arguments.callee, 10); + } + })(); + } + else { + obj.parentNode.replaceChild(abstractAltContent(obj), obj); + } + } - if(itemEl){ - item = this.getComponent(itemEl.id.split(this.idDelimiter)[1]); - if(item.disabled){ - return { - close : null, - item : null, - el : null - }; + function abstractAltContent(obj) { + var ac = createElement("div"); + if (ua.win && ua.ie) { + ac.innerHTML = obj.innerHTML; + } + else { + var nestedObj = obj.getElementsByTagName(OBJECT)[0]; + if (nestedObj) { + var c = nestedObj.childNodes; + if (c) { + var cl = c.length; + for (var i = 0; i < cl; i++) { + if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) { + ac.appendChild(c[i].cloneNode(true)); + } + } + } } } - return { - close : e.getTarget('.x-tab-strip-close', this.strip), - item : item, - el : itemEl - }; - }, + return ac; + } + + /* Cross-browser dynamic SWF creation + */ + function createSWF(attObj, parObj, id) { + var r, el = getElementById(id); + if (ua.wk && ua.wk < 312) { return r; } + if (el) { + if (typeof attObj.id == UNDEF) { // if no 'id' is defined for the object element, it will inherit the 'id' from the alternative content + attObj.id = id; + } + if (ua.ie && ua.win) { // Internet Explorer + the HTML object element + W3C DOM methods do not combine: fall back to outerHTML + var att = ""; + for (var i in attObj) { + if (attObj[i] != Object.prototype[i]) { // filter out prototype additions from other potential libraries + if (i.toLowerCase() == "data") { + parObj.movie = attObj[i]; + } + else if (i.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword + att += ' class="' + attObj[i] + '"'; + } + else if (i.toLowerCase() != "classid") { + att += ' ' + i + '="' + attObj[i] + '"'; + } + } + } + var par = ""; + for (var j in parObj) { + if (parObj[j] != Object.prototype[j]) { // filter out prototype additions from other potential libraries + par += ''; + } + } + el.outerHTML = ''; + objIdArr[objIdArr.length] = attObj.id; // stored to fix object 'leaks' on unload (dynamic publishing only) + r = getElementById(attObj.id); + } + else { // well-behaving browsers + var o = createElement(OBJECT); + o.setAttribute("type", FLASH_MIME_TYPE); + for (var m in attObj) { + if (attObj[m] != Object.prototype[m]) { // filter out prototype additions from other potential libraries + if (m.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword + o.setAttribute("class", attObj[m]); + } + else if (m.toLowerCase() != "classid") { // filter out IE specific attribute + o.setAttribute(m, attObj[m]); + } + } + } + for (var n in parObj) { + if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") { // filter out prototype additions from other potential libraries and IE specific param element + createObjParam(o, n, parObj[n]); + } + } + el.parentNode.replaceChild(o, el); + r = o; + } + } + return r; + } + + function createObjParam(el, pName, pValue) { + var p = createElement("param"); + p.setAttribute("name", pName); + p.setAttribute("value", pValue); + el.appendChild(p); + } + + /* Cross-browser SWF removal + - Especially needed to safely and completely remove a SWF in Internet Explorer + */ + function removeSWF(id) { + var obj = getElementById(id); + if (obj && obj.nodeName == "OBJECT") { + if (ua.ie && ua.win) { + obj.style.display = "none"; + (function(){ + if (obj.readyState == 4) { + removeObjectInIE(id); + } + else { + setTimeout(arguments.callee, 10); + } + })(); + } + else { + obj.parentNode.removeChild(obj); + } + } + } + + function removeObjectInIE(id) { + var obj = getElementById(id); + if (obj) { + for (var i in obj) { + if (typeof obj[i] == "function") { + obj[i] = null; + } + } + obj.parentNode.removeChild(obj); + } + } + + /* Functions to optimize JavaScript compression + */ + function getElementById(id) { + var el = null; + try { + el = doc.getElementById(id); + } + catch (e) {} + return el; + } + + function createElement(el) { + return doc.createElement(el); + } + + /* Updated attachEvent function for Internet Explorer + - Stores attachEvent information in an Array, so on unload the detachEvent functions can be called to avoid memory leaks + */ + function addListener(target, eventType, fn) { + target.attachEvent(eventType, fn); + listenersArr[listenersArr.length] = [target, eventType, fn]; + } + + /* Flash Player and SWF content version matching + */ + function hasPlayerVersion(rv) { + var pv = ua.pv, v = rv.split("."); + v[0] = parseInt(v[0], 10); + v[1] = parseInt(v[1], 10) || 0; // supports short notation, e.g. "9" instead of "9.0.0" + v[2] = parseInt(v[2], 10) || 0; + return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false; + } + + /* Cross-browser dynamic CSS creation + - Based on Bobby van der Sluis' solution: http://www.bobbyvandersluis.com/articles/dynamicCSS.php + */ + function createCSS(sel, decl, media, newStyle) { + if (ua.ie && ua.mac) { return; } + var h = doc.getElementsByTagName("head")[0]; + if (!h) { return; } // to also support badly authored HTML pages that lack a head element + var m = (media && typeof media == "string") ? media : "screen"; + if (newStyle) { + dynamicStylesheet = null; + dynamicStylesheetMedia = null; + } + if (!dynamicStylesheet || dynamicStylesheetMedia != m) { + // create dynamic stylesheet + get a global reference to it + var s = createElement("style"); + s.setAttribute("type", "text/css"); + s.setAttribute("media", m); + dynamicStylesheet = h.appendChild(s); + if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) { + dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1]; + } + dynamicStylesheetMedia = m; + } + // add style rule + if (ua.ie && ua.win) { + if (dynamicStylesheet && typeof dynamicStylesheet.addRule == OBJECT) { + dynamicStylesheet.addRule(sel, decl); + } + } + else { + if (dynamicStylesheet && typeof doc.createTextNode != UNDEF) { + dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}")); + } + } + } + + function setVisibility(id, isVisible) { + if (!autoHideShow) { return; } + var v = isVisible ? "visible" : "hidden"; + if (isDomLoaded && getElementById(id)) { + getElementById(id).style.visibility = v; + } + else { + createCSS("#" + id, "visibility:" + v); + } + } - // private - onStripMouseDown : function(e){ - if(e.button !== 0){ - return; + /* Filter to avoid XSS attacks + */ + function urlEncodeIfNecessary(s) { + var regex = /[\\\"<>\.;]/; + var hasBadChars = regex.exec(s) != null; + return hasBadChars && typeof encodeURIComponent != UNDEF ? encodeURIComponent(s) : s; + } + + /* Release memory to avoid memory leaks caused by closures, fix hanging audio/video threads and force open sockets/NetConnections to disconnect (Internet Explorer only) + */ + var cleanup = function() { + if (ua.ie && ua.win) { + window.attachEvent("onunload", function() { + // remove listeners to avoid memory leaks + var ll = listenersArr.length; + for (var i = 0; i < ll; i++) { + listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]); + } + // cleanup dynamically embedded objects to fix audio/video threads and force open sockets and NetConnections to disconnect + var il = objIdArr.length; + for (var j = 0; j < il; j++) { + removeSWF(objIdArr[j]); + } + // cleanup library's main closures to avoid memory leaks + for (var k in ua) { + ua[k] = null; + } + ua = null; + for (var l in swfobject) { + swfobject[l] = null; + } + swfobject = null; + }); } - e.preventDefault(); - var t = this.findTargets(e); - if(t.close){ - if (t.item.fireEvent('beforeclose', t.item) !== false) { - t.item.fireEvent('close', t.item); - this.remove(t.item); + }(); + + return { + /* Public API + - Reference: http://code.google.com/p/swfobject/wiki/documentation + */ + registerObject: function(objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) { + if (ua.w3 && objectIdStr && swfVersionStr) { + var regObj = {}; + regObj.id = objectIdStr; + regObj.swfVersion = swfVersionStr; + regObj.expressInstall = xiSwfUrlStr; + regObj.callbackFn = callbackFn; + regObjArr[regObjArr.length] = regObj; + setVisibility(objectIdStr, false); + } + else if (callbackFn) { + callbackFn({success:false, id:objectIdStr}); + } + }, + + getObjectById: function(objectIdStr) { + if (ua.w3) { + return getObjectById(objectIdStr); + } + }, + + embedSWF: function(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) { + var callbackObj = {success:false, id:replaceElemIdStr}; + if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) { + setVisibility(replaceElemIdStr, false); + addDomLoadEvent(function() { + widthStr += ""; // auto-convert to string + heightStr += ""; + var att = {}; + if (attObj && typeof attObj === OBJECT) { + for (var i in attObj) { // copy object to avoid the use of references, because web authors often reuse attObj for multiple SWFs + att[i] = attObj[i]; + } + } + att.data = swfUrlStr; + att.width = widthStr; + att.height = heightStr; + var par = {}; + if (parObj && typeof parObj === OBJECT) { + for (var j in parObj) { // copy object to avoid the use of references, because web authors often reuse parObj for multiple SWFs + par[j] = parObj[j]; + } + } + if (flashvarsObj && typeof flashvarsObj === OBJECT) { + for (var k in flashvarsObj) { // copy object to avoid the use of references, because web authors often reuse flashvarsObj for multiple SWFs + if (typeof par.flashvars != UNDEF) { + par.flashvars += "&" + k + "=" + flashvarsObj[k]; + } + else { + par.flashvars = k + "=" + flashvarsObj[k]; + } + } + } + if (hasPlayerVersion(swfVersionStr)) { // create SWF + var obj = createSWF(att, par, replaceElemIdStr); + if (att.id == replaceElemIdStr) { + setVisibility(replaceElemIdStr, true); + } + callbackObj.success = true; + callbackObj.ref = obj; + } + else if (xiSwfUrlStr && canExpressInstall()) { // show Adobe Express Install + att.data = xiSwfUrlStr; + showExpressInstall(att, par, replaceElemIdStr, callbackFn); + return; + } + else { // show alternative content + setVisibility(replaceElemIdStr, true); + } + if (callbackFn) { callbackFn(callbackObj); } + }); + } + else if (callbackFn) { callbackFn(callbackObj); } + }, + + switchOffAutoHideShow: function() { + autoHideShow = false; + }, + + ua: ua, + + getFlashPlayerVersion: function() { + return { major:ua.pv[0], minor:ua.pv[1], release:ua.pv[2] }; + }, + + hasFlashPlayerVersion: hasPlayerVersion, + + createSWF: function(attObj, parObj, replaceElemIdStr) { + if (ua.w3) { + return createSWF(attObj, parObj, replaceElemIdStr); + } + else { + return undefined; } - return; - } - if(t.item && t.item != this.activeTab){ - this.setActiveTab(t.item); + }, + + showExpressInstall: function(att, par, replaceElemIdStr, callbackFn) { + if (ua.w3 && canExpressInstall()) { + showExpressInstall(att, par, replaceElemIdStr, callbackFn); + } + }, + + removeSWF: function(objElemIdStr) { + if (ua.w3) { + removeSWF(objElemIdStr); + } + }, + + createCSS: function(selStr, declStr, mediaStr, newStyleBoolean) { + if (ua.w3) { + createCSS(selStr, declStr, mediaStr, newStyleBoolean); + } + }, + + addDomLoadEvent: addDomLoadEvent, + + addLoadEvent: addLoadEvent, + + getQueryParamValue: function(param) { + var q = doc.location.search || doc.location.hash; + if (q) { + if (/\?/.test(q)) { q = q.split("?")[1]; } // strip question mark + if (param == null) { + return urlEncodeIfNecessary(q); + } + var pairs = q.split("&"); + for (var i = 0; i < pairs.length; i++) { + if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) { + return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1))); + } + } + } + return ""; + }, + + // For internal usage only + expressInstallCallback: function() { + if (isExpressInstallActive) { + var obj = getElementById(EXPRESS_INSTALL_ID); + if (obj && storedAltContent) { + obj.parentNode.replaceChild(storedAltContent, obj); + if (storedAltContentId) { + setVisibility(storedAltContentId, true); + if (ua.ie && ua.win) { storedAltContent.style.display = "block"; } + } + if (storedCallbackFn) { storedCallbackFn(storedCallbackObj); } + } + isExpressInstallActive = false; + } } - }, + }; +}(); +/** + * @class Ext.FlashComponent + * @extends Ext.BoxComponent + * @constructor + * @xtype flash + */ +Ext.FlashComponent = Ext.extend(Ext.BoxComponent, { + /** + * @cfg {String} flashVersion + * Indicates the version the flash content was published for. Defaults to '9.0.115'. + */ + flashVersion : '9.0.115', - // private - onStripContextMenu : function(e){ - e.preventDefault(); - var t = this.findTargets(e); - if(t.item){ - this.fireEvent('contextmenu', this, t.item, e); - } - }, + /** + * @cfg {String} backgroundColor + * The background color of the chart. Defaults to '#ffffff'. + */ + backgroundColor: '#ffffff', /** - * True to scan the markup in this tab panel for {@link #autoTabs} using the - * {@link #autoTabSelector} - * @param {Boolean} removeExisting True to remove existing tabs + * @cfg {String} wmode + * The wmode of the flash object. This can be used to control layering. Defaults to 'opaque'. */ - readTabs : function(removeExisting){ - if(removeExisting === true){ - this.items.each(function(item){ - this.remove(item); - }, this); - } - var tabs = this.el.query(this.autoTabSelector); - for(var i = 0, len = tabs.length; i < len; i++){ - var tab = tabs[i], - title = tab.getAttribute('title'); - tab.removeAttribute('title'); - this.add({ - title: title, - contentEl: tab - }); - } - }, + wmode: 'opaque', - // private - initTab : function(item, index){ - var before = this.strip.dom.childNodes[index], - p = this.getTemplateArgs(item), - el = before ? - this.itemTpl.insertBefore(before, p) : - this.itemTpl.append(this.strip, p), - cls = 'x-tab-strip-over', - tabEl = Ext.get(el); + /** + * @cfg {Object} flashVars + * A set of key value pairs to be passed to the flash object as flash variables. Defaults to undefined. + */ + flashVars: undefined, - tabEl.hover(function(){ - if(!item.disabled){ - tabEl.addClass(cls); - } - }, function(){ - tabEl.removeClass(cls); - }); + /** + * @cfg {Object} flashParams + * A set of key value pairs to be passed to the flash object as parameters. Possible parameters can be found here: + * http://kb2.adobe.com/cps/127/tn_12701.html Defaults to undefined. + */ + flashParams: undefined, - if(item.tabTip){ - tabEl.child('span.x-tab-strip-text', true).qtip = item.tabTip; - } - item.tabEl = el; + /** + * @cfg {String} url + * The URL of the chart to include. Defaults to undefined. + */ + url: undefined, + swfId : undefined, + swfWidth: '100%', + swfHeight: '100%', - // Route *keyboard triggered* click events to the tab strip mouse handler. - tabEl.select('a').on('click', function(e){ - if(!e.getPageX()){ - this.onStripMouseDown(e); - } - }, this, {preventDefault: true}); + /** + * @cfg {Boolean} expressInstall + * True to prompt the user to install flash if not installed. Note that this uses + * Ext.FlashComponent.EXPRESS_INSTALL_URL, which should be set to the local resource. Defaults to false. + */ + expressInstall: false, - item.on({ - scope: this, - disable: this.onItemDisabled, - enable: this.onItemEnabled, - titlechange: this.onItemTitleChanged, - iconchange: this.onItemIconChanged, - beforeshow: this.onBeforeShowItem - }); + initComponent : function(){ + Ext.FlashComponent.superclass.initComponent.call(this); + + this.addEvents( + /** + * @event initialize + * + * @param {Chart} this + */ + 'initialize' + ); }, + onRender : function(){ + Ext.FlashComponent.superclass.onRender.apply(this, arguments); + var params = Ext.apply({ + allowScriptAccess: 'always', + bgcolor: this.backgroundColor, + wmode: this.wmode + }, this.flashParams), vars = Ext.apply({ + allowedDomain: document.location.hostname, + YUISwfId: this.getId(), + YUIBridgeCallback: 'Ext.FlashEventProxy.onEvent' + }, this.flashVars); - /** - * Provides template arguments for rendering a tab selector item in the tab strip. - * This method returns an object hash containing properties used by the TabPanel's {@link #itemTpl} - * to create a formatted, clickable tab selector element. The properties which must be returned - * are: - * id : StringA unique identifier which links to the item - * text : StringThe text to display - * cls : StringThe CSS class name - * iconCls : StringA CSS class to provide appearance for an icon. - * - * @param {BoxComponent} item The {@link Ext.BoxComponent BoxComponent} for which to create a selector element in the tab strip. - * @return {Object} An object hash containing the properties required to render the selector element. - */ - getTemplateArgs : function(item) { - var cls = item.closable ? 'x-tab-strip-closable' : ''; - if(item.disabled){ - cls += ' x-item-disabled'; - } - if(item.iconCls){ - cls += ' x-tab-with-icon'; - } - if(item.tabCls){ - cls += ' ' + item.tabCls; - } + new swfobject.embedSWF(this.url, this.id, this.swfWidth, this.swfHeight, this.flashVersion, + this.expressInstall ? Ext.FlashComponent.EXPRESS_INSTALL_URL : undefined, vars, params); - return { - id: this.id + this.idDelimiter + item.getItemId(), - text: item.title, - cls: cls, - iconCls: item.iconCls || '' - }; + this.swf = Ext.getDom(this.id); + this.el = Ext.get(this.swf); }, - // private - onAdd : function(c){ - Ext.TabPanel.superclass.onAdd.call(this, c); - if(this.rendered){ - var items = this.items; - this.initTab(c, items.indexOf(c)); - if(items.getCount() == 1){ - this.syncSize(); - } - this.delegateUpdates(); - } + getSwfId : function(){ + return this.swfId || (this.swfId = "extswf" + (++Ext.Component.AUTO_ID)); }, - // private - onBeforeAdd : function(item){ - var existing = item.events ? (this.items.containsKey(item.getItemId()) ? item : null) : this.items.get(item); - if(existing){ - this.setActiveTab(item); - return false; - } - Ext.TabPanel.superclass.onBeforeAdd.apply(this, arguments); - var es = item.elements; - item.elements = es ? es.replace(',header', '') : es; - item.border = (item.border === true); + getId : function(){ + return this.id || (this.id = "extflashcmp" + (++Ext.Component.AUTO_ID)); }, - // private - onRemove : function(c){ - var te = Ext.get(c.tabEl); - // check if the tabEl exists, it won't if the tab isn't rendered - if(te){ - te.select('a').removeAllListeners(); - Ext.destroy(te); - } - Ext.TabPanel.superclass.onRemove.call(this, c); - this.stack.remove(c); - delete c.tabEl; - c.un('disable', this.onItemDisabled, this); - c.un('enable', this.onItemEnabled, this); - c.un('titlechange', this.onItemTitleChanged, this); - c.un('iconchange', this.onItemIconChanged, this); - c.un('beforeshow', this.onBeforeShowItem, this); - if(c == this.activeTab){ - var next = this.stack.next(); - if(next){ - this.setActiveTab(next); - }else if(this.items.getCount() > 0){ - this.setActiveTab(0); - }else{ - this.setActiveTab(null); - } - } - if(!this.destroying){ - this.delegateUpdates(); + onFlashEvent : function(e){ + switch(e.type){ + case "swfReady": + this.initSwf(); + return; + case "log": + return; } + e.component = this; + this.fireEvent(e.type.toLowerCase().replace(/event$/, ''), e); }, - // private - onBeforeShowItem : function(item){ - if(item != this.activeTab){ - this.setActiveTab(item); - return false; - } + initSwf : function(){ + this.onSwfReady(!!this.isInitialized); + this.isInitialized = true; + this.fireEvent('initialize', this); }, - // private - onItemDisabled : function(item){ - var el = this.getTabEl(item); - if(el){ - Ext.fly(el).addClass('x-item-disabled'); + beforeDestroy: function(){ + if(this.rendered){ + swfobject.removeSWF(this.swf.id); } - this.stack.remove(item); + Ext.FlashComponent.superclass.beforeDestroy.call(this); }, - // private - onItemEnabled : function(item){ - var el = this.getTabEl(item); - if(el){ - Ext.fly(el).removeClass('x-item-disabled'); - } - }, + onSwfReady : Ext.emptyFn +}); - // private - onItemTitleChanged : function(item){ - var el = this.getTabEl(item); - if(el){ - Ext.fly(el).child('span.x-tab-strip-text', true).innerHTML = item.title; - } - }, +/** + * Sets the url for installing flash if it doesn't exist. This should be set to a local resource. + * @static + * @type String + */ +Ext.FlashComponent.EXPRESS_INSTALL_URL = 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'; - //private - onItemIconChanged : function(item, iconCls, oldCls){ - var el = this.getTabEl(item); - if(el){ - el = Ext.get(el); - el.child('span.x-tab-strip-text').replaceClass(oldCls, iconCls); - el[Ext.isEmpty(iconCls) ? 'removeClass' : 'addClass']('x-tab-with-icon'); +Ext.reg('flash', Ext.FlashComponent);/** + * @class Ext.FlashProxy + * @singleton + */ +Ext.FlashEventProxy = { + onEvent : function(id, e){ + var fp = Ext.getCmp(id); + if(fp){ + fp.onFlashEvent(e); + }else{ + arguments.callee.defer(10, this, [id, e]); } - }, + } +};/** + * @class Ext.chart.Chart + * @extends Ext.FlashComponent + * The Ext.chart package provides the capability to visualize data with flash based charting. + * Each chart binds directly to an Ext.data.Store enabling automatic updates of the chart. + * To change the look and feel of a chart, see the {@link #chartStyle} and {@link #extraStyle} config options. + * @constructor + * @xtype chart + */ + + Ext.chart.Chart = Ext.extend(Ext.FlashComponent, { + refreshBuffer: 100, /** - * Gets the DOM element for the tab strip item which activates the child panel with the specified - * ID. Access this to change the visual treatment of the item, for example by changing the CSS class name. - * @param {Panel/Number/String} tab The tab component, or the tab's index, or the tabs id or itemId. - * @return {HTMLElement} The DOM node + * @cfg {String} backgroundColor + * @hide */ - getTabEl : function(item){ - var c = this.getComponent(item); - return c ? c.tabEl : null; - }, - // private - onResize : function(){ - Ext.TabPanel.superclass.onResize.apply(this, arguments); - this.delegateUpdates(); + /** + * @cfg {Object} chartStyle + * Sets styles for this chart. This contains default styling, so modifying this property will override + * the built in styles of the chart. Use {@link #extraStyle} to add customizations to the default styling. + */ + chartStyle: { + padding: 10, + animationEnabled: true, + font: { + name: 'Tahoma', + color: 0x444444, + size: 11 + }, + dataTip: { + padding: 5, + border: { + color: 0x99bbe8, + size:1 + }, + background: { + color: 0xDAE7F6, + alpha: .9 + }, + font: { + name: 'Tahoma', + color: 0x15428B, + size: 10, + bold: true + } + } }, /** - * Suspends any internal calculations or scrolling while doing a bulk operation. See {@link #endUpdate} + * @cfg {String} url + * The url to load the chart from. This defaults to Ext.chart.Chart.CHART_URL, which should + * be modified to point to the local charts resource. + */ + + /** + * @cfg {Object} extraStyle + * Contains extra styles that will be added or overwritten to the default chartStyle. Defaults to null. + * For a detailed list of the options available, visit the YUI Charts site + * at http://developer.yahoo.com/yui/charts/#basicstyles + * Some of the options availabe: + * + * padding - The space around the edge of the chart's contents. Padding does not increase the size of the chart. + * animationEnabled - A Boolean value that specifies whether marker animations are enabled or not. Enabled by default. + * font - An Object defining the font style to be used in the chart. Defaults to { name: 'Tahoma', color: 0x444444, size: 11 } + * + * name - font name + * color - font color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) + * size - font size in points (numeric portion only, ie: 11) + * bold - boolean + * italic - boolean + * underline - boolean + * + * + * border - An object defining the border style around the chart. The chart itself will decrease in dimensions to accomodate the border. + * + * color - border color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) + * size - border size in pixels (numeric portion only, ie: 1) + * + * + * background - An object defining the background style of the chart. + * + * color - border color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) + * image - an image URL. May be relative to the current document or absolute. + * + * + * legend - An object defining the legend style + * + * display - location of the legend. Possible values are "none", "left", "right", "top", and "bottom". + * spacing - an image URL. May be relative to the current document or absolute. + * padding, border, background, font - same options as described above. + * + * dataTip - An object defining the style of the data tip (tooltip). + * + * padding, border, background, font - same options as described above. + * + * xAxis and yAxis - An object defining the style of the style of either axis. + * + * color - same option as described above. + * size - same option as described above. + * showLabels - boolean + * labelRotation - a value in degrees from -90 through 90. Default is zero. + * + * majorGridLines and minorGridLines - An object defining the style of the style of the grid lines. + * + * color, size - same options as described above. + * + * zeroGridLine - An object defining the style of the style of the zero grid line. + * + * color, size - same options as described above. + * + * majorTicks and minorTicks - An object defining the style of the style of ticks in the chart. + * + * color, size - same options as described above. + * length - the length of each tick in pixels extending from the axis. + * display - how the ticks are drawn. Possible values are "none", "inside", "outside", and "cross". + * + * */ - beginUpdate : function(){ - this.suspendUpdates = true; - }, + extraStyle: null, /** - * Resumes calculations and scrolling at the end of a bulk operation. See {@link #beginUpdate} + * @cfg {Object} seriesStyles + * Contains styles to apply to the series after a refresh. Defaults to null. */ - endUpdate : function(){ - this.suspendUpdates = false; - this.delegateUpdates(); - }, + seriesStyles: null, /** - * Hides the tab strip item for the passed tab - * @param {Number/String/Panel} item The tab index, id or item + * @cfg {Boolean} disableCaching + * True to add a "cache buster" to the end of the chart url. Defaults to true for Opera and IE. */ - hideTabStripItem : function(item){ - item = this.getComponent(item); - var el = this.getTabEl(item); - if(el){ - el.style.display = 'none'; - this.delegateUpdates(); + disableCaching: Ext.isIE || Ext.isOpera, + disableCacheParam: '_dc', + + initComponent : function(){ + Ext.chart.Chart.superclass.initComponent.call(this); + if(!this.url){ + this.url = Ext.chart.Chart.CHART_URL; } - this.stack.remove(item); + if(this.disableCaching){ + this.url = Ext.urlAppend(this.url, String.format('{0}={1}', this.disableCacheParam, new Date().getTime())); + } + this.addEvents( + 'itemmouseover', + 'itemmouseout', + 'itemclick', + 'itemdoubleclick', + 'itemdragstart', + 'itemdrag', + 'itemdragend', + /** + * @event beforerefresh + * Fires before a refresh to the chart data is called. If the beforerefresh handler returns + * false the {@link #refresh} action will be cancelled. + * @param {Chart} this + */ + 'beforerefresh', + /** + * @event refresh + * Fires after the chart data has been refreshed. + * @param {Chart} this + */ + 'refresh' + ); + this.store = Ext.StoreMgr.lookup(this.store); }, /** - * Unhides the tab strip item for the passed tab - * @param {Number/String/Panel} item The tab index, id or item + * Sets a single style value on the Chart instance. + * + * @param name {String} Name of the Chart style value to change. + * @param value {Object} New value to pass to the Chart style. */ - unhideTabStripItem : function(item){ - item = this.getComponent(item); - var el = this.getTabEl(item); - if(el){ - el.style.display = ''; - this.delegateUpdates(); - } + setStyle: function(name, value){ + this.swf.setStyle(name, Ext.encode(value)); + }, + + /** + * Resets all styles on the Chart instance. + * + * @param styles {Object} Initializer for all Chart styles. + */ + setStyles: function(styles){ + this.swf.setStyles(Ext.encode(styles)); }, - // private - delegateUpdates : function(){ - if(this.suspendUpdates){ - return; - } - if(this.resizeTabs && this.rendered){ - this.autoSizeTabs(); - } - if(this.enableTabScroll && this.rendered){ - this.autoScrollTabs(); - } + /** + * Sets the styles on all series in the Chart. + * + * @param styles {Array} Initializer for all Chart series styles. + */ + setSeriesStyles: function(styles){ + this.seriesStyles = styles; + var s = []; + Ext.each(styles, function(style){ + s.push(Ext.encode(style)); + }); + this.swf.setSeriesStyles(s); }, - // private - autoSizeTabs : function(){ - var count = this.items.length, - ce = this.tabPosition != 'bottom' ? 'header' : 'footer', - ow = this[ce].dom.offsetWidth, - aw = this[ce].dom.clientWidth; + setCategoryNames : function(names){ + this.swf.setCategoryNames(names); + }, - if(!this.resizeTabs || count < 1 || !aw){ // !aw for display:none - return; - } + setLegendRenderer : function(fn, scope){ + var chart = this; + scope = scope || chart; + chart.removeFnProxy(chart.legendFnName); + chart.legendFnName = chart.createFnProxy(function(name){ + return fn.call(scope, name); + }); + chart.swf.setLegendLabelFunction(chart.legendFnName); + }, - var each = Math.max(Math.min(Math.floor((aw-4) / count) - this.tabMargin, this.tabWidth), this.minTabWidth); // -4 for float errors in IE - this.lastTabWidth = each; - var lis = this.strip.query('li:not(.x-tab-edge)'); - for(var i = 0, len = lis.length; i < len; i++) { - var li = lis[i], - inner = Ext.fly(li).child('.x-tab-strip-inner', true), - tw = li.offsetWidth, - iw = inner.offsetWidth; - inner.style.width = (each - (tw-iw)) + 'px'; - } + setTipRenderer : function(fn, scope){ + var chart = this; + scope = scope || chart; + chart.removeFnProxy(chart.tipFnName); + chart.tipFnName = chart.createFnProxy(function(item, index, series){ + var record = chart.store.getAt(index); + return fn.call(scope, chart, record, index, series); + }); + chart.swf.setDataTipFunction(chart.tipFnName); }, - // private - adjustBodyWidth : function(w){ - if(this.header){ - this.header.setWidth(w); - } - if(this.footer){ - this.footer.setWidth(w); - } - return w; + setSeries : function(series){ + this.series = series; + this.refresh(); }, /** - * Sets the specified tab as the active tab. This method fires the {@link #beforetabchange} event which - * can return false to cancel the tab change. - * @param {String/Number} item - * The id or tab Panel to activate. This parameter may be any of the following: - * - * a String : representing the {@link Ext.Component#itemId itemId} - * or {@link Ext.Component#id id} of the child component - * a Number : representing the position of the child component - * within the {@link Ext.Container#items items} property - * - * For additional information see {@link Ext.util.MixedCollection#get}. + * Changes the data store bound to this chart and refreshes it. + * @param {Store} store The store to bind to this chart */ - setActiveTab : function(item){ - item = this.getComponent(item); - if(this.fireEvent('beforetabchange', this, item, this.activeTab) === false){ - return; + bindStore : function(store, initial){ + if(!initial && this.store){ + if(store !== this.store && this.store.autoDestroy){ + this.store.destroy(); + }else{ + this.store.un("datachanged", this.refresh, this); + this.store.un("add", this.delayRefresh, this); + this.store.un("remove", this.delayRefresh, this); + this.store.un("update", this.delayRefresh, this); + this.store.un("clear", this.refresh, this); + } } - if(!this.rendered){ - this.activeTab = item; - return; + if(store){ + store = Ext.StoreMgr.lookup(store); + store.on({ + scope: this, + datachanged: this.refresh, + add: this.delayRefresh, + remove: this.delayRefresh, + update: this.delayRefresh, + clear: this.refresh + }); } - if(this.activeTab != item){ - if(this.activeTab){ - var oldEl = this.getTabEl(this.activeTab); - if(oldEl){ - Ext.fly(oldEl).removeClass('x-tab-strip-active'); - } - } - if(item){ - var el = this.getTabEl(item); - Ext.fly(el).addClass('x-tab-strip-active'); - this.activeTab = item; - this.stack.add(item); - - this.layout.setActiveItem(item); - if(this.scrolling){ - this.scrollToTab(item, this.animScroll); - } - } - this.fireEvent('tabchange', this, item); + this.store = store; + if(store && !initial){ + this.refresh(); } }, - /** - * Returns the Component which is the currently active tab. Note that before the TabPanel - * first activates a child Component, this method will return whatever was configured in the - * {@link #activeTab} config option. - * @return {BoxComponent} The currently active child Component if one is active, or the {@link #activeTab} config value. - */ - getActiveTab : function(){ - return this.activeTab || null; - }, + onSwfReady : function(isReset){ + Ext.chart.Chart.superclass.onSwfReady.call(this, isReset); + var ref; + this.swf.setType(this.type); - /** - * Gets the specified tab by id. - * @param {String} id The tab id - * @return {Panel} The tab - */ - getItem : function(item){ - return this.getComponent(item); - }, + if(this.chartStyle){ + this.setStyles(Ext.apply({}, this.extraStyle, this.chartStyle)); + } - // private - autoScrollTabs : function(){ - this.pos = this.tabPosition=='bottom' ? this.footer : this.header; - var count = this.items.length, - ow = this.pos.dom.offsetWidth, - tw = this.pos.dom.clientWidth, - wrap = this.stripWrap, - wd = wrap.dom, - cw = wd.offsetWidth, - pos = this.getScrollPos(), - l = this.edge.getOffsetsTo(this.stripWrap)[0] + pos; + if(this.categoryNames){ + this.setCategoryNames(this.categoryNames); + } + + if(this.tipRenderer){ + ref = this.getFunctionRef(this.tipRenderer); + this.setTipRenderer(ref.fn, ref.scope); + } + if(this.legendRenderer){ + ref = this.getFunctionRef(this.legendRenderer); + this.setLegendRenderer(ref.fn, ref.scope); + } + if(!isReset){ + this.bindStore(this.store, true); + } + this.refresh.defer(10, this); + }, - if(!this.enableTabScroll || count < 1 || cw < 20){ // 20 to prevent display:none issues - return; + delayRefresh : function(){ + if(!this.refreshTask){ + this.refreshTask = new Ext.util.DelayedTask(this.refresh, this); } - if(l <= tw){ - wd.scrollLeft = 0; - wrap.setWidth(tw); - if(this.scrolling){ - this.scrolling = false; - this.pos.removeClass('x-tab-scrolling'); - this.scrollLeft.hide(); - this.scrollRight.hide(); - // See here: http://extjs.com/forum/showthread.php?t=49308&highlight=isSafari - if(Ext.isAir || Ext.isWebKit){ - wd.style.marginLeft = ''; - wd.style.marginRight = ''; - } - } - }else{ - if(!this.scrolling){ - this.pos.addClass('x-tab-scrolling'); - // See here: http://extjs.com/forum/showthread.php?t=49308&highlight=isSafari - if(Ext.isAir || Ext.isWebKit){ - wd.style.marginLeft = '18px'; - wd.style.marginRight = '18px'; + this.refreshTask.delay(this.refreshBuffer); + }, + + refresh : function(){ + if(this.fireEvent('beforerefresh', this) !== false){ + var styleChanged = false; + // convert the store data into something YUI charts can understand + var data = [], rs = this.store.data.items; + for(var j = 0, len = rs.length; j < len; j++){ + data[j] = rs[j].data; + } + //make a copy of the series definitions so that we aren't + //editing them directly. + var dataProvider = []; + var seriesCount = 0; + var currentSeries = null; + var i = 0; + if(this.series){ + seriesCount = this.series.length; + for(i = 0; i < seriesCount; i++){ + currentSeries = this.series[i]; + var clonedSeries = {}; + for(var prop in currentSeries){ + if(prop == "style" && currentSeries.style !== null){ + clonedSeries.style = Ext.encode(currentSeries.style); + styleChanged = true; + //we don't want to modify the styles again next time + //so null out the style property. + // this causes issues + // currentSeries.style = null; + } else{ + clonedSeries[prop] = currentSeries[prop]; + } + } + dataProvider.push(clonedSeries); } } - tw -= wrap.getMargins('lr'); - wrap.setWidth(tw > 20 ? tw : 20); - if(!this.scrolling){ - if(!this.scrollLeft){ - this.createScrollers(); - }else{ - this.scrollLeft.show(); - this.scrollRight.show(); + + if(seriesCount > 0){ + for(i = 0; i < seriesCount; i++){ + currentSeries = dataProvider[i]; + if(!currentSeries.type){ + currentSeries.type = this.type; + } + currentSeries.dataProvider = data; } + } else{ + dataProvider.push({type: this.type, dataProvider: data}); } - this.scrolling = true; - if(pos > (l-tw)){ // ensure it stays within bounds - wd.scrollLeft = l-tw; - }else{ // otherwise, make sure the active tab is still visible - this.scrollToTab(this.activeTab, false); + this.swf.setDataProvider(dataProvider); + if(this.seriesStyles){ + this.setSeriesStyles(this.seriesStyles); } - this.updateScrollButtons(); + this.fireEvent('refresh', this); } }, // private - createScrollers : function(){ - this.pos.addClass('x-tab-scrolling-' + this.tabPosition); - var h = this.stripWrap.dom.offsetHeight; - - // left - var sl = this.pos.insertFirst({ - cls:'x-tab-scroller-left' - }); - sl.setHeight(h); - sl.addClassOnOver('x-tab-scroller-left-over'); - this.leftRepeater = new Ext.util.ClickRepeater(sl, { - interval : this.scrollRepeatInterval, - handler: this.onScrollLeft, - scope: this - }); - this.scrollLeft = sl; - - // right - var sr = this.pos.insertFirst({ - cls:'x-tab-scroller-right' - }); - sr.setHeight(h); - sr.addClassOnOver('x-tab-scroller-right-over'); - this.rightRepeater = new Ext.util.ClickRepeater(sr, { - interval : this.scrollRepeatInterval, - handler: this.onScrollRight, - scope: this - }); - this.scrollRight = sr; + createFnProxy : function(fn){ + var fnName = 'extFnProxy' + (++Ext.chart.Chart.PROXY_FN_ID); + Ext.chart.Chart.proxyFunction[fnName] = fn; + return 'Ext.chart.Chart.proxyFunction.' + fnName; }, // private - getScrollWidth : function(){ - return this.edge.getOffsetsTo(this.stripWrap)[0] + this.getScrollPos(); + removeFnProxy : function(fn){ + if(!Ext.isEmpty(fn)){ + fn = fn.replace('Ext.chart.Chart.proxyFunction.', ''); + delete Ext.chart.Chart.proxyFunction[fn]; + } }, // private - getScrollPos : function(){ - return parseInt(this.stripWrap.dom.scrollLeft, 10) || 0; + getFunctionRef : function(val){ + if(Ext.isFunction(val)){ + return { + fn: val, + scope: this + }; + }else{ + return { + fn: val.fn, + scope: val.scope || this + } + } }, // private - getScrollArea : function(){ - return parseInt(this.stripWrap.dom.clientWidth, 10) || 0; - }, + onDestroy: function(){ + if (this.refreshTask && this.refreshTask.cancel){ + this.refreshTask.cancel(); + } + Ext.chart.Chart.superclass.onDestroy.call(this); + this.bindStore(null); + this.removeFnProxy(this.tipFnName); + this.removeFnProxy(this.legendFnName); + } +}); +Ext.reg('chart', Ext.chart.Chart); +Ext.chart.Chart.PROXY_FN_ID = 0; +Ext.chart.Chart.proxyFunction = {}; - // private - getScrollAnim : function(){ - return {duration:this.scrollDuration, callback: this.updateScrollButtons, scope: this}; +/** + * Sets the url to load the chart from. This should be set to a local resource. + * @static + * @type String + */ +Ext.chart.Chart.CHART_URL = 'http:/' + '/yui.yahooapis.com/2.8.0/build/charts/assets/charts.swf'; + +/** + * @class Ext.chart.PieChart + * @extends Ext.chart.Chart + * @constructor + * @xtype piechart + */ +Ext.chart.PieChart = Ext.extend(Ext.chart.Chart, { + type: 'pie', + + onSwfReady : function(isReset){ + Ext.chart.PieChart.superclass.onSwfReady.call(this, isReset); + + this.setDataField(this.dataField); + this.setCategoryField(this.categoryField); }, - // private - getScrollIncrement : function(){ - return this.scrollIncrement || (this.resizeTabs ? this.lastTabWidth+2 : 100); + setDataField : function(field){ + this.dataField = field; + this.swf.setDataField(field); }, - /** - * Scrolls to a particular tab if tab scrolling is enabled - * @param {Panel} item The item to scroll to - * @param {Boolean} animate True to enable animations - */ + setCategoryField : function(field){ + this.categoryField = field; + this.swf.setCategoryField(field); + } +}); +Ext.reg('piechart', Ext.chart.PieChart); - scrollToTab : function(item, animate){ - if(!item){ - return; +/** + * @class Ext.chart.CartesianChart + * @extends Ext.chart.Chart + * @constructor + * @xtype cartesianchart + */ +Ext.chart.CartesianChart = Ext.extend(Ext.chart.Chart, { + onSwfReady : function(isReset){ + Ext.chart.CartesianChart.superclass.onSwfReady.call(this, isReset); + this.labelFn = []; + if(this.xField){ + this.setXField(this.xField); } - var el = this.getTabEl(item), - pos = this.getScrollPos(), - area = this.getScrollArea(), - left = Ext.fly(el).getOffsetsTo(this.stripWrap)[0] + pos, - right = left + el.offsetWidth; - if(left < pos){ - this.scrollTo(left, animate); - }else if(right > (pos + area)){ - this.scrollTo(right - area, animate); + if(this.yField){ + this.setYField(this.yField); + } + if(this.xAxis){ + this.setXAxis(this.xAxis); + } + if(this.xAxes){ + this.setXAxes(this.xAxes); + } + if(this.yAxis){ + this.setYAxis(this.yAxis); + } + if(this.yAxes){ + this.setYAxes(this.yAxes); + } + if(Ext.isDefined(this.constrainViewport)){ + this.swf.setConstrainViewport(this.constrainViewport); } }, - // private - scrollTo : function(pos, animate){ - this.stripWrap.scrollTo('left', pos, animate ? this.getScrollAnim() : false); - if(!animate){ - this.updateScrollButtons(); - } + setXField : function(value){ + this.xField = value; + this.swf.setHorizontalField(value); }, - onWheel : function(e){ - var d = e.getWheelDelta()*this.wheelIncrement*-1; - e.stopEvent(); + setYField : function(value){ + this.yField = value; + this.swf.setVerticalField(value); + }, - var pos = this.getScrollPos(), - newpos = pos + d, - sw = this.getScrollWidth()-this.getScrollArea(); + setXAxis : function(value){ + this.xAxis = this.createAxis('xAxis', value); + this.swf.setHorizontalAxis(this.xAxis); + }, - var s = Math.max(0, Math.min(sw, newpos)); - if(s != pos){ - this.scrollTo(s, false); + setXAxes : function(value){ + var axis; + for(var i = 0; i < value.length; i++) { + axis = this.createAxis('xAxis' + i, value[i]); + this.swf.setHorizontalAxis(axis); } }, - // private - onScrollRight : function(){ - var sw = this.getScrollWidth()-this.getScrollArea(), - pos = this.getScrollPos(), - s = Math.min(sw, pos + this.getScrollIncrement()); - if(s != pos){ - this.scrollTo(s, this.animScroll); - } + setYAxis : function(value){ + this.yAxis = this.createAxis('yAxis', value); + this.swf.setVerticalAxis(this.yAxis); }, - // private - onScrollLeft : function(){ - var pos = this.getScrollPos(), - s = Math.max(0, pos - this.getScrollIncrement()); - if(s != pos){ - this.scrollTo(s, this.animScroll); + setYAxes : function(value){ + var axis; + for(var i = 0; i < value.length; i++) { + axis = this.createAxis('yAxis' + i, value[i]); + this.swf.setVerticalAxis(axis); } }, - // private - updateScrollButtons : function(){ - var pos = this.getScrollPos(); - this.scrollLeft[pos === 0 ? 'addClass' : 'removeClass']('x-tab-scroller-left-disabled'); - this.scrollRight[pos >= (this.getScrollWidth()-this.getScrollArea()) ? 'addClass' : 'removeClass']('x-tab-scroller-right-disabled'); + createAxis : function(axis, value){ + var o = Ext.apply({}, value), + ref, + old; + + if(this[axis]){ + old = this[axis].labelFunction; + this.removeFnProxy(old); + this.labelFn.remove(old); + } + if(o.labelRenderer){ + ref = this.getFunctionRef(o.labelRenderer); + o.labelFunction = this.createFnProxy(function(v){ + return ref.fn.call(ref.scope, v); + }); + delete o.labelRenderer; + this.labelFn.push(o.labelFunction); + } + if(axis.indexOf('xAxis') > -1 && o.position == 'left'){ + o.position = 'bottom'; + } + return o; }, - // private - beforeDestroy : function() { - Ext.destroy(this.leftRepeater, this.rightRepeater); - this.deleteMembers('strip', 'edge', 'scrollLeft', 'scrollRight', 'stripWrap'); - this.activeTab = null; - Ext.TabPanel.superclass.beforeDestroy.apply(this); + onDestroy : function(){ + Ext.chart.CartesianChart.superclass.onDestroy.call(this); + Ext.each(this.labelFn, function(fn){ + this.removeFnProxy(fn); + }, this); } - - /** - * @cfg {Boolean} collapsible - * @hide - */ - /** - * @cfg {String} header - * @hide - */ - /** - * @cfg {Boolean} headerAsText - * @hide - */ - /** - * @property header - * @hide - */ - /** - * @cfg title - * @hide - */ - /** - * @cfg {Array} tools - * @hide - */ - /** - * @cfg {Array} toolTemplate - * @hide - */ - /** - * @cfg {Boolean} hideCollapseTool - * @hide - */ - /** - * @cfg {Boolean} titleCollapse - * @hide - */ - /** - * @cfg {Boolean} collapsed - * @hide - */ - /** - * @cfg {String} layout - * @hide - */ - /** - * @cfg {Boolean} preventBodyReset - * @hide - */ }); -Ext.reg('tabpanel', Ext.TabPanel); +Ext.reg('cartesianchart', Ext.chart.CartesianChart); /** - * See {@link #setActiveTab}. Sets the specified tab as the active tab. This method fires - * the {@link #beforetabchange} event which can return false to cancel the tab change. - * @param {String/Panel} tab The id or tab Panel to activate - * @method activate + * @class Ext.chart.LineChart + * @extends Ext.chart.CartesianChart + * @constructor + * @xtype linechart */ -Ext.TabPanel.prototype.activate = Ext.TabPanel.prototype.setActiveTab; - -// private utility class used by TabPanel -Ext.TabPanel.AccessStack = function(){ - var items = []; - return { - add : function(item){ - items.push(item); - if(items.length > 10){ - items.shift(); - } - }, - - remove : function(item){ - var s = []; - for(var i = 0, len = items.length; i < len; i++) { - if(items[i] != item){ - s.push(items[i]); - } - } - items = s; - }, - - next : function(){ - return items.pop(); - } - }; -}; -/** - * @class Ext.Button - * @extends Ext.BoxComponent - * Simple Button class - * @cfg {String} text The button text to be used as innerHTML (html tags are accepted) - * @cfg {String} icon The path to an image to display in the button (the image will be set as the background-image - * CSS property of the button by default, so if you want a mixed icon/text button, set cls:'x-btn-text-icon') - * @cfg {Function} handler A function called when the button is clicked (can be used instead of click event). - * The handler is passed the following parameters: - * b : ButtonThis Button. - * e : EventObjectThe click event. - * - * @cfg {Number} minWidth The minimum width for this button (used to give a set of buttons a common width). - * See also {@link Ext.Panel}.{@link Ext.Panel#minButtonWidth minButtonWidth}. - * @cfg {String/Object} tooltip The tooltip for the button - can be a string to be used as innerHTML (html tags are accepted) or QuickTips config object - * @cfg {Boolean} hidden True to start hidden (defaults to false) - * @cfg {Boolean} disabled True to start disabled (defaults to false) - * @cfg {Boolean} pressed True to start pressed (only if enableToggle = true) - * @cfg {String} toggleGroup The group this toggle button is a member of (only 1 per group can be pressed) - * @cfg {Boolean/Object} repeat True to repeat fire the click event while the mouse is down. This can also be - * a {@link Ext.util.ClickRepeater ClickRepeater} config object (defaults to false). - * @constructor - * Create a new button - * @param {Object} config The config object - * @xtype button - */ -Ext.Button = Ext.extend(Ext.BoxComponent, { - /** - * Read-only. True if this button is hidden - * @type Boolean - */ - hidden : false, - /** - * Read-only. True if this button is disabled - * @type Boolean - */ - disabled : false, - /** - * Read-only. True if this button is pressed (only if enableToggle = true) - * @type Boolean - */ - pressed : false, - - /** - * @cfg {Number} tabIndex Set a DOM tabIndex for this button (defaults to undefined) - */ - - /** - * @cfg {Boolean} allowDepress - * False to not allow a pressed Button to be depressed (defaults to undefined). Only valid when {@link #enableToggle} is true. - */ - - /** - * @cfg {Boolean} enableToggle - * True to enable pressed/not pressed toggling (defaults to false) - */ - enableToggle : false, - /** - * @cfg {Function} toggleHandler - * Function called when a Button with {@link #enableToggle} set to true is clicked. Two arguments are passed: - * button : Ext.Buttonthis Button object - * state : BooleanThe next state of the Button, true means pressed. - * - */ - /** - * @cfg {Mixed} menu - * Standard menu attribute consisting of a reference to a menu object, a menu id or a menu config blob (defaults to undefined). - */ - /** - * @cfg {String} menuAlign - * The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?'). - */ - menuAlign : 'tl-bl?', - - /** - * @cfg {String} overflowText If used in a {@link Ext.Toolbar Toolbar}, the - * text to be used if this item is shown in the overflow menu. See also - * {@link Ext.Toolbar.Item}.{@link Ext.Toolbar.Item#overflowText overflowText}. - */ - /** - * @cfg {String} iconCls - * A css class which sets a background image to be used as the icon for this button - */ - /** - * @cfg {String} type - * submit, reset or button - defaults to 'button' - */ - type : 'button', - - // private - menuClassTarget : 'tr:nth(2)', - - /** - * @cfg {String} clickEvent - * The DOM event that will fire the handler of the button. This can be any valid event name (dblclick, contextmenu). - * Defaults to 'click'. - */ - clickEvent : 'click', - - /** - * @cfg {Boolean} handleMouseEvents - * False to disable visual cues on mouseover, mouseout and mousedown (defaults to true) - */ - handleMouseEvents : true, - - /** - * @cfg {String} tooltipType - * The type of tooltip to use. Either 'qtip' (default) for QuickTips or 'title' for title attribute. - */ - tooltipType : 'qtip', - - /** - * @cfg {String} buttonSelector - * (Optional) A {@link Ext.DomQuery DomQuery} selector which is used to extract the active, clickable element from the - * DOM structure created. - * When a custom {@link #template} is used, you must ensure that this selector results in the selection of - * a focussable element. - * Defaults to 'button:first-child'. - */ - buttonSelector : 'button:first-child', - - /** - * @cfg {String} scale - * (Optional) The size of the Button. Three values are allowed: - * - * 'small'Results in the button element being 16px high. - * 'medium'Results in the button element being 24px high. - * 'large'Results in the button element being 32px high. - * - * Defaults to 'small'. - */ - scale : 'small', - - /** - * @cfg {Object} scope The scope (this reference) in which the - * {@link #handler} and {@link #toggleHandler} is - * executed. Defaults to this Button. - */ - - /** - * @cfg {String} iconAlign - * (Optional) The side of the Button box to render the icon. Four values are allowed: - * - * 'top' - * 'right' - * 'bottom' - * 'left' - * - * Defaults to 'left'. - */ - iconAlign : 'left', - - /** - * @cfg {String} arrowAlign - * (Optional) The side of the Button box to render the arrow if the button has an associated {@link #menu}. - * Two values are allowed: - * - * 'right' - * 'bottom' - * - * Defaults to 'right'. - */ - arrowAlign : 'right', - - /** - * @cfg {Ext.Template} template (Optional) - * A {@link Ext.Template Template} used to create the Button's DOM structure. - * Instances, or subclasses which need a different DOM structure may provide a different - * template layout in conjunction with an implementation of {@link #getTemplateArgs}. - * @type Ext.Template - * @property template - */ - /** - * @cfg {String} cls - * A CSS class string to apply to the button's main element. - */ - /** - * @property menu - * @type Menu - * The {@link Ext.menu.Menu Menu} object associated with this Button when configured with the {@link #menu} config option. - */ - - initComponent : function(){ - Ext.Button.superclass.initComponent.call(this); - - this.addEvents( - /** - * @event click - * Fires when this button is clicked - * @param {Button} this - * @param {EventObject} e The click event - */ - 'click', - /** - * @event toggle - * Fires when the 'pressed' state of this button changes (only if enableToggle = true) - * @param {Button} this - * @param {Boolean} pressed - */ - 'toggle', - /** - * @event mouseover - * Fires when the mouse hovers over the button - * @param {Button} this - * @param {Event} e The event object - */ - 'mouseover', - /** - * @event mouseout - * Fires when the mouse exits the button - * @param {Button} this - * @param {Event} e The event object - */ - 'mouseout', - /** - * @event menushow - * If this button has a menu, this event fires when it is shown - * @param {Button} this - * @param {Menu} menu - */ - 'menushow', - /** - * @event menuhide - * If this button has a menu, this event fires when it is hidden - * @param {Button} this - * @param {Menu} menu - */ - 'menuhide', - /** - * @event menutriggerover - * If this button has a menu, this event fires when the mouse enters the menu triggering element - * @param {Button} this - * @param {Menu} menu - * @param {EventObject} e - */ - 'menutriggerover', - /** - * @event menutriggerout - * If this button has a menu, this event fires when the mouse leaves the menu triggering element - * @param {Button} this - * @param {Menu} menu - * @param {EventObject} e - */ - 'menutriggerout' - ); - if(this.menu){ - this.menu = Ext.menu.MenuMgr.get(this.menu); - } - if(Ext.isString(this.toggleGroup)){ - this.enableToggle = true; - } - }, - -/** - * This method returns an Array which provides substitution parameters for the {@link #template Template} used - * to create this Button's DOM structure. - * Instances or subclasses which use a different Template to create a different DOM structure may need to provide their - * own implementation of this method. - * The default implementation which provides data for the default {@link #template} returns an Array containing the - * following items: - * The <button>'s {@link #type} - * A CSS class name applied to the Button's main <tbody> element which determines the button's scale and icon alignment. - * A CSS class to determine the presence and position of an arrow icon. ('x-btn-arrow' or 'x-btn-arrow-bottom' or '') - * The {@link #cls} CSS class name applied to the button's wrapping <table> element. - * The Component id which is applied to the button's wrapping <table> element. - * - * @return {Array} Substitution data for a Template. - */ - getTemplateArgs : function(){ - return [this.type, 'x-btn-' + this.scale + ' x-btn-icon-' + this.scale + '-' + this.iconAlign, this.getMenuClass(), this.cls, this.id]; - }, - - // private - setButtonClass : function(){ - if(this.useSetClass){ - if(!Ext.isEmpty(this.oldCls)){ - this.el.removeClass([this.oldCls, 'x-btn-pressed']); - } - this.oldCls = (this.iconCls || this.icon) ? (this.text ? ' x-btn-text-icon' : ' x-btn-icon') : ' x-btn-noicon'; - this.el.addClass([this.oldCls, this.pressed ? 'x-btn-pressed' : null]); - } - }, - - // protected - getMenuClass : function(){ - return this.menu ? (this.arrowAlign != 'bottom' ? 'x-btn-arrow' : 'x-btn-arrow-bottom') : ''; - }, - - // private - onRender : function(ct, position){ - if(!this.template){ - if(!Ext.Button.buttonTemplate){ - // hideous table template - Ext.Button.buttonTemplate = new Ext.Template( - '', - '', - '', - '', - ' '); - Ext.Button.buttonTemplate.compile(); - } - this.template = Ext.Button.buttonTemplate; - } - - var btn, targs = this.getTemplateArgs(); - - if(position){ - btn = this.template.insertBefore(position, targs, true); - }else{ - btn = this.template.append(ct, targs, true); - } - /** - * An {@link Ext.Element Element} encapsulating the Button's clickable element. By default, - * this references a <button> element. Read only. - * @type Ext.Element - * @property btnEl - */ - this.btnEl = btn.child(this.buttonSelector); - this.mon(this.btnEl, { - scope: this, - focus: this.onFocus, - blur: this.onBlur - }); - - this.initButtonEl(btn, this.btnEl); - - Ext.ButtonToggleMgr.register(this); - }, - - // private - initButtonEl : function(btn, btnEl){ - this.el = btn; - this.setIcon(this.icon); - this.setText(this.text); - this.setIconClass(this.iconCls); - if(Ext.isDefined(this.tabIndex)){ - btnEl.dom.tabIndex = this.tabIndex; - } - if(this.tooltip){ - this.setTooltip(this.tooltip, true); - } - - if(this.handleMouseEvents){ - this.mon(btn, { - scope: this, - mouseover: this.onMouseOver, - mousedown: this.onMouseDown - }); - - // new functionality for monitoring on the document level - //this.mon(btn, 'mouseout', this.onMouseOut, this); - } - - if(this.menu){ - this.mon(this.menu, { - scope: this, - show: this.onMenuShow, - hide: this.onMenuHide - }); - } - - if(this.repeat){ - var repeater = new Ext.util.ClickRepeater(btn, Ext.isObject(this.repeat) ? this.repeat : {}); - this.mon(repeater, 'click', this.onClick, this); - } - this.mon(btn, this.clickEvent, this.onClick, this); - }, - - // private - afterRender : function(){ - Ext.Button.superclass.afterRender.call(this); - this.useSetClass = true; - this.setButtonClass(); - this.doc = Ext.getDoc(); - this.doAutoWidth(); - }, - - /** - * Sets the CSS class that provides a background image to use as the button's icon. This method also changes - * the value of the {@link iconCls} config internally. - * @param {String} cls The CSS class providing the icon image - * @return {Ext.Button} this - */ - setIconClass : function(cls){ - this.iconCls = cls; - if(this.el){ - this.btnEl.dom.className = ''; - this.btnEl.addClass(['x-btn-text', cls || '']); - this.setButtonClass(); - } - return this; - }, - - /** - * Sets the tooltip for this Button. - * @param {String/Object} tooltip. This may be: - * String : A string to be used as innerHTML (html tags are accepted) to show in a tooltip - * Object : A configuration object for {@link Ext.QuickTips#register}. - * - * @return {Ext.Button} this - */ - setTooltip : function(tooltip, /* private */ initial){ - if(this.rendered){ - if(!initial){ - this.clearTip(); - } - if(Ext.isObject(tooltip)){ - Ext.QuickTips.register(Ext.apply({ - target: this.btnEl.id - }, tooltip)); - this.tooltip = tooltip; - }else{ - this.btnEl.dom[this.tooltipType] = tooltip; - } - }else{ - this.tooltip = tooltip; - } - return this; - }, - - // private - clearTip : function(){ - if(Ext.isObject(this.tooltip)){ - Ext.QuickTips.unregister(this.btnEl); - } - }, - - // private - beforeDestroy : function(){ - if(this.rendered){ - this.clearTip(); - } - if(this.menu && this.destroyMenu !== false) { - Ext.destroy(this.menu); - } - Ext.destroy(this.repeater); - }, - - // private - onDestroy : function(){ - if(this.rendered){ - this.doc.un('mouseover', this.monitorMouseOver, this); - this.doc.un('mouseup', this.onMouseUp, this); - delete this.doc; - delete this.btnEl; - Ext.ButtonToggleMgr.unregister(this); - } - Ext.Button.superclass.onDestroy.call(this); - }, - - // private - doAutoWidth : function(){ - if(this.el && this.text && this.width === undefined){ - this.el.setWidth('auto'); - if(Ext.isIE7 && Ext.isStrict){ - var ib = this.btnEl; - if(ib && ib.getWidth() > 20){ - ib.clip(); - ib.setWidth(Ext.util.TextMetrics.measure(ib, this.text).width+ib.getFrameWidth('lr')); - } - } - if(this.minWidth){ - if(this.el.getWidth() < this.minWidth){ - this.el.setWidth(this.minWidth); - } - } - } - }, - - /** - * Assigns this Button's click handler - * @param {Function} handler The function to call when the button is clicked - * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed. - * Defaults to this Button. - * @return {Ext.Button} this - */ - setHandler : function(handler, scope){ - this.handler = handler; - this.scope = scope; - return this; - }, - - /** - * Sets this Button's text - * @param {String} text The button text - * @return {Ext.Button} this - */ - setText : function(text){ - this.text = text; - if(this.el){ - this.btnEl.update(text || ' '); - this.setButtonClass(); - } - this.doAutoWidth(); - return this; - }, - - /** - * Sets the background image (inline style) of the button. This method also changes - * the value of the {@link icon} config internally. - * @param {String} icon The path to an image to display in the button - * @return {Ext.Button} this - */ - setIcon : function(icon){ - this.icon = icon; - if(this.el){ - this.btnEl.setStyle('background-image', icon ? 'url(' + icon + ')' : ''); - this.setButtonClass(); - } - return this; - }, - - /** - * Gets the text for this Button - * @return {String} The button text - */ - getText : function(){ - return this.text; - }, - - /** - * If a state it passed, it becomes the pressed state otherwise the current state is toggled. - * @param {Boolean} state (optional) Force a particular state - * @param {Boolean} supressEvent (optional) True to stop events being fired when calling this method. - * @return {Ext.Button} this - */ - toggle : function(state, suppressEvent){ - state = state === undefined ? !this.pressed : !!state; - if(state != this.pressed){ - if(this.rendered){ - this.el[state ? 'addClass' : 'removeClass']('x-btn-pressed'); - } - this.pressed = state; - if(!suppressEvent){ - this.fireEvent('toggle', this, state); - if(this.toggleHandler){ - this.toggleHandler.call(this.scope || this, this, state); - } - } - } - return this; - }, - - /** - * Focus the button - */ - focus : function(){ - this.btnEl.focus(); - }, - - // private - onDisable : function(){ - this.onDisableChange(true); - }, - - // private - onEnable : function(){ - this.onDisableChange(false); - }, - - onDisableChange : function(disabled){ - if(this.el){ - if(!Ext.isIE6 || !this.text){ - this.el[disabled ? 'addClass' : 'removeClass'](this.disabledClass); - } - this.el.dom.disabled = disabled; - } - this.disabled = disabled; - }, - - /** - * Show this button's menu (if it has one) - */ - showMenu : function(){ - if(this.rendered && this.menu){ - if(this.tooltip){ - Ext.QuickTips.getQuickTip().cancelShow(this.btnEl); - } - if(this.menu.isVisible()){ - this.menu.hide(); - } - this.menu.ownerCt = this; - this.menu.show(this.el, this.menuAlign); - } - return this; - }, - - /** - * Hide this button's menu (if it has one) - */ - hideMenu : function(){ - if(this.hasVisibleMenu()){ - this.menu.hide(); - } - return this; - }, - - /** - * Returns true if the button has a menu and it is visible - * @return {Boolean} - */ - hasVisibleMenu : function(){ - return this.menu && this.menu.ownerCt == this && this.menu.isVisible(); - }, - - // private - onClick : function(e){ - if(e){ - e.preventDefault(); - } - if(e.button !== 0){ - return; - } - if(!this.disabled){ - if(this.enableToggle && (this.allowDepress !== false || !this.pressed)){ - this.toggle(); - } - if(this.menu && !this.hasVisibleMenu() && !this.ignoreNextClick){ - this.showMenu(); - } - this.fireEvent('click', this, e); - if(this.handler){ - //this.el.removeClass('x-btn-over'); - this.handler.call(this.scope || this, this, e); - } - } - }, - - // private - isMenuTriggerOver : function(e, internal){ - return this.menu && !internal; - }, - - // private - isMenuTriggerOut : function(e, internal){ - return this.menu && !internal; - }, - - // private - onMouseOver : function(e){ - if(!this.disabled){ - var internal = e.within(this.el, true); - if(!internal){ - this.el.addClass('x-btn-over'); - if(!this.monitoringMouseOver){ - this.doc.on('mouseover', this.monitorMouseOver, this); - this.monitoringMouseOver = true; - } - this.fireEvent('mouseover', this, e); - } - if(this.isMenuTriggerOver(e, internal)){ - this.fireEvent('menutriggerover', this, this.menu, e); - } - } - }, - - // private - monitorMouseOver : function(e){ - if(e.target != this.el.dom && !e.within(this.el)){ - if(this.monitoringMouseOver){ - this.doc.un('mouseover', this.monitorMouseOver, this); - this.monitoringMouseOver = false; - } - this.onMouseOut(e); - } - }, - - // private - onMouseOut : function(e){ - var internal = e.within(this.el) && e.target != this.el.dom; - this.el.removeClass('x-btn-over'); - this.fireEvent('mouseout', this, e); - if(this.isMenuTriggerOut(e, internal)){ - this.fireEvent('menutriggerout', this, this.menu, e); - } - }, - - focus : function() { - this.btnEl.focus(); - }, - - blur : function() { - this.btnEl.blur(); - }, - - // private - onFocus : function(e){ - if(!this.disabled){ - this.el.addClass('x-btn-focus'); - } - }, - // private - onBlur : function(e){ - this.el.removeClass('x-btn-focus'); - }, - - // private - getClickEl : function(e, isUp){ - return this.el; - }, - - // private - onMouseDown : function(e){ - if(!this.disabled && e.button === 0){ - this.getClickEl(e).addClass('x-btn-click'); - this.doc.on('mouseup', this.onMouseUp, this); - } - }, - // private - onMouseUp : function(e){ - if(e.button === 0){ - this.getClickEl(e, true).removeClass('x-btn-click'); - this.doc.un('mouseup', this.onMouseUp, this); - } - }, - // private - onMenuShow : function(e){ - if(this.menu.ownerCt == this){ - this.menu.ownerCt = this; - this.ignoreNextClick = 0; - this.el.addClass('x-btn-menu-active'); - this.fireEvent('menushow', this, this.menu); - } - }, - // private - onMenuHide : function(e){ - if(this.menu.ownerCt == this){ - this.el.removeClass('x-btn-menu-active'); - this.ignoreNextClick = this.restoreClick.defer(250, this); - this.fireEvent('menuhide', this, this.menu); - delete this.menu.ownerCt; - } - }, - - // private - restoreClick : function(){ - this.ignoreNextClick = 0; - } - - /** - * @cfg {String} autoEl @hide - */ - /** - * @cfg {String/Object} html @hide - */ - /** - * @cfg {String} contentEl @hide - */ - /** - * @cfg {Mixed} data @hide - */ - /** - * @cfg {Mixed} tpl @hide - */ - /** - * @cfg {String} tplWriteMode @hide - */ -}); -Ext.reg('button', Ext.Button); - -// Private utility class used by Button -Ext.ButtonToggleMgr = function(){ - var groups = {}; - - function toggleGroup(btn, state){ - if(state){ - var g = groups[btn.toggleGroup]; - for(var i = 0, l = g.length; i < l; i++){ - if(g[i] != btn){ - g[i].toggle(false); - } - } - } - } - - return { - register : function(btn){ - if(!btn.toggleGroup){ - return; - } - var g = groups[btn.toggleGroup]; - if(!g){ - g = groups[btn.toggleGroup] = []; - } - g.push(btn); - btn.on('toggle', toggleGroup); - }, - - unregister : function(btn){ - if(!btn.toggleGroup){ - return; - } - var g = groups[btn.toggleGroup]; - if(g){ - g.remove(btn); - btn.un('toggle', toggleGroup); - } - }, - - /** - * Gets the pressed button in the passed group or null - * @param {String} group - * @return Button - */ - getPressed : function(group){ - var g = groups[group]; - if(g){ - for(var i = 0, len = g.length; i < len; i++){ - if(g[i].pressed === true){ - return g[i]; - } - } - } - return null; - } - }; -}(); -/** - * @class Ext.SplitButton - * @extends Ext.Button - * A split button that provides a built-in dropdown arrow that can fire an event separately from the default - * click event of the button. Typically this would be used to display a dropdown menu that provides additional - * options to the primary button action, but any custom handler can provide the arrowclick implementation. Example usage: - * -// display a dropdown menu: -new Ext.SplitButton({ - renderTo: 'button-ct', // the container id - text: 'Options', - handler: optionsHandler, // handle a click on the button itself - menu: new Ext.menu.Menu({ - items: [ - // these items will render as dropdown menu items when the arrow is clicked: - {text: 'Item 1', handler: item1Handler}, - {text: 'Item 2', handler: item2Handler} - ] - }) -}); - -// Instead of showing a menu, you provide any type of custom -// functionality you want when the dropdown arrow is clicked: -new Ext.SplitButton({ - renderTo: 'button-ct', - text: 'Options', - handler: optionsHandler, - arrowHandler: myCustomHandler -}); - - * @cfg {Function} arrowHandler A function called when the arrow button is clicked (can be used instead of click event) - * @cfg {String} arrowTooltip The title attribute of the arrow - * @constructor - * Create a new menu button - * @param {Object} config The config object - * @xtype splitbutton - */ -Ext.SplitButton = Ext.extend(Ext.Button, { - // private - arrowSelector : 'em', - split: true, - - // private - initComponent : function(){ - Ext.SplitButton.superclass.initComponent.call(this); - /** - * @event arrowclick - * Fires when this button's arrow is clicked - * @param {MenuButton} this - * @param {EventObject} e The click event - */ - this.addEvents("arrowclick"); - }, - - // private - onRender : function(){ - Ext.SplitButton.superclass.onRender.apply(this, arguments); - if(this.arrowTooltip){ - this.el.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip; - } - }, - - /** - * Sets this button's arrow click handler. - * @param {Function} handler The function to call when the arrow is clicked - * @param {Object} scope (optional) Scope for the function passed above - */ - setArrowHandler : function(handler, scope){ - this.arrowHandler = handler; - this.scope = scope; - }, - - getMenuClass : function(){ - return 'x-btn-split' + (this.arrowAlign == 'bottom' ? '-bottom' : ''); - }, - - isClickOnArrow : function(e){ - if (this.arrowAlign != 'bottom') { - var visBtn = this.el.child('em.x-btn-split'); - var right = visBtn.getRegion().right - visBtn.getPadding('r'); - return e.getPageX() > right; - } else { - return e.getPageY() > this.btnEl.getRegion().bottom; - } - }, - - // private - onClick : function(e, t){ - e.preventDefault(); - if(!this.disabled){ - if(this.isClickOnArrow(e)){ - if(this.menu && !this.menu.isVisible() && !this.ignoreNextClick){ - this.showMenu(); - } - this.fireEvent("arrowclick", this, e); - if(this.arrowHandler){ - this.arrowHandler.call(this.scope || this, this, e); - } - }else{ - if(this.enableToggle){ - this.toggle(); - } - this.fireEvent("click", this, e); - if(this.handler){ - this.handler.call(this.scope || this, this, e); - } - } - } - }, - - // private - isMenuTriggerOver : function(e){ - return this.menu && e.target.tagName == this.arrowSelector; - }, - - // private - isMenuTriggerOut : function(e, internal){ - return this.menu && e.target.tagName != this.arrowSelector; - } -}); - -Ext.reg('splitbutton', Ext.SplitButton);/** - * @class Ext.CycleButton - * @extends Ext.SplitButton - * A specialized SplitButton that contains a menu of {@link Ext.menu.CheckItem} elements. The button automatically - * cycles through each menu item on click, raising the button's {@link #change} event (or calling the button's - * {@link #changeHandler} function, if supplied) for the active menu item. Clicking on the arrow section of the - * button displays the dropdown menu just like a normal SplitButton. Example usage: - * -var btn = new Ext.CycleButton({ - showText: true, - prependText: 'View as ', - items: [{ - text:'text only', - iconCls:'view-text', - checked:true - },{ - text:'HTML', - iconCls:'view-html' - }], - changeHandler:function(btn, item){ - Ext.Msg.alert('Change View', item.text); - } -}); - - * @constructor - * Create a new split button - * @param {Object} config The config object - * @xtype cycle - */ -Ext.CycleButton = Ext.extend(Ext.SplitButton, { - /** - * @cfg {Array} items An array of {@link Ext.menu.CheckItem} config objects to be used when creating the - * button's menu items (e.g., {text:'Foo', iconCls:'foo-icon'}) - */ - /** - * @cfg {Boolean} showText True to display the active item's text as the button text (defaults to false) - */ - /** - * @cfg {String} prependText A static string to prepend before the active item's text when displayed as the - * button's text (only applies when showText = true, defaults to '') - */ - /** - * @cfg {Function} changeHandler A callback function that will be invoked each time the active menu - * item in the button's menu has changed. If this callback is not supplied, the SplitButton will instead - * fire the {@link #change} event on active item change. The changeHandler function will be called with the - * following argument list: (SplitButton this, Ext.menu.CheckItem item) - */ - /** - * @cfg {String} forceIcon A css class which sets an image to be used as the static icon for this button. This - * icon will always be displayed regardless of which item is selected in the dropdown list. This overrides the - * default behavior of changing the button's icon to match the selected item's icon on change. - */ - /** - * @property menu - * @type Menu - * The {@link Ext.menu.Menu Menu} object used to display the {@link Ext.menu.CheckItem CheckItems} representing the available choices. - */ - - // private - getItemText : function(item){ - if(item && this.showText === true){ - var text = ''; - if(this.prependText){ - text += this.prependText; - } - text += item.text; - return text; - } - return undefined; - }, - - /** - * Sets the button's active menu item. - * @param {Ext.menu.CheckItem} item The item to activate - * @param {Boolean} suppressEvent True to prevent the button's change event from firing (defaults to false) - */ - setActiveItem : function(item, suppressEvent){ - if(!Ext.isObject(item)){ - item = this.menu.getComponent(item); - } - if(item){ - if(!this.rendered){ - this.text = this.getItemText(item); - this.iconCls = item.iconCls; - }else{ - var t = this.getItemText(item); - if(t){ - this.setText(t); - } - this.setIconClass(item.iconCls); - } - this.activeItem = item; - if(!item.checked){ - item.setChecked(true, false); - } - if(this.forceIcon){ - this.setIconClass(this.forceIcon); - } - if(!suppressEvent){ - this.fireEvent('change', this, item); - } - } - }, - - /** - * Gets the currently active menu item. - * @return {Ext.menu.CheckItem} The active item - */ - getActiveItem : function(){ - return this.activeItem; - }, - - // private - initComponent : function(){ - this.addEvents( - /** - * @event change - * Fires after the button's active menu item has changed. Note that if a {@link #changeHandler} function - * is set on this CycleButton, it will be called instead on active item change and this change event will - * not be fired. - * @param {Ext.CycleButton} this - * @param {Ext.menu.CheckItem} item The menu item that was selected - */ - "change" - ); - - if(this.changeHandler){ - this.on('change', this.changeHandler, this.scope||this); - delete this.changeHandler; - } - - this.itemCount = this.items.length; - - this.menu = {cls:'x-cycle-menu', items:[]}; - var checked = 0; - Ext.each(this.items, function(item, i){ - Ext.apply(item, { - group: item.group || this.id, - itemIndex: i, - checkHandler: this.checkHandler, - scope: this, - checked: item.checked || false - }); - this.menu.items.push(item); - if(item.checked){ - checked = i; - } - }, this); - Ext.CycleButton.superclass.initComponent.call(this); - this.on('click', this.toggleSelected, this); - this.setActiveItem(checked, true); - }, - - // private - checkHandler : function(item, pressed){ - if(pressed){ - this.setActiveItem(item); - } - }, - - /** - * This is normally called internally on button click, but can be called externally to advance the button's - * active item programmatically to the next one in the menu. If the current item is the last one in the menu - * the active item will be set to the first item in the menu. - */ - toggleSelected : function(){ - var m = this.menu; - m.render(); - // layout if we haven't before so the items are active - if(!m.hasLayout){ - m.doLayout(); - } - - var nextIdx, checkItem; - for (var i = 1; i < this.itemCount; i++) { - nextIdx = (this.activeItem.itemIndex + i) % this.itemCount; - // check the potential item - checkItem = m.items.itemAt(nextIdx); - // if its not disabled then check it. - if (!checkItem.disabled) { - checkItem.setChecked(true); - break; - } - } - } -}); -Ext.reg('cycle', Ext.CycleButton);/** - * @class Ext.Toolbar - * @extends Ext.Container - * Basic Toolbar class. Although the {@link Ext.Container#defaultType defaultType} for Toolbar - * is {@link Ext.Button button}, Toolbar elements (child items for the Toolbar container) may - * be virtually any type of Component. Toolbar elements can be created explicitly via their constructors, - * or implicitly via their xtypes, and can be {@link #add}ed dynamically. - * Some items have shortcut strings for creation: - * -Shortcut xtype Class Description -'->' 'tbfill' {@link Ext.Toolbar.Fill} begin using the right-justified button container -'-' 'tbseparator' {@link Ext.Toolbar.Separator} add a vertical separator bar between toolbar items -' ' 'tbspacer' {@link Ext.Toolbar.Spacer} add horiztonal space between elements - * - * - * Example usage of various elements: - * -var tb = new Ext.Toolbar({ - renderTo: document.body, - width: 600, - height: 100, - items: [ - { - // xtype: 'button', // default for Toolbars, same as 'tbbutton' - text: 'Button' - }, - { - xtype: 'splitbutton', // same as 'tbsplitbutton' - text: 'Split Button' - }, - // begin using the right-justified button container - '->', // same as {xtype: 'tbfill'}, // Ext.Toolbar.Fill - { - xtype: 'textfield', - name: 'field1', - emptyText: 'enter search term' - }, - // add a vertical separator bar between toolbar items - '-', // same as {xtype: 'tbseparator'} to create Ext.Toolbar.Separator - 'text 1', // same as {xtype: 'tbtext', text: 'text1'} to create Ext.Toolbar.TextItem - {xtype: 'tbspacer'},// same as ' ' to create Ext.Toolbar.Spacer - 'text 2', - {xtype: 'tbspacer', width: 50}, // add a 50px space - 'text 3' - ] +Ext.chart.LineChart = Ext.extend(Ext.chart.CartesianChart, { + type: 'line' }); - * - * Example adding a ComboBox within a menu of a button: - * -// ComboBox creation -var combo = new Ext.form.ComboBox({ - store: new Ext.data.ArrayStore({ - autoDestroy: true, - fields: ['initials', 'fullname'], - data : [ - ['FF', 'Fred Flintstone'], - ['BR', 'Barney Rubble'] - ] - }), - displayField: 'fullname', - typeAhead: true, - mode: 'local', - forceSelection: true, - triggerAction: 'all', - emptyText: 'Select a name...', - selectOnFocus: true, - width: 135, - getListParent: function() { - return this.el.up('.x-menu'); - }, - iconCls: 'no-icon' //use iconCls if placing within menu to shift to right side of menu +Ext.reg('linechart', Ext.chart.LineChart); + +/** + * @class Ext.chart.ColumnChart + * @extends Ext.chart.CartesianChart + * @constructor + * @xtype columnchart + */ +Ext.chart.ColumnChart = Ext.extend(Ext.chart.CartesianChart, { + type: 'column' }); +Ext.reg('columnchart', Ext.chart.ColumnChart); -// put ComboBox in a Menu -var menu = new Ext.menu.Menu({ - id: 'mainMenu', - items: [ - combo // A Field in a Menu - ] +/** + * @class Ext.chart.StackedColumnChart + * @extends Ext.chart.CartesianChart + * @constructor + * @xtype stackedcolumnchart + */ +Ext.chart.StackedColumnChart = Ext.extend(Ext.chart.CartesianChart, { + type: 'stackcolumn' }); +Ext.reg('stackedcolumnchart', Ext.chart.StackedColumnChart); -// add a Button with the menu -tb.add({ - text:'Button w/ Menu', - menu: menu // assign menu by instance - }); -tb.doLayout(); - * +/** + * @class Ext.chart.BarChart + * @extends Ext.chart.CartesianChart * @constructor - * Creates a new Toolbar - * @param {Object/Array} config A config object or an array of buttons to {@link #add} - * @xtype toolbar + * @xtype barchart */ -Ext.Toolbar = function(config){ - if(Ext.isArray(config)){ - config = {items: config, layout: 'toolbar'}; - } else { - config = Ext.apply({ - layout: 'toolbar' - }, config); - if(config.buttons) { - config.items = config.buttons; - } - } - Ext.Toolbar.superclass.constructor.call(this, config); -}; +Ext.chart.BarChart = Ext.extend(Ext.chart.CartesianChart, { + type: 'bar' +}); +Ext.reg('barchart', Ext.chart.BarChart); -(function(){ +/** + * @class Ext.chart.StackedBarChart + * @extends Ext.chart.CartesianChart + * @constructor + * @xtype stackedbarchart + */ +Ext.chart.StackedBarChart = Ext.extend(Ext.chart.CartesianChart, { + type: 'stackbar' +}); +Ext.reg('stackedbarchart', Ext.chart.StackedBarChart); -var T = Ext.Toolbar; -Ext.extend(T, Ext.Container, { - defaultType: 'button', +/** + * @class Ext.chart.Axis + * Defines a CartesianChart's vertical or horizontal axis. + * @constructor + */ +Ext.chart.Axis = function(config){ + Ext.apply(this, config); +}; +Ext.chart.Axis.prototype = +{ /** - * @cfg {String/Object} layout - * This class assigns a default layout (layout:'toolbar'). - * Developers may override this configuration option if another layout - * is required (the constructor must be passed a configuration object in this - * case instead of an array). - * See {@link Ext.Container#layout} for additional information. + * The type of axis. + * + * @property type + * @type String */ - - enableOverflow : false, + type: null, /** - * @cfg {Boolean} enableOverflow - * Defaults to false. Configure true to make the toolbar provide a button - * which activates a dropdown Menu to show items which overflow the Toolbar's width. + * The direction in which the axis is drawn. May be "horizontal" or "vertical". + * + * @property orientation + * @type String */ + orientation: "horizontal", + /** - * @cfg {String} buttonAlign - * The default position at which to align child items. Defaults to "left" - * May be specified as "center" to cause items added before a Fill (A "->") item - * to be centered in the Toolbar. Items added after a Fill are still right-aligned. - * Specify as "right" to right align all child items. + * If true, the items on the axis will be drawn in opposite direction. + * + * @property reverse + * @type Boolean */ + reverse: false, - trackMenus : true, - internalDefaults: {removeMode: 'container', hideParent: true}, - toolbarCls: 'x-toolbar', - - initComponent : function(){ - T.superclass.initComponent.call(this); - - /** - * @event overflowchange - * Fires after the overflow state has changed. - * @param {Object} c The Container - * @param {Boolean} lastOverflow overflow state - */ - this.addEvents('overflowchange'); - }, - - // private - onRender : function(ct, position){ - if(!this.el){ - if(!this.autoCreate){ - this.autoCreate = { - cls: this.toolbarCls + ' x-small-editor' - }; - } - this.el = ct.createChild(Ext.apply({ id: this.id },this.autoCreate), position); - Ext.Toolbar.superclass.onRender.apply(this, arguments); - } - }, + /** + * A string reference to the globally-accessible function that may be called to + * determine each of the label values for this axis. + * + * @property labelFunction + * @type String + */ + labelFunction: null, /** - * Adds element(s) to the toolbar -- this function takes a variable number of - * arguments of mixed type and adds them to the toolbar. - * Note: See the notes within {@link Ext.Container#add}. - * @param {Mixed} arg1 The following types of arguments are all valid: - * - * {@link Ext.Button} config: A valid button config object (equivalent to {@link #addButton}) - * HtmlElement: Any standard HTML element (equivalent to {@link #addElement}) - * Field: Any form field (equivalent to {@link #addField}) - * Item: Any subclass of {@link Ext.Toolbar.Item} (equivalent to {@link #addItem}) - * String: Any generic string (gets wrapped in a {@link Ext.Toolbar.TextItem}, equivalent to {@link #addText}). - * Note that there are a few special strings that are treated differently as explained next. - * '-': Creates a separator element (equivalent to {@link #addSeparator}) - * ' ': Creates a spacer element (equivalent to {@link #addSpacer}) - * '->': Creates a fill element (equivalent to {@link #addFill}) - * - * @param {Mixed} arg2 - * @param {Mixed} etc. - * @method add + * If true, labels that overlap previously drawn labels on the axis will be hidden. + * + * @property hideOverlappingLabels + * @type Boolean */ + hideOverlappingLabels: true, - // private - lookupComponent : function(c){ - if(Ext.isString(c)){ - if(c == '-'){ - c = new T.Separator(); - }else if(c == ' '){ - c = new T.Spacer(); - }else if(c == '->'){ - c = new T.Fill(); - }else{ - c = new T.TextItem(c); - } - this.applyDefaults(c); - }else{ - if(c.isFormField || c.render){ // some kind of form field, some kind of Toolbar.Item - c = this.createComponent(c); - }else if(c.tag){ // DomHelper spec - c = new T.Item({autoEl: c}); - }else if(c.tagName){ // element - c = new T.Item({el:c}); - }else if(Ext.isObject(c)){ // must be button config? - c = c.xtype ? this.createComponent(c) : this.constructButton(c); - } - } - return c; - }, + /** + * The space, in pixels, between labels on an axis. + * + * @property labelSpacing + * @type Number + */ + labelSpacing: 2 +}; - // private - applyDefaults : function(c){ - if(!Ext.isString(c)){ - c = Ext.Toolbar.superclass.applyDefaults.call(this, c); - var d = this.internalDefaults; - if(c.events){ - Ext.applyIf(c.initialConfig, d); - Ext.apply(c, d); - }else{ - Ext.applyIf(c, d); - } - } - return c; - }, +/** + * @class Ext.chart.NumericAxis + * @extends Ext.chart.Axis + * A type of axis whose units are measured in numeric values. + * @constructor + */ +Ext.chart.NumericAxis = Ext.extend(Ext.chart.Axis, { + type: "numeric", /** - * Adds a separator - * Note: See the notes within {@link Ext.Container#add}. - * @return {Ext.Toolbar.Item} The separator {@link Ext.Toolbar.Item item} + * The minimum value drawn by the axis. If not set explicitly, the axis + * minimum will be calculated automatically. + * + * @property minimum + * @type Number */ - addSeparator : function(){ - return this.add(new T.Separator()); - }, + minimum: NaN, /** - * Adds a spacer element - * Note: See the notes within {@link Ext.Container#add}. - * @return {Ext.Toolbar.Spacer} The spacer item + * The maximum value drawn by the axis. If not set explicitly, the axis + * maximum will be calculated automatically. + * + * @property maximum + * @type Number */ - addSpacer : function(){ - return this.add(new T.Spacer()); - }, + maximum: NaN, /** - * Forces subsequent additions into the float:right toolbar - * Note: See the notes within {@link Ext.Container#add}. + * The spacing between major intervals on this axis. + * + * @property majorUnit + * @type Number */ - addFill : function(){ - this.add(new T.Fill()); - }, + majorUnit: NaN, /** - * Adds any standard HTML element to the toolbar - * Note: See the notes within {@link Ext.Container#add}. - * @param {Mixed} el The element or id of the element to add - * @return {Ext.Toolbar.Item} The element's item + * The spacing between minor intervals on this axis. + * + * @property minorUnit + * @type Number */ - addElement : function(el){ - return this.addItem(new T.Item({el:el})); - }, + minorUnit: NaN, /** - * Adds any Toolbar.Item or subclass - * Note: See the notes within {@link Ext.Container#add}. - * @param {Ext.Toolbar.Item} item - * @return {Ext.Toolbar.Item} The item + * If true, the labels, ticks, gridlines, and other objects will snap to the + * nearest major or minor unit. If false, their position will be based on + * the minimum value. + * + * @property snapToUnits + * @type Boolean */ - addItem : function(item){ - return this.add.apply(this, arguments); - }, + snapToUnits: true, /** - * Adds a button (or buttons). See {@link Ext.Button} for more info on the config. - * Note: See the notes within {@link Ext.Container#add}. - * @param {Object/Array} config A button config or array of configs - * @return {Ext.Button/Array} + * If true, and the bounds are calculated automatically, either the minimum + * or maximum will be set to zero. + * + * @property alwaysShowZero + * @type Boolean */ - addButton : function(config){ - if(Ext.isArray(config)){ - var buttons = []; - for(var i = 0, len = config.length; i < len; i++) { - buttons.push(this.addButton(config[i])); - } - return buttons; - } - return this.add(this.constructButton(config)); - }, + alwaysShowZero: true, /** - * Adds text to the toolbar - * Note: See the notes within {@link Ext.Container#add}. - * @param {String} text The text to add - * @return {Ext.Toolbar.Item} The element's item + * The scaling algorithm to use on this axis. May be "linear" or + * "logarithmic". + * + * @property scale + * @type String */ - addText : function(text){ - return this.addItem(new T.TextItem(text)); - }, + scale: "linear", /** - * Adds a new element to the toolbar from the passed {@link Ext.DomHelper} config - * Note: See the notes within {@link Ext.Container#add}. - * @param {Object} config - * @return {Ext.Toolbar.Item} The element's item + * Indicates whether to round the major unit. + * + * @property roundMajorUnit + * @type Boolean */ - addDom : function(config){ - return this.add(new T.Item({autoEl: config})); - }, + roundMajorUnit: true, /** - * Adds a dynamically rendered Ext.form field (TextField, ComboBox, etc). Note: the field should not have - * been rendered yet. For a field that has already been rendered, use {@link #addElement}. - * Note: See the notes within {@link Ext.Container#add}. - * @param {Ext.form.Field} field - * @return {Ext.Toolbar.Item} + * Indicates whether to factor in the size of the labels when calculating a + * major unit. + * + * @property calculateByLabelSize + * @type Boolean */ - addField : function(field){ - return this.add(field); - }, + calculateByLabelSize: true, /** - * Inserts any {@link Ext.Toolbar.Item}/{@link Ext.Button} at the specified index. - * Note: See the notes within {@link Ext.Container#add}. - * @param {Number} index The index where the item is to be inserted - * @param {Object/Ext.Toolbar.Item/Ext.Button/Array} item The button, or button config object to be - * inserted, or an array of buttons/configs. - * @return {Ext.Button/Item} + * Indicates the position of the axis relative to the chart + * + * @property position + * @type String */ - insertButton : function(index, item){ - if(Ext.isArray(item)){ - var buttons = []; - for(var i = 0, len = item.length; i < len; i++) { - buttons.push(this.insertButton(index + i, item[i])); - } - return buttons; - } - return Ext.Toolbar.superclass.insert.call(this, index, item); - }, + position: 'left', - // private - trackMenu : function(item, remove){ - if(this.trackMenus && item.menu){ - var method = remove ? 'mun' : 'mon'; - this[method](item, 'menutriggerover', this.onButtonTriggerOver, this); - this[method](item, 'menushow', this.onButtonMenuShow, this); - this[method](item, 'menuhide', this.onButtonMenuHide, this); - } - }, + /** + * Indicates whether to extend maximum beyond data's maximum to the nearest + * majorUnit. + * + * @property adjustMaximumByMajorUnit + * @type Boolean + */ + adjustMaximumByMajorUnit: true, - // private - constructButton : function(item){ - var b = item.events ? item : this.createComponent(item, item.split ? 'splitbutton' : this.defaultType); - return b; - }, + /** + * Indicates whether to extend the minimum beyond data's minimum to the + * nearest majorUnit. + * + * @property adjustMinimumByMajorUnit + * @type Boolean + */ + adjustMinimumByMajorUnit: true - // private - onAdd : function(c){ - Ext.Toolbar.superclass.onAdd.call(this); - this.trackMenu(c); - if(this.disabled){ - c.disable(); - } - }, +}); - // private - onRemove : function(c){ - Ext.Toolbar.superclass.onRemove.call(this); - this.trackMenu(c, true); - }, +/** + * @class Ext.chart.TimeAxis + * @extends Ext.chart.Axis + * A type of axis whose units are measured in time-based values. + * @constructor + */ +Ext.chart.TimeAxis = Ext.extend(Ext.chart.Axis, { + type: "time", - // private - onDisable : function(){ - this.items.each(function(item){ - if(item.disable){ - item.disable(); - } - }); - }, + /** + * The minimum value drawn by the axis. If not set explicitly, the axis + * minimum will be calculated automatically. + * + * @property minimum + * @type Date + */ + minimum: null, - // private - onEnable : function(){ - this.items.each(function(item){ - if(item.enable){ - item.enable(); - } - }); - }, + /** + * The maximum value drawn by the axis. If not set explicitly, the axis + * maximum will be calculated automatically. + * + * @property maximum + * @type Number + */ + maximum: null, - // private - onButtonTriggerOver : function(btn){ - if(this.activeMenuBtn && this.activeMenuBtn != btn){ - this.activeMenuBtn.hideMenu(); - btn.showMenu(); - this.activeMenuBtn = btn; - } - }, + /** + * The spacing between major intervals on this axis. + * + * @property majorUnit + * @type Number + */ + majorUnit: NaN, - // private - onButtonMenuShow : function(btn){ - this.activeMenuBtn = btn; - }, + /** + * The time unit used by the majorUnit. + * + * @property majorTimeUnit + * @type String + */ + majorTimeUnit: null, - // private - onButtonMenuHide : function(btn){ - delete this.activeMenuBtn; - } -}); -Ext.reg('toolbar', Ext.Toolbar); + /** + * The spacing between minor intervals on this axis. + * + * @property majorUnit + * @type Number + */ + minorUnit: NaN, -/** - * @class Ext.Toolbar.Item - * @extends Ext.BoxComponent - * The base class that other non-interacting Toolbar Item classes should extend in order to - * get some basic common toolbar item functionality. - * @constructor - * Creates a new Item - * @param {HTMLElement} el - * @xtype tbitem - */ -T.Item = Ext.extend(Ext.BoxComponent, { - hideParent: true, // Hiding a Toolbar.Item hides its containing TD - enable:Ext.emptyFn, - disable:Ext.emptyFn, - focus:Ext.emptyFn /** - * @cfg {String} overflowText Text to be used for the menu if the item is overflowed. + * The time unit used by the minorUnit. + * + * @property majorTimeUnit + * @type String */ -}); -Ext.reg('tbitem', T.Item); + minorTimeUnit: null, + + /** + * If true, the labels, ticks, gridlines, and other objects will snap to the + * nearest major or minor unit. If false, their position will be based on + * the minimum value. + * + * @property snapToUnits + * @type Boolean + */ + snapToUnits: true, + + /** + * Series that are stackable will only stack when this value is set to true. + * + * @property stackingEnabled + * @type Boolean + */ + stackingEnabled: false, + + /** + * Indicates whether to factor in the size of the labels when calculating a + * major unit. + * + * @property calculateByLabelSize + * @type Boolean + */ + calculateByLabelSize: true -/** - * @class Ext.Toolbar.Separator - * @extends Ext.Toolbar.Item - * A simple class that adds a vertical separator bar between toolbar items - * (css class:'xtb-sep'). Example usage: - * -new Ext.Panel({ - tbar : [ - 'Item 1', - {xtype: 'tbseparator'}, // or '-' - 'Item 2' - ] -}); - - * @constructor - * Creates a new Separator - * @xtype tbseparator - */ -T.Separator = Ext.extend(T.Item, { - onRender : function(ct, position){ - this.el = ct.createChild({tag:'span', cls:'xtb-sep'}, position); - } }); -Ext.reg('tbseparator', T.Separator); /** - * @class Ext.Toolbar.Spacer - * @extends Ext.Toolbar.Item - * A simple element that adds extra horizontal space between items in a toolbar. - * By default a 2px wide space is added via css specification: -.x-toolbar .xtb-spacer { - width:2px; -} - * - * Example usage: - * -new Ext.Panel({ - tbar : [ - 'Item 1', - {xtype: 'tbspacer'}, // or ' ' - 'Item 2', - // space width is also configurable via javascript - {xtype: 'tbspacer', width: 50}, // add a 50px space - 'Item 3' - ] -}); - + * @class Ext.chart.CategoryAxis + * @extends Ext.chart.Axis + * A type of axis that displays items in categories. * @constructor - * Creates a new Spacer - * @xtype tbspacer */ -T.Spacer = Ext.extend(T.Item, { +Ext.chart.CategoryAxis = Ext.extend(Ext.chart.Axis, { + type: "category", + /** - * @cfg {Number} width - * The width of the spacer in pixels (defaults to 2px via css style .x-toolbar .xtb-spacer). + * A list of category names to display along this axis. + * + * @property categoryNames + * @type Array */ + categoryNames: null, + + /** + * Indicates whether or not to calculate the number of categories (ticks and + * labels) when there is not enough room to display all labels on the axis. + * If set to true, the axis will determine the number of categories to plot. + * If not, all categories will be plotted. + * + * @property calculateCategoryCount + * @type Boolean + */ + calculateCategoryCount: false - onRender : function(ct, position){ - this.el = ct.createChild({tag:'div', cls:'xtb-spacer', style: this.width?'width:'+this.width+'px':''}, position); - } }); -Ext.reg('tbspacer', T.Spacer); /** - * @class Ext.Toolbar.Fill - * @extends Ext.Toolbar.Spacer - * A non-rendering placeholder item which instructs the Toolbar's Layout to begin using - * the right-justified button container. - * -new Ext.Panel({ - tbar : [ - 'Item 1', - {xtype: 'tbfill'}, // or '->' - 'Item 2' - ] -}); - + * @class Ext.chart.Series + * Series class for the charts widget. * @constructor - * Creates a new Fill - * @xtype tbfill */ -T.Fill = Ext.extend(T.Item, { - // private - render : Ext.emptyFn, - isFill : true -}); -Ext.reg('tbfill', T.Fill); +Ext.chart.Series = function(config) { Ext.apply(this, config); }; + +Ext.chart.Series.prototype = +{ + /** + * The type of series. + * + * @property type + * @type String + */ + type: null, + + /** + * The human-readable name of the series. + * + * @property displayName + * @type String + */ + displayName: null +}; /** - * @class Ext.Toolbar.TextItem - * @extends Ext.Toolbar.Item - * A simple class that renders text directly into a toolbar - * (with css class:'xtb-text'). Example usage: - * -new Ext.Panel({ - tbar : [ - {xtype: 'tbtext', text: 'Item 1'} // or simply 'Item 1' - ] -}); - + * @class Ext.chart.CartesianSeries + * @extends Ext.chart.Series + * CartesianSeries class for the charts widget. * @constructor - * Creates a new TextItem - * @param {String/Object} text A text string, or a config object containing a text property - * @xtype tbtext */ -T.TextItem = Ext.extend(T.Item, { +Ext.chart.CartesianSeries = Ext.extend(Ext.chart.Series, { /** - * @cfg {String} text The text to be used as innerHTML (html tags are accepted) + * The field used to access the x-axis value from the items from the data + * source. + * + * @property xField + * @type String */ + xField: null, - constructor: function(config){ - T.TextItem.superclass.constructor.call(this, Ext.isString(config) ? {text: config} : config); - }, + /** + * The field used to access the y-axis value from the items from the data + * source. + * + * @property yField + * @type String + */ + yField: null, - // private - onRender : function(ct, position) { - this.autoEl = {cls: 'xtb-text', html: this.text || ''}; - T.TextItem.superclass.onRender.call(this, ct, position); - }, + /** + * False to not show this series in the legend. Defaults to true. + * + * @property showInLegend + * @type Boolean + */ + showInLegend: true, /** - * Updates this item's text, setting the text to be used as innerHTML. - * @param {String} t The text to display (html accepted). + * Indicates which axis the series will bind to + * + * @property axis + * @type String */ - setText : function(t) { - if(this.rendered){ - this.el.update(t); - }else{ - this.text = t; - } - } + axis: 'primary' }); -Ext.reg('tbtext', T.TextItem); -// backwards compat -T.Button = Ext.extend(Ext.Button, {}); -T.SplitButton = Ext.extend(Ext.SplitButton, {}); -Ext.reg('tbbutton', T.Button); -Ext.reg('tbsplit', T.SplitButton); +/** + * @class Ext.chart.ColumnSeries + * @extends Ext.chart.CartesianSeries + * ColumnSeries class for the charts widget. + * @constructor + */ +Ext.chart.ColumnSeries = Ext.extend(Ext.chart.CartesianSeries, { + type: "column" +}); -})(); -/** - * @class Ext.ButtonGroup - * @extends Ext.Panel - * Container for a group of buttons. Example usage: - * -var p = new Ext.Panel({ - title: 'Panel with Button Group', - width: 300, - height:200, - renderTo: document.body, - html: 'whatever', - tbar: [{ - xtype: 'buttongroup', - {@link #columns}: 3, - title: 'Clipboard', - items: [{ - text: 'Paste', - scale: 'large', - rowspan: 3, iconCls: 'add', - iconAlign: 'top', - cls: 'x-btn-as-arrow' - },{ - xtype:'splitbutton', - text: 'Menu Button', - scale: 'large', - rowspan: 3, - iconCls: 'add', - iconAlign: 'top', - arrowAlign:'bottom', - menu: [{text: 'Menu Item 1'}] - },{ - xtype:'splitbutton', text: 'Cut', iconCls: 'add16', menu: [{text: 'Cut Menu Item'}] - },{ - text: 'Copy', iconCls: 'add16' - },{ - text: 'Format', iconCls: 'add16' - }] - }] -}); - * - * @constructor - * Create a new ButtonGroup. - * @param {Object} config The config object - * @xtype buttongroup - */ -Ext.ButtonGroup = Ext.extend(Ext.Panel, { - /** - * @cfg {Number} columns The columns configuration property passed to the - * {@link #layout configured layout manager}. See {@link Ext.layout.TableLayout#columns}. - */ - /** - * @cfg {String} baseCls Defaults to 'x-btn-group'. See {@link Ext.Panel#baseCls}. - */ - baseCls: 'x-btn-group', - /** - * @cfg {String} layout Defaults to 'table'. See {@link Ext.Container#layout}. - */ - layout:'table', - defaultType: 'button', - /** - * @cfg {Boolean} frame Defaults to true. See {@link Ext.Panel#frame}. - */ - frame: true, - internalDefaults: {removeMode: 'container', hideParent: true}, - - initComponent : function(){ - this.layoutConfig = this.layoutConfig || {}; - Ext.applyIf(this.layoutConfig, { - columns : this.columns - }); - if(!this.title){ - this.addClass('x-btn-group-notitle'); - } - this.on('afterlayout', this.onAfterLayout, this); - Ext.ButtonGroup.superclass.initComponent.call(this); - }, - - applyDefaults : function(c){ - c = Ext.ButtonGroup.superclass.applyDefaults.call(this, c); - var d = this.internalDefaults; - if(c.events){ - Ext.applyIf(c.initialConfig, d); - Ext.apply(c, d); - }else{ - Ext.applyIf(c, d); - } - return c; - }, - - onAfterLayout : function(){ - var bodyWidth = this.body.getFrameWidth('lr') + this.body.dom.firstChild.offsetWidth; - this.body.setWidth(bodyWidth); - this.el.setWidth(bodyWidth + this.getFrameWidth()); - } - /** - * @cfg {Array} tools @hide - */ -}); - -Ext.reg('buttongroup', Ext.ButtonGroup); /** - * @class Ext.PagingToolbar - * @extends Ext.Toolbar - * As the amount of records increases, the time required for the browser to render - * them increases. Paging is used to reduce the amount of data exchanged with the client. - * Note: if there are more records/rows than can be viewed in the available screen area, vertical - * scrollbars will be added. - * Paging is typically handled on the server side (see exception below). The client sends - * parameters to the server side, which the server needs to interpret and then respond with the - * approprate data. - * Ext.PagingToolbar is a specialized toolbar that is bound to a {@link Ext.data.Store} - * and provides automatic paging control. This Component {@link Ext.data.Store#load load}s blocks - * of data into the {@link #store} by passing {@link Ext.data.Store#paramNames paramNames} used for - * paging criteria. - * PagingToolbar is typically used as one of the Grid's toolbars: - * -Ext.QuickTips.init(); // to display button quicktips + * @class Ext.chart.LineSeries + * @extends Ext.chart.CartesianSeries + * LineSeries class for the charts widget. + * @constructor + */ +Ext.chart.LineSeries = Ext.extend(Ext.chart.CartesianSeries, { + type: "line" +}); -var myStore = new Ext.data.Store({ - reader: new Ext.data.JsonReader({ - {@link Ext.data.JsonReader#totalProperty totalProperty}: 'results', - ... - }), - ... +/** + * @class Ext.chart.BarSeries + * @extends Ext.chart.CartesianSeries + * BarSeries class for the charts widget. + * @constructor + */ +Ext.chart.BarSeries = Ext.extend(Ext.chart.CartesianSeries, { + type: "bar" }); -var myPageSize = 25; // server script should only send back 25 items at a time -var grid = new Ext.grid.GridPanel({ - ... - store: myStore, - bbar: new Ext.PagingToolbar({ - {@link #store}: myStore, // grid and PagingToolbar using same store - {@link #displayInfo}: true, - {@link #pageSize}: myPageSize, - {@link #prependButtons}: true, - items: [ - 'text 1' - ] - }) -}); - * +/** + * @class Ext.chart.PieSeries + * @extends Ext.chart.Series + * PieSeries class for the charts widget. + * @constructor + */ +Ext.chart.PieSeries = Ext.extend(Ext.chart.Series, { + type: "pie", + dataField: null, + categoryField: null +});/** + * @class Ext.menu.Menu + * @extends Ext.Container + * A menu object. This is the container to which you may add menu items. Menu can also serve as a base class + * when you want a specialized menu based off of another component (like {@link Ext.menu.DateMenu} for example). + * Menus may contain either {@link Ext.menu.Item menu items}, or general {@link Ext.Component Component}s. + * To make a contained general {@link Ext.Component Component} line up with other {@link Ext.menu.Item menu items} + * specify iconCls: 'no-icon'. This reserves a space for an icon, and indents the Component in line + * with the other menu items. See {@link Ext.form.ComboBox}.{@link Ext.form.ComboBox#getListParent getListParent} + * for an example. + * By default, Menus are absolutely positioned, floating Components. By configuring a Menu with + * {@link #floating}:false, a Menu may be used as child of a Container. * - * To use paging, pass the paging requirements to the server when the store is first loaded. - * -store.load({ - params: { - // specify params for the first page load if using paging - start: 0, - limit: myPageSize, - // other params - foo: 'bar' - } -}); - * - * - * If using {@link Ext.data.Store#autoLoad store's autoLoad} configuration: - * -var myStore = new Ext.data.Store({ - {@link Ext.data.Store#autoLoad autoLoad}: {params:{start: 0, limit: 25}}, - ... -}); - * - * - * The packet sent back from the server would have this form: - * -{ - "success": true, - "results": 2000, - "rows": [ // *Note: this must be an Array - { "id": 1, "name": "Bill", "occupation": "Gardener" }, - { "id": 2, "name": "Ben", "occupation": "Horticulturalist" }, - ... - { "id": 25, "name": "Sue", "occupation": "Botanist" } - ] -} - * - * Paging with Local Data - * Paging can also be accomplished with local data using extensions: - * - * Ext.ux.data.PagingStore - * Paging Memory Proxy (examples/ux/PagingMemoryProxy.js) - * - * @constructor Create a new PagingToolbar - * @param {Object} config The config object - * @xtype paging + * @xtype menu */ -(function() { - -var T = Ext.Toolbar; - -Ext.PagingToolbar = Ext.extend(Ext.Toolbar, { +Ext.menu.Menu = Ext.extend(Ext.Container, { /** - * @cfg {Ext.data.Store} store - * The {@link Ext.data.Store} the paging toolbar should use as its data source (required). + * @cfg {Object} defaults + * A config object that will be applied to all items added to this container either via the {@link #items} + * config or via the {@link #add} method. The defaults config can contain any number of + * name/value property pairs to be added to each item, and should be valid for the types of items + * being added to the menu. */ /** - * @cfg {Boolean} displayInfo - * true to display the displayMsg (defaults to false) + * @cfg {Mixed} items + * An array of items to be added to this menu. Menus may contain either {@link Ext.menu.Item menu items}, + * or general {@link Ext.Component Component}s. */ /** - * @cfg {Number} pageSize - * The number of records to display per page (defaults to 20) + * @cfg {Number} minWidth The minimum width of the menu in pixels (defaults to 120) */ - pageSize : 20, + minWidth : 120, /** - * @cfg {Boolean} prependButtons - * true to insert any configured items before the paging buttons. - * Defaults to false. + * @cfg {Boolean/String} shadow True or 'sides' for the default effect, 'frame' for 4-way shadow, and 'drop' + * for bottom-right shadow (defaults to 'sides') */ + shadow : 'sides', /** - * @cfg {String} displayMsg - * The paging status message to display (defaults to 'Displaying {0} - {1} of {2}'). - * Note that this string is formatted using the braced numbers {0}-{2} as tokens - * that are replaced by the values for start, end and total respectively. These tokens should - * be preserved when overriding this string if showing those values is desired. + * @cfg {String} subMenuAlign The {@link Ext.Element#alignTo} anchor position value to use for submenus of + * this menu (defaults to 'tl-tr?') */ - displayMsg : 'Displaying {0} - {1} of {2}', + subMenuAlign : 'tl-tr?', /** - * @cfg {String} emptyMsg - * The message to display when no records are found (defaults to 'No data to display') + * @cfg {String} defaultAlign The default {@link Ext.Element#alignTo} anchor position value for this menu + * relative to its element of origin (defaults to 'tl-bl?') */ - emptyMsg : 'No data to display', + defaultAlign : 'tl-bl?', /** - * @cfg {String} beforePageText - * The text displayed before the input item (defaults to 'Page'). + * @cfg {Boolean} allowOtherMenus True to allow multiple menus to be displayed at the same time (defaults to false) */ - beforePageText : 'Page', + allowOtherMenus : false, /** - * @cfg {String} afterPageText - * Customizable piece of the default paging text (defaults to 'of {0}'). Note that - * this string is formatted using {0} as a token that is replaced by the number of - * total pages. This token should be preserved when overriding this string if showing the - * total page count is desired. + * @cfg {Boolean} ignoreParentClicks True to ignore clicks on any item in this menu that is a parent item (displays + * a submenu) so that the submenu is not dismissed when clicking the parent item (defaults to false). */ - afterPageText : 'of {0}', + ignoreParentClicks : false, /** - * @cfg {String} firstText - * The quicktip text displayed for the first page button (defaults to 'First Page'). - * Note: quick tips must be initialized for the quicktip to show. + * @cfg {Boolean} enableScrolling True to allow the menu container to have scroller controls if the menu is too long (defaults to true). */ - firstText : 'First Page', + enableScrolling : true, /** - * @cfg {String} prevText - * The quicktip text displayed for the previous page button (defaults to 'Previous Page'). - * Note: quick tips must be initialized for the quicktip to show. + * @cfg {Number} maxHeight The maximum height of the menu. Only applies when enableScrolling is set to True (defaults to null). */ - prevText : 'Previous Page', + maxHeight : null, /** - * @cfg {String} nextText - * The quicktip text displayed for the next page button (defaults to 'Next Page'). - * Note: quick tips must be initialized for the quicktip to show. + * @cfg {Number} scrollIncrement The amount to scroll the menu. Only applies when enableScrolling is set to True (defaults to 24). */ - nextText : 'Next Page', + scrollIncrement : 24, /** - * @cfg {String} lastText - * The quicktip text displayed for the last page button (defaults to 'Last Page'). - * Note: quick tips must be initialized for the quicktip to show. + * @cfg {Boolean} showSeparator True to show the icon separator. (defaults to true). */ - lastText : 'Last Page', + showSeparator : true, /** - * @cfg {String} refreshText - * The quicktip text displayed for the Refresh button (defaults to 'Refresh'). - * Note: quick tips must be initialized for the quicktip to show. + * @cfg {Array} defaultOffsets An array specifying the [x, y] offset in pixels by which to + * change the default Menu popup position after aligning according to the {@link #defaultAlign} + * configuration. Defaults to [0, 0]. */ - refreshText : 'Refresh', + defaultOffsets : [0, 0], /** - * Deprecated. paramNames should be set in the data store - * (see {@link Ext.data.Store#paramNames}). - * Object mapping of parameter names used for load calls, initially set to: - * {start: 'start', limit: 'limit'} - * @type Object - * @property paramNames - * @deprecated + * @cfg {Boolean} plain + * True to remove the incised line down the left side of the menu. Defaults to false. */ + plain : false, /** - * The number of records to display per page. See also {@link #cursor}. - * @type Number - * @property pageSize + * @cfg {Boolean} floating + * By default, a Menu configured as floating:true + * will be rendered as an {@link Ext.Layer} (an absolutely positioned, + * floating Component with zindex=15000). + * If configured as floating:false, the Menu may be + * used as child item of another Container instead of a free-floating + * {@link Ext.Layer Layer}. */ + floating : true, + /** - * Indicator for the record position. This property might be used to get the active page - * number for example: - * // t is reference to the paging toolbar instance - * var activePage = Math.ceil((t.cursor + t.pageSize) / t.pageSize); - * - * @type Number - * @property cursor + * @cfg {Number} zIndex + * zIndex to use when the menu is floating. */ + zIndex: 15000, - initComponent : function(){ - var pagingItems = [this.first = new T.Button({ - tooltip: this.firstText, - overflowText: this.firstText, - iconCls: 'x-tbar-page-first', - disabled: true, - handler: this.moveFirst, - scope: this - }), this.prev = new T.Button({ - tooltip: this.prevText, - overflowText: this.prevText, - iconCls: 'x-tbar-page-prev', - disabled: true, - handler: this.movePrevious, - scope: this - }), '-', this.beforePageText, - this.inputItem = new Ext.form.NumberField({ - cls: 'x-tbar-page-number', - allowDecimals: false, - allowNegative: false, - enableKeyEvents: true, - selectOnFocus: true, - submitValue: false, - listeners: { - scope: this, - keydown: this.onPagingKeyDown, - blur: this.onPagingBlur - } - }), this.afterTextItem = new T.TextItem({ - text: String.format(this.afterPageText, 1) - }), '-', this.next = new T.Button({ - tooltip: this.nextText, - overflowText: this.nextText, - iconCls: 'x-tbar-page-next', - disabled: true, - handler: this.moveNext, - scope: this - }), this.last = new T.Button({ - tooltip: this.lastText, - overflowText: this.lastText, - iconCls: 'x-tbar-page-last', - disabled: true, - handler: this.moveLast, - scope: this - }), '-', this.refresh = new T.Button({ - tooltip: this.refreshText, - overflowText: this.refreshText, - iconCls: 'x-tbar-loading', - handler: this.doRefresh, - scope: this - })]; + // private + hidden : true, + /** + * @cfg {String/Object} layout + * This class assigns a default layout (layout:'menu'). + * Developers may override this configuration option if another layout is required. + * See {@link Ext.Container#layout} for additional information. + */ + layout : 'menu', + hideMode : 'offsets', // Important for laying out Components + scrollerHeight : 8, + autoLayout : true, // Provided for backwards compat + defaultType : 'menuitem', + bufferResize : false, - var userItems = this.items || this.buttons || []; - if (this.prependButtons) { - this.items = userItems.concat(pagingItems); - }else{ - this.items = pagingItems.concat(userItems); - } - delete this.buttons; - if(this.displayInfo){ - this.items.push('->'); - this.items.push(this.displayItem = new T.TextItem({})); + initComponent : function(){ + if(Ext.isArray(this.initialConfig)){ + Ext.apply(this, {items:this.initialConfig}); } - Ext.PagingToolbar.superclass.initComponent.call(this); this.addEvents( /** - * @event change - * Fires after the active page has been changed. - * @param {Ext.PagingToolbar} this - * @param {Object} pageData An object that has these properties: - * total : Number The total number of records in the dataset as - * returned by the server - * activePage : Number The current page number - * pages : Number The total number of pages (calculated from - * the total number of records in the dataset as returned by the server and the current {@link #pageSize}) - * + * @event click + * Fires when this menu is clicked (or when the enter key is pressed while it is active) + * @param {Ext.menu.Menu} this + * @param {Ext.menu.Item} menuItem The menu item that was clicked + * @param {Ext.EventObject} e */ - 'change', + 'click', /** - * @event beforechange - * Fires just before the active page is changed. - * Return false to prevent the active page from being changed. - * @param {Ext.PagingToolbar} this - * @param {Object} params An object hash of the parameters which the PagingToolbar will send when - * loading the required page. This will contain: - * start : Number The starting row number for the next page of records to - * be retrieved from the server - * limit : Number The number of records to be retrieved from the server - * - * (note: the names of the start and limit properties are determined - * by the store's {@link Ext.data.Store#paramNames paramNames} property.) - * Parameters may be added as required in the event handler. + * @event mouseover + * Fires when the mouse is hovering over this menu + * @param {Ext.menu.Menu} this + * @param {Ext.EventObject} e + * @param {Ext.menu.Item} menuItem The menu item that was clicked */ - 'beforechange' + 'mouseover', + /** + * @event mouseout + * Fires when the mouse exits this menu + * @param {Ext.menu.Menu} this + * @param {Ext.EventObject} e + * @param {Ext.menu.Item} menuItem The menu item that was clicked + */ + 'mouseout', + /** + * @event itemclick + * Fires when a menu item contained in this menu is clicked + * @param {Ext.menu.BaseItem} baseItem The BaseItem that was clicked + * @param {Ext.EventObject} e + */ + 'itemclick' ); - this.on('afterlayout', this.onFirstLayout, this, {single: true}); - this.cursor = 0; - this.bindStore(this.store, true); + Ext.menu.MenuMgr.register(this); + if(this.floating){ + Ext.EventManager.onWindowResize(this.hide, this); + }else{ + if(this.initialConfig.hidden !== false){ + this.hidden = false; + } + this.internalDefaults = {hideOnClick: false}; + } + Ext.menu.Menu.superclass.initComponent.call(this); + if(this.autoLayout){ + var fn = this.doLayout.createDelegate(this, []); + this.on({ + add: fn, + remove: fn + }); + } + }, + + //private + getLayoutTarget : function() { + return this.ul; + }, + + // private + onRender : function(ct, position){ + if(!ct){ + ct = Ext.getBody(); + } + + var dh = { + id: this.getId(), + cls: 'x-menu ' + ((this.floating) ? 'x-menu-floating x-layer ' : '') + (this.cls || '') + (this.plain ? ' x-menu-plain' : '') + (this.showSeparator ? '' : ' x-menu-nosep'), + style: this.style, + cn: [ + {tag: 'a', cls: 'x-menu-focus', href: '#', onclick: 'return false;', tabIndex: '-1'}, + {tag: 'ul', cls: 'x-menu-list'} + ] + }; + if(this.floating){ + this.el = new Ext.Layer({ + shadow: this.shadow, + dh: dh, + constrain: false, + parentEl: ct, + zindex: this.zIndex + }); + }else{ + this.el = ct.createChild(dh); + } + Ext.menu.Menu.superclass.onRender.call(this, ct, position); + + if(!this.keyNav){ + this.keyNav = new Ext.menu.MenuNav(this); + } + // generic focus element + this.focusEl = this.el.child('a.x-menu-focus'); + this.ul = this.el.child('ul.x-menu-list'); + this.mon(this.ul, { + scope: this, + click: this.onClick, + mouseover: this.onMouseOver, + mouseout: this.onMouseOut + }); + if(this.enableScrolling){ + this.mon(this.el, { + scope: this, + delegate: '.x-menu-scroller', + click: this.onScroll, + mouseover: this.deactivateActive + }); + } + }, + + // private + findTargetItem : function(e){ + var t = e.getTarget('.x-menu-list-item', this.ul, true); + if(t && t.menuItemId){ + return this.items.get(t.menuItemId); + } + }, + + // private + onClick : function(e){ + var t = this.findTargetItem(e); + if(t){ + if(t.isFormField){ + this.setActiveItem(t); + }else if(t instanceof Ext.menu.BaseItem){ + if(t.menu && this.ignoreParentClicks){ + t.expandMenu(); + e.preventDefault(); + }else if(t.onClick){ + t.onClick(e); + this.fireEvent('click', this, t, e); + } + } + } + }, + + // private + setActiveItem : function(item, autoExpand){ + if(item != this.activeItem){ + this.deactivateActive(); + if((this.activeItem = item).isFormField){ + item.focus(); + }else{ + item.activate(autoExpand); + } + }else if(autoExpand){ + item.expandMenu(); + } + }, + + deactivateActive : function(){ + var a = this.activeItem; + if(a){ + if(a.isFormField){ + //Fields cannot deactivate, but Combos must collapse + if(a.collapse){ + a.collapse(); + } + }else{ + a.deactivate(); + } + delete this.activeItem; + } + }, + + // private + tryActivate : function(start, step){ + var items = this.items; + for(var i = start, len = items.length; i >= 0 && i < len; i+= step){ + var item = items.get(i); + if(!item.disabled && (item.canActivate || item.isFormField)){ + this.setActiveItem(item, false); + return item; + } + } + return false; + }, + + // private + onMouseOver : function(e){ + var t = this.findTargetItem(e); + if(t){ + if(t.canActivate && !t.disabled){ + this.setActiveItem(t, true); + } + } + this.over = true; + this.fireEvent('mouseover', this, e, t); + }, + + // private + onMouseOut : function(e){ + var t = this.findTargetItem(e); + if(t){ + if(t == this.activeItem && t.shouldDeactivate && t.shouldDeactivate(e)){ + this.activeItem.deactivate(); + delete this.activeItem; + } + } + this.over = false; + this.fireEvent('mouseout', this, e, t); + }, + + // private + onScroll : function(e, t){ + if(e){ + e.stopEvent(); + } + var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top'); + ul.scrollTop += this.scrollIncrement * (top ? -1 : 1); + if(top ? ul.scrollTop <= 0 : ul.scrollTop + this.activeMax >= ul.scrollHeight){ + this.onScrollerOut(null, t); + } + }, + + // private + onScrollerIn : function(e, t){ + var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top'); + if(top ? ul.scrollTop > 0 : ul.scrollTop + this.activeMax < ul.scrollHeight){ + Ext.fly(t).addClass(['x-menu-item-active', 'x-menu-scroller-active']); + } + }, + + // private + onScrollerOut : function(e, t){ + Ext.fly(t).removeClass(['x-menu-item-active', 'x-menu-scroller-active']); + }, + + /** + * If {@link #floating}=true, shows this menu relative to + * another element using {@link #showat}, otherwise uses {@link Ext.Component#show}. + * @param {Mixed} element The element to align to + * @param {String} position (optional) The {@link Ext.Element#alignTo} anchor position to use in aligning to + * the element (defaults to this.defaultAlign) + * @param {Ext.menu.Menu} parentMenu (optional) This menu's parent menu, if applicable (defaults to undefined) + */ + show : function(el, pos, parentMenu){ + if(this.floating){ + this.parentMenu = parentMenu; + if(!this.el){ + this.render(); + this.doLayout(false, true); + } + this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign, this.defaultOffsets), parentMenu); + }else{ + Ext.menu.Menu.superclass.show.call(this); + } + }, + + /** + * Displays this menu at a specific xy position and fires the 'show' event if a + * handler for the 'beforeshow' event does not return false cancelling the operation. + * @param {Array} xyPosition Contains X & Y [x, y] values for the position at which to show the menu (coordinates are page-based) + * @param {Ext.menu.Menu} parentMenu (optional) This menu's parent menu, if applicable (defaults to undefined) + */ + showAt : function(xy, parentMenu){ + if(this.fireEvent('beforeshow', this) !== false){ + this.parentMenu = parentMenu; + if(!this.el){ + this.render(); + } + if(this.enableScrolling){ + // set the position so we can figure out the constrain value. + this.el.setXY(xy); + //constrain the value, keep the y coordinate the same + xy[1] = this.constrainScroll(xy[1]); + xy = [this.el.adjustForConstraints(xy)[0], xy[1]]; + }else{ + //constrain to the viewport. + xy = this.el.adjustForConstraints(xy); + } + this.el.setXY(xy); + this.el.show(); + Ext.menu.Menu.superclass.onShow.call(this); + if(Ext.isIE){ + // internal event, used so we don't couple the layout to the menu + this.fireEvent('autosize', this); + if(!Ext.isIE8){ + this.el.repaint(); + } + } + this.hidden = false; + this.focus(); + this.fireEvent('show', this); + } + }, + + constrainScroll : function(y){ + var max, full = this.ul.setHeight('auto').getHeight(), + returnY = y, normalY, parentEl, scrollTop, viewHeight; + if(this.floating){ + parentEl = Ext.fly(this.el.dom.parentNode); + scrollTop = parentEl.getScroll().top; + viewHeight = parentEl.getViewSize().height; + //Normalize y by the scroll position for the parent element. Need to move it into the coordinate space + //of the view. + normalY = y - scrollTop; + max = this.maxHeight ? this.maxHeight : viewHeight - normalY; + if(full > viewHeight) { + max = viewHeight; + //Set returnY equal to (0,0) in view space by reducing y by the value of normalY + returnY = y - normalY; + } else if(max < full) { + returnY = y - (full - max); + max = full; + } + }else{ + max = this.getHeight(); + } + // Always respect maxHeight + if (this.maxHeight){ + max = Math.min(this.maxHeight, max); + } + if(full > max && max > 0){ + this.activeMax = max - this.scrollerHeight * 2 - this.el.getFrameWidth('tb') - Ext.num(this.el.shadowOffset, 0); + this.ul.setHeight(this.activeMax); + this.createScrollers(); + this.el.select('.x-menu-scroller').setDisplayed(''); + }else{ + this.ul.setHeight(full); + this.el.select('.x-menu-scroller').setDisplayed('none'); + } + this.ul.dom.scrollTop = 0; + return returnY; }, - // private - onFirstLayout : function(){ - if(this.dsLoaded){ - this.onLoad.apply(this, this.dsLoaded); + createScrollers : function(){ + if(!this.scroller){ + this.scroller = { + pos: 0, + top: this.el.insertFirst({ + tag: 'div', + cls: 'x-menu-scroller x-menu-scroller-top', + html: ' ' + }), + bottom: this.el.createChild({ + tag: 'div', + cls: 'x-menu-scroller x-menu-scroller-bottom', + html: ' ' + }) + }; + this.scroller.top.hover(this.onScrollerIn, this.onScrollerOut, this); + this.scroller.topRepeater = new Ext.util.ClickRepeater(this.scroller.top, { + listeners: { + click: this.onScroll.createDelegate(this, [null, this.scroller.top], false) + } + }); + this.scroller.bottom.hover(this.onScrollerIn, this.onScrollerOut, this); + this.scroller.bottomRepeater = new Ext.util.ClickRepeater(this.scroller.bottom, { + listeners: { + click: this.onScroll.createDelegate(this, [null, this.scroller.bottom], false) + } + }); } }, - // private - updateInfo : function(){ - if(this.displayItem){ - var count = this.store.getCount(); - var msg = count == 0 ? - this.emptyMsg : - String.format( - this.displayMsg, - this.cursor+1, this.cursor+count, this.store.getTotalCount() - ); - this.displayItem.setText(msg); + onLayout : function(){ + if(this.isVisible()){ + if(this.enableScrolling){ + this.constrainScroll(this.el.getTop()); + } + if(this.floating){ + this.el.sync(); + } } }, - // private - onLoad : function(store, r, o){ - if(!this.rendered){ - this.dsLoaded = [store, r, o]; - return; + focus : function(){ + if(!this.hidden){ + this.doFocus.defer(50, this); } - var p = this.getParams(); - this.cursor = (o.params && o.params[p.start]) ? o.params[p.start] : 0; - var d = this.getPageData(), ap = d.activePage, ps = d.pages; - - this.afterTextItem.setText(String.format(this.afterPageText, d.pages)); - this.inputItem.setValue(ap); - this.first.setDisabled(ap == 1); - this.prev.setDisabled(ap == 1); - this.next.setDisabled(ap == ps); - this.last.setDisabled(ap == ps); - this.refresh.enable(); - this.updateInfo(); - this.fireEvent('change', this, d); }, - // private - getPageData : function(){ - var total = this.store.getTotalCount(); - return { - total : total, - activePage : Math.ceil((this.cursor+this.pageSize)/this.pageSize), - pages : total < this.pageSize ? 1 : Math.ceil(total/this.pageSize) - }; + doFocus : function(){ + if(!this.hidden){ + this.focusEl.focus(); + } }, /** - * Change the active page - * @param {Integer} page The page to display + * Hides this menu and optionally all parent menus + * @param {Boolean} deep (optional) True to hide all parent menus recursively, if any (defaults to false) */ - changePage : function(page){ - this.doLoad(((page-1) * this.pageSize).constrain(0, this.store.getTotalCount())); - }, - - // private - onLoadError : function(){ - if(!this.rendered){ - return; + hide : function(deep){ + if (!this.isDestroyed) { + this.deepHide = deep; + Ext.menu.Menu.superclass.hide.call(this); + delete this.deepHide; } - this.refresh.enable(); }, // private - readPage : function(d){ - var v = this.inputItem.getValue(), pageNum; - if (!v || isNaN(pageNum = parseInt(v, 10))) { - this.inputItem.setValue(d.activePage); - return false; + onHide : function(){ + Ext.menu.Menu.superclass.onHide.call(this); + this.deactivateActive(); + if(this.el && this.floating){ + this.el.hide(); } - return pageNum; - }, - - onPagingFocus : function(){ - this.inputItem.select(); - }, - - //private - onPagingBlur : function(e){ - this.inputItem.setValue(this.getPageData().activePage); - }, - - // private - onPagingKeyDown : function(field, e){ - var k = e.getKey(), d = this.getPageData(), pageNum; - if (k == e.RETURN) { - e.stopEvent(); - pageNum = this.readPage(d); - if(pageNum !== false){ - pageNum = Math.min(Math.max(1, pageNum), d.pages) - 1; - this.doLoad(pageNum * this.pageSize); - } - }else if (k == e.HOME || k == e.END){ - e.stopEvent(); - pageNum = k == e.HOME ? 1 : d.pages; - field.setValue(pageNum); - }else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN){ - e.stopEvent(); - if((pageNum = this.readPage(d))){ - var increment = e.shiftKey ? 10 : 1; - if(k == e.DOWN || k == e.PAGEDOWN){ - increment *= -1; - } - pageNum += increment; - if(pageNum >= 1 & pageNum <= d.pages){ - field.setValue(pageNum); - } + var pm = this.parentMenu; + if(this.deepHide === true && pm){ + if(pm.floating){ + pm.hide(true); + }else{ + pm.deactivateActive(); } } }, // private - getParams : function(){ - //retain backwards compat, allow params on the toolbar itself, if they exist. - return this.paramNames || this.store.paramNames; + lookupComponent : function(c){ + if(Ext.isString(c)){ + c = (c == 'separator' || c == '-') ? new Ext.menu.Separator() : new Ext.menu.TextItem(c); + this.applyDefaults(c); + }else{ + if(Ext.isObject(c)){ + c = this.getMenuItem(c); + }else if(c.tagName || c.el){ // element. Wrap it. + c = new Ext.BoxComponent({ + el: c + }); + } + } + return c; }, - // private - beforeLoad : function(){ - if(this.rendered && this.refresh){ - this.refresh.disable(); + applyDefaults : function(c){ + if(!Ext.isString(c)){ + c = Ext.menu.Menu.superclass.applyDefaults.call(this, c); + var d = this.internalDefaults; + if(d){ + if(c.events){ + Ext.applyIf(c.initialConfig, d); + Ext.apply(c, d); + }else{ + Ext.applyIf(c, d); + } + } } + return c; }, // private - doLoad : function(start){ - var o = {}, pn = this.getParams(); - o[pn.start] = start; - o[pn.limit] = this.pageSize; - if(this.fireEvent('beforechange', this, o) !== false){ - this.store.load({params:o}); + getMenuItem : function(config){ + if(!config.isXType){ + if(!config.xtype && Ext.isBoolean(config.checked)){ + return new Ext.menu.CheckItem(config) + } + return Ext.create(config, this.defaultType); } + return config; }, /** - * Move to the first page, has the same effect as clicking the 'first' button. + * Adds a separator bar to the menu + * @return {Ext.menu.Item} The menu item that was added */ - moveFirst : function(){ - this.doLoad(0); + addSeparator : function(){ + return this.add(new Ext.menu.Separator()); }, /** - * Move to the previous page, has the same effect as clicking the 'previous' button. + * Adds an {@link Ext.Element} object to the menu + * @param {Mixed} el The element or DOM node to add, or its id + * @return {Ext.menu.Item} The menu item that was added */ - movePrevious : function(){ - this.doLoad(Math.max(0, this.cursor-this.pageSize)); + addElement : function(el){ + return this.add(new Ext.menu.BaseItem({ + el: el + })); }, /** - * Move to the next page, has the same effect as clicking the 'next' button. + * Adds an existing object based on {@link Ext.menu.BaseItem} to the menu + * @param {Ext.menu.Item} item The menu item to add + * @return {Ext.menu.Item} The menu item that was added */ - moveNext : function(){ - this.doLoad(this.cursor+this.pageSize); + addItem : function(item){ + return this.add(item); }, /** - * Move to the last page, has the same effect as clicking the 'last' button. + * Creates a new {@link Ext.menu.Item} based an the supplied config object and adds it to the menu + * @param {Object} config A MenuItem config object + * @return {Ext.menu.Item} The menu item that was added */ - moveLast : function(){ - var total = this.store.getTotalCount(), - extra = total % this.pageSize; - - this.doLoad(extra ? (total - extra) : total - this.pageSize); + addMenuItem : function(config){ + return this.add(this.getMenuItem(config)); }, /** - * Refresh the current page, has the same effect as clicking the 'refresh' button. + * Creates a new {@link Ext.menu.TextItem} with the supplied text and adds it to the menu + * @param {String} text The text to display in the menu item + * @return {Ext.menu.Item} The menu item that was added */ - doRefresh : function(){ - this.doLoad(this.cursor); + addText : function(text){ + return this.add(new Ext.menu.TextItem(text)); }, - /** - * Binds the paging toolbar to the specified {@link Ext.data.Store} - * @param {Store} store The store to bind to this toolbar - * @param {Boolean} initial (Optional) true to not remove listeners - */ - bindStore : function(store, initial){ - var doLoad; - if(!initial && this.store){ - if(store !== this.store && this.store.autoDestroy){ - this.store.destroy(); - }else{ - this.store.un('beforeload', this.beforeLoad, this); - this.store.un('load', this.onLoad, this); - this.store.un('exception', this.onLoadError, this); - } - if(!store){ - this.store = null; - } + //private + onDestroy : function(){ + Ext.EventManager.removeResizeListener(this.hide, this); + var pm = this.parentMenu; + if(pm && pm.activeChild == this){ + delete pm.activeChild; } - if(store){ - store = Ext.StoreMgr.lookup(store); - store.on({ - scope: this, - beforeload: this.beforeLoad, - load: this.onLoad, - exception: this.onLoadError - }); - doLoad = true; + delete this.parentMenu; + Ext.menu.Menu.superclass.onDestroy.call(this); + Ext.menu.MenuMgr.unregister(this); + if(this.keyNav) { + this.keyNav.disable(); } - this.store = store; - if(doLoad){ - this.onLoad(store, null, {}); + var s = this.scroller; + if(s){ + Ext.destroy(s.topRepeater, s.bottomRepeater, s.top, s.bottom); } - }, + Ext.destroy( + this.el, + this.focusEl, + this.ul + ); + } +}); + +Ext.reg('menu', Ext.menu.Menu); + +// MenuNav is a private utility class used internally by the Menu +Ext.menu.MenuNav = Ext.extend(Ext.KeyNav, function(){ + function up(e, m){ + if(!m.tryActivate(m.items.indexOf(m.activeItem)-1, -1)){ + m.tryActivate(m.items.length-1, -1); + } + } + function down(e, m){ + if(!m.tryActivate(m.items.indexOf(m.activeItem)+1, 1)){ + m.tryActivate(0, 1); + } + } + return { + constructor : function(menu){ + Ext.menu.MenuNav.superclass.constructor.call(this, menu.el); + this.scope = this.menu = menu; + }, + + doRelay : function(e, h){ + var k = e.getKey(); +// Keystrokes within a form Field (e.g.: down in a Combo) do not navigate. Allow only TAB + if (this.menu.activeItem && this.menu.activeItem.isFormField && k != e.TAB) { + return false; + } + if(!this.menu.activeItem && e.isNavKeyPress() && k != e.SPACE && k != e.RETURN){ + this.menu.tryActivate(0, 1); + return false; + } + return h.call(this.scope || this, e, this.menu); + }, + + tab: function(e, m) { + e.stopEvent(); + if (e.shiftKey) { + up(e, m); + } else { + down(e, m); + } + }, + + up : up, + + down : down, + + right : function(e, m){ + if(m.activeItem){ + m.activeItem.expandMenu(true); + } + }, + + left : function(e, m){ + m.hide(); + if(m.parentMenu && m.parentMenu.activeItem){ + m.parentMenu.activeItem.activate(); + } + }, + + enter : function(e, m){ + if(m.activeItem){ + e.stopPropagation(); + m.activeItem.onClick(e); + m.fireEvent('click', this, m.activeItem); + return true; + } + } + }; +}()); +/** + * @class Ext.menu.MenuMgr + * Provides a common registry of all menu items on a page so that they can be easily accessed by id. + * @singleton + */ +Ext.menu.MenuMgr = function(){ + var menus, active, groups = {}, attached = false, lastShow = new Date(); + + // private - called when first menu is created + function init(){ + menus = {}; + active = new Ext.util.MixedCollection(); + Ext.getDoc().addKeyListener(27, function(){ + if(active.length > 0){ + hideAll(); + } + }); + } + + // private + function hideAll(){ + if(active && active.length > 0){ + var c = active.clone(); + c.each(function(m){ + m.hide(); + }); + return true; + } + return false; + } + + // private + function onHide(m){ + active.remove(m); + if(active.length < 1){ + Ext.getDoc().un("mousedown", onMouseDown); + attached = false; + } + } + + // private + function onShow(m){ + var last = active.last(); + lastShow = new Date(); + active.add(m); + if(!attached){ + Ext.getDoc().on("mousedown", onMouseDown); + attached = true; + } + if(m.parentMenu){ + m.getEl().setZIndex(parseInt(m.parentMenu.getEl().getStyle("z-index"), 10) + 3); + m.parentMenu.activeChild = m; + }else if(last && !last.isDestroyed && last.isVisible()){ + m.getEl().setZIndex(parseInt(last.getEl().getStyle("z-index"), 10) + 3); + } + } + + // private + function onBeforeHide(m){ + if(m.activeChild){ + m.activeChild.hide(); + } + if(m.autoHideTimer){ + clearTimeout(m.autoHideTimer); + delete m.autoHideTimer; + } + } + + // private + function onBeforeShow(m){ + var pm = m.parentMenu; + if(!pm && !m.allowOtherMenus){ + hideAll(); + }else if(pm && pm.activeChild){ + pm.activeChild.hide(); + } + } + + // private + function onMouseDown(e){ + if(lastShow.getElapsed() > 50 && active.length > 0 && !e.getTarget(".x-menu")){ + hideAll(); + } + } + + // private + function onBeforeCheck(mi, state){ + if(state){ + var g = groups[mi.group]; + for(var i = 0, l = g.length; i < l; i++){ + if(g[i] != mi){ + g[i].setChecked(false); + } + } + } + } + + return { + + /** + * Hides all menus that are currently visible + * @return {Boolean} success True if any active menus were hidden. + */ + hideAll : function(){ + return hideAll(); + }, + + // private + register : function(menu){ + if(!menus){ + init(); + } + menus[menu.id] = menu; + menu.on({ + beforehide: onBeforeHide, + hide: onHide, + beforeshow: onBeforeShow, + show: onShow + }); + }, + + /** + * Returns a {@link Ext.menu.Menu} object + * @param {String/Object} menu The string menu id, an existing menu object reference, or a Menu config that will + * be used to generate and return a new Menu instance. + * @return {Ext.menu.Menu} The specified menu, or null if none are found + */ + get : function(menu){ + if(typeof menu == "string"){ // menu id + if(!menus){ // not initialized, no menus to return + return null; + } + return menus[menu]; + }else if(menu.events){ // menu instance + return menu; + }else if(typeof menu.length == 'number'){ // array of menu items? + return new Ext.menu.Menu({items:menu}); + }else{ // otherwise, must be a config + return Ext.create(menu, 'menu'); + } + }, + + // private + unregister : function(menu){ + delete menus[menu.id]; + menu.un("beforehide", onBeforeHide); + menu.un("hide", onHide); + menu.un("beforeshow", onBeforeShow); + menu.un("show", onShow); + }, - /** - * Unbinds the paging toolbar from the specified {@link Ext.data.Store} (deprecated) - * @param {Ext.data.Store} store The data store to unbind - */ - unbind : function(store){ - this.bindStore(null); - }, + // private + registerCheckable : function(menuItem){ + var g = menuItem.group; + if(g){ + if(!groups[g]){ + groups[g] = []; + } + groups[g].push(menuItem); + menuItem.on("beforecheckchange", onBeforeCheck); + } + }, - /** - * Binds the paging toolbar to the specified {@link Ext.data.Store} (deprecated) - * @param {Ext.data.Store} store The data store to bind - */ - bind : function(store){ - this.bindStore(store); - }, + // private + unregisterCheckable : function(menuItem){ + var g = menuItem.group; + if(g){ + groups[g].remove(menuItem); + menuItem.un("beforecheckchange", onBeforeCheck); + } + }, - // private - onDestroy : function(){ - this.bindStore(null); - Ext.PagingToolbar.superclass.onDestroy.call(this); - } -}); + getCheckedItem : function(groupId){ + var g = groups[groupId]; + if(g){ + for(var i = 0, l = g.length; i < l; i++){ + if(g[i].checked){ + return g[i]; + } + } + } + return null; + }, -})(); -Ext.reg('paging', Ext.PagingToolbar);/** - * @class Ext.History - * @extends Ext.util.Observable - * History management component that allows you to register arbitrary tokens that signify application - * history state on navigation actions. You can then handle the history {@link #change} event in order - * to reset your application UI to the appropriate state when the user navigates forward or backward through - * the browser history stack. - * @singleton - */ -Ext.History = (function () { - var iframe, hiddenField; - var ready = false; - var currentToken; - - function getHash() { - var href = top.location.href, i = href.indexOf("#"); - return i >= 0 ? href.substr(i + 1) : null; - } - - function doSave() { - hiddenField.value = currentToken; - } - - function handleStateChange(token) { - currentToken = token; - Ext.History.fireEvent('change', token); - } - - function updateIFrame (token) { - var html = ['',Ext.util.Format.htmlEncode(token),''].join(''); - try { - var doc = iframe.contentWindow.document; - doc.open(); - doc.write(html); - doc.close(); - return true; - } catch (e) { - return false; - } - } - - function checkIFrame() { - if (!iframe.contentWindow || !iframe.contentWindow.document) { - setTimeout(checkIFrame, 10); - return; - } - - var doc = iframe.contentWindow.document; - var elem = doc.getElementById("state"); - var token = elem ? elem.innerText : null; - - var hash = getHash(); - - setInterval(function () { - - doc = iframe.contentWindow.document; - elem = doc.getElementById("state"); - - var newtoken = elem ? elem.innerText : null; - - var newHash = getHash(); - - if (newtoken !== token) { - token = newtoken; - handleStateChange(token); - top.location.hash = token; - hash = token; - doSave(); - } else if (newHash !== hash) { - hash = newHash; - updateIFrame(newHash); - } - - }, 50); - - ready = true; - - Ext.History.fireEvent('ready', Ext.History); - } - - function startUp() { - currentToken = hiddenField.value ? hiddenField.value : getHash(); - - if (Ext.isIE) { - checkIFrame(); - } else { - var hash = getHash(); - setInterval(function () { - var newHash = getHash(); - if (newHash !== hash) { - hash = newHash; - handleStateChange(hash); - doSave(); - } - }, 50); - ready = true; - Ext.History.fireEvent('ready', Ext.History); - } - } - - return { - /** - * The id of the hidden field required for storing the current history token. - * @type String - * @property - */ - fieldId: 'x-history-field', - /** - * The id of the iframe required by IE to manage the history stack. - * @type String - * @property - */ - iframeId: 'x-history-frame', - - events:{}, - - /** - * Initialize the global History instance. - * @param {Boolean} onReady (optional) A callback function that will be called once the history - * component is fully initialized. - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to the browser window. - */ - init: function (onReady, scope) { - if(ready) { - Ext.callback(onReady, scope, [this]); - return; - } - if(!Ext.isReady){ - Ext.onReady(function(){ - Ext.History.init(onReady, scope); - }); - return; - } - hiddenField = Ext.getDom(Ext.History.fieldId); - if (Ext.isIE) { - iframe = Ext.getDom(Ext.History.iframeId); - } - this.addEvents( - /** - * @event ready - * Fires when the Ext.History singleton has been initialized and is ready for use. - * @param {Ext.History} The Ext.History singleton. - */ - 'ready', - /** - * @event change - * Fires when navigation back or forwards within the local page's history occurs. - * @param {String} token An identifier associated with the page state at that point in its history. - */ - 'change' - ); - if(onReady){ - this.on('ready', onReady, scope, {single:true}); - } - startUp(); - }, - - /** - * Add a new token to the history stack. This can be any arbitrary value, although it would - * commonly be the concatenation of a component id and another id marking the specifc history - * state of that component. Example usage: - * -// Handle tab changes on a TabPanel -tabPanel.on('tabchange', function(tabPanel, tab){ - Ext.History.add(tabPanel.id + ':' + tab.id); -}); - - * @param {String} token The value that defines a particular application-specific history state - * @param {Boolean} preventDuplicates When true, if the passed token matches the current token - * it will not save a new history step. Set to false if the same state can be saved more than once - * at the same history stack location (defaults to true). - */ - add: function (token, preventDup) { - if(preventDup !== false){ - if(this.getToken() == token){ - return true; - } - } - if (Ext.isIE) { - return updateIFrame(token); - } else { - top.location.hash = token; - return true; - } - }, - - /** - * Programmatically steps back one step in browser history (equivalent to the user pressing the Back button). - */ - back: function(){ - history.go(-1); - }, - - /** - * Programmatically steps forward one step in browser history (equivalent to the user pressing the Forward button). - */ - forward: function(){ - history.go(1); - }, - - /** - * Retrieves the currently-active history token. - * @return {String} The token - */ - getToken: function() { - return ready ? currentToken : getHash(); - } - }; -})(); -Ext.apply(Ext.History, new Ext.util.Observable());/** - * @class Ext.Tip - * @extends Ext.Panel - * @xtype tip - * This is the base class for {@link Ext.QuickTip} and {@link Ext.Tooltip} that provides the basic layout and - * positioning that all tip-based classes require. This class can be used directly for simple, statically-positioned - * tips that are displayed programmatically, or it can be extended to provide custom tip implementations. - * @constructor - * Create a new Tip - * @param {Object} config The configuration options - */ -Ext.Tip = Ext.extend(Ext.Panel, { - /** - * @cfg {Boolean} closable True to render a close tool button into the tooltip header (defaults to false). - */ - /** - * @cfg {Number} width - * Width in pixels of the tip (defaults to auto). Width will be ignored if it exceeds the bounds of - * {@link #minWidth} or {@link #maxWidth}. The maximum supported value is 500. - */ - /** - * @cfg {Number} minWidth The minimum width of the tip in pixels (defaults to 40). - */ - minWidth : 40, - /** - * @cfg {Number} maxWidth The maximum width of the tip in pixels (defaults to 300). The maximum supported value is 500. - */ - maxWidth : 300, - /** - * @cfg {Boolean/String} shadow True or "sides" for the default effect, "frame" for 4-way shadow, and "drop" - * for bottom-right shadow (defaults to "sides"). - */ - shadow : "sides", - /** - * @cfg {String} defaultAlign Experimental. The default {@link Ext.Element#alignTo} anchor position value - * for this tip relative to its element of origin (defaults to "tl-bl?"). - */ - defaultAlign : "tl-bl?", - autoRender: true, - quickShowInterval : 250, - - // private panel overrides - frame:true, - hidden:true, - baseCls: 'x-tip', - floating:{shadow:true,shim:true,useDisplay:true,constrain:false}, - autoHeight:true, - - closeAction: 'hide', - - // private - initComponent : function(){ - Ext.Tip.superclass.initComponent.call(this); - if(this.closable && !this.title){ - this.elements += ',header'; - } - }, - - // private - afterRender : function(){ - Ext.Tip.superclass.afterRender.call(this); - if(this.closable){ - this.addTool({ - id: 'close', - handler: this[this.closeAction], - scope: this - }); - } - }, - - /** - * Shows this tip at the specified XY position. Example usage: - * -// Show the tip at x:50 and y:100 -tip.showAt([50,100]); - - * @param {Array} xy An array containing the x and y coordinates - */ - showAt : function(xy){ - Ext.Tip.superclass.show.call(this); - if(this.measureWidth !== false && (!this.initialConfig || typeof this.initialConfig.width != 'number')){ - this.doAutoWidth(); - } - if(this.constrainPosition){ - xy = this.el.adjustForConstraints(xy); - } - this.setPagePosition(xy[0], xy[1]); - }, - - // protected - doAutoWidth : function(adjust){ - adjust = adjust || 0; - var bw = this.body.getTextWidth(); - if(this.title){ - bw = Math.max(bw, this.header.child('span').getTextWidth(this.title)); - } - bw += this.getFrameWidth() + (this.closable ? 20 : 0) + this.body.getPadding("lr") + adjust; - this.setWidth(bw.constrain(this.minWidth, this.maxWidth)); - - // IE7 repaint bug on initial show - if(Ext.isIE7 && !this.repainted){ - this.el.repaint(); - this.repainted = true; - } - }, - - /** - * Experimental. Shows this tip at a position relative to another element using a standard {@link Ext.Element#alignTo} - * anchor position value. Example usage: - * -// Show the tip at the default position ('tl-br?') -tip.showBy('my-el'); - -// Show the tip's top-left corner anchored to the element's top-right corner -tip.showBy('my-el', 'tl-tr'); - - * @param {Mixed} el An HTMLElement, Ext.Element or string id of the target element to align to - * @param {String} position (optional) A valid {@link Ext.Element#alignTo} anchor position (defaults to 'tl-br?' or - * {@link #defaultAlign} if specified). - */ - showBy : function(el, pos){ - if(!this.rendered){ - this.render(Ext.getBody()); - } - this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign)); - }, - - initDraggable : function(){ - this.dd = new Ext.Tip.DD(this, typeof this.draggable == 'boolean' ? null : this.draggable); - this.header.addClass('x-tip-draggable'); - } -}); - -Ext.reg('tip', Ext.Tip); - -// private - custom Tip DD implementation -Ext.Tip.DD = function(tip, config){ - Ext.apply(this, config); - this.tip = tip; - Ext.Tip.DD.superclass.constructor.call(this, tip.el.id, 'WindowDD-'+tip.id); - this.setHandleElId(tip.header.id); - this.scroll = false; -}; - -Ext.extend(Ext.Tip.DD, Ext.dd.DD, { - moveOnly:true, - scroll:false, - headerOffsets:[100, 25], - startDrag : function(){ - this.tip.el.disableShadow(); - }, - endDrag : function(e){ - this.tip.el.enableShadow(true); - } -});/** - * @class Ext.ToolTip - * @extends Ext.Tip - * A standard tooltip implementation for providing additional information when hovering over a target element. - * @xtype tooltip - * @constructor - * Create a new Tooltip - * @param {Object} config The configuration options - */ -Ext.ToolTip = Ext.extend(Ext.Tip, { - /** - * When a Tooltip is configured with the {@link #delegate} - * option to cause selected child elements of the {@link #target} - * Element to each trigger a seperate show event, this property is set to - * the DOM element which triggered the show. - * @type DOMElement - * @property triggerElement - */ - /** - * @cfg {Mixed} target The target HTMLElement, Ext.Element or id to monitor - * for mouseover events to trigger showing this ToolTip. - */ - /** - * @cfg {Boolean} autoHide True to automatically hide the tooltip after the - * mouse exits the target element or after the {@link #dismissDelay} - * has expired if set (defaults to true). If {@link closable} = true - * a close tool button will be rendered into the tooltip header. - */ - /** - * @cfg {Number} showDelay Delay in milliseconds before the tooltip displays - * after the mouse enters the target element (defaults to 500) - */ - showDelay : 500, - /** - * @cfg {Number} hideDelay Delay in milliseconds after the mouse exits the - * target element but before the tooltip actually hides (defaults to 200). - * Set to 0 for the tooltip to hide immediately. - */ - hideDelay : 200, - /** - * @cfg {Number} dismissDelay Delay in milliseconds before the tooltip - * automatically hides (defaults to 5000). To disable automatic hiding, set - * dismissDelay = 0. - */ - dismissDelay : 5000, - /** - * @cfg {Array} mouseOffset An XY offset from the mouse position where the - * tooltip should be shown (defaults to [15,18]). - */ - /** - * @cfg {Boolean} trackMouse True to have the tooltip follow the mouse as it - * moves over the target element (defaults to false). - */ - trackMouse : false, - /** - * @cfg {Boolean} anchorToTarget True to anchor the tooltip to the target - * element, false to anchor it relative to the mouse coordinates (defaults - * to true). When anchorToTarget is true, use - * {@link #defaultAlign} to control tooltip alignment to the - * target element. When anchorToTarget is false, use - * {@link #anchorPosition} instead to control alignment. - */ - anchorToTarget : true, - /** - * @cfg {Number} anchorOffset A numeric pixel value used to offset the - * default position of the anchor arrow (defaults to 0). When the anchor - * position is on the top or bottom of the tooltip, anchorOffset - * will be used as a horizontal offset. Likewise, when the anchor position - * is on the left or right side, anchorOffset will be used as - * a vertical offset. - */ - anchorOffset : 0, - /** - * @cfg {String} delegate Optional. A {@link Ext.DomQuery DomQuery} - * selector which allows selection of individual elements within the - * {@link #target} element to trigger showing and hiding the - * ToolTip as the mouse moves within the target. - * When specified, the child element of the target which caused a show - * event is placed into the {@link #triggerElement} property - * before the ToolTip is shown. - * This may be useful when a Component has regular, repeating elements - * in it, each of which need a Tooltip which contains information specific - * to that element. For example: -var myGrid = new Ext.grid.gridPanel(gridConfig); -myGrid.on('render', function(grid) { - var store = grid.getStore(); // Capture the Store. - var view = grid.getView(); // Capture the GridView. - myGrid.tip = new Ext.ToolTip({ - target: view.mainBody, // The overall target element. - delegate: '.x-grid3-row', // Each grid row causes its own seperate show and hide. - trackMouse: true, // Moving within the row should not hide the tip. - renderTo: document.body, // Render immediately so that tip.body can be - // referenced prior to the first show. - listeners: { // Change content dynamically depending on which element - // triggered the show. - beforeshow: function updateTipBody(tip) { - var rowIndex = view.findRowIndex(tip.triggerElement); - tip.body.dom.innerHTML = 'Over Record ID ' + store.getAt(rowIndex).id; - } - } - }); -}); - * - */ - - // private - targetCounter : 0, - - constrainPosition : false, - - // private - initComponent : function(){ - Ext.ToolTip.superclass.initComponent.call(this); - this.lastActive = new Date(); - this.initTarget(this.target); - this.origAnchor = this.anchor; - }, - - // private - onRender : function(ct, position){ - Ext.ToolTip.superclass.onRender.call(this, ct, position); - this.anchorCls = 'x-tip-anchor-' + this.getAnchorPosition(); - this.anchorEl = this.el.createChild({ - cls: 'x-tip-anchor ' + this.anchorCls - }); - }, - - // private - afterRender : function(){ - Ext.ToolTip.superclass.afterRender.call(this); - this.anchorEl.setStyle('z-index', this.el.getZIndex() + 1); - }, - - /** - * Binds this ToolTip to the specified element. The tooltip will be displayed when the mouse moves over the element. - * @param {Mixed} t The Element, HtmlElement, or ID of an element to bind to - */ - initTarget : function(target){ - var t; - if((t = Ext.get(target))){ - if(this.target){ - var tg = Ext.get(this.target); - this.mun(tg, 'mouseover', this.onTargetOver, this); - this.mun(tg, 'mouseout', this.onTargetOut, this); - this.mun(tg, 'mousemove', this.onMouseMove, this); - } - this.mon(t, { - mouseover: this.onTargetOver, - mouseout: this.onTargetOut, - mousemove: this.onMouseMove, - scope: this - }); - this.target = t; - } - if(this.anchor){ - this.anchorTarget = this.target; - } - }, - - // private - onMouseMove : function(e){ - var t = this.delegate ? e.getTarget(this.delegate) : this.triggerElement = true; - if (t) { - this.targetXY = e.getXY(); - if (t === this.triggerElement) { - if(!this.hidden && this.trackMouse){ - this.setPagePosition(this.getTargetXY()); - } - } else { - this.hide(); - this.lastActive = new Date(0); - this.onTargetOver(e); - } - } else if (!this.closable && this.isVisible()) { - this.hide(); - } - }, - - // private - getTargetXY : function(){ - if(this.delegate){ - this.anchorTarget = this.triggerElement; - } - if(this.anchor){ - this.targetCounter++; - var offsets = this.getOffsets(), - xy = (this.anchorToTarget && !this.trackMouse) ? this.el.getAlignToXY(this.anchorTarget, this.getAnchorAlign()) : this.targetXY, - dw = Ext.lib.Dom.getViewWidth() - 5, - dh = Ext.lib.Dom.getViewHeight() - 5, - de = document.documentElement, - bd = document.body, - scrollX = (de.scrollLeft || bd.scrollLeft || 0) + 5, - scrollY = (de.scrollTop || bd.scrollTop || 0) + 5, - axy = [xy[0] + offsets[0], xy[1] + offsets[1]], - sz = this.getSize(); - - this.anchorEl.removeClass(this.anchorCls); - - if(this.targetCounter < 2){ - if(axy[0] < scrollX){ - if(this.anchorToTarget){ - this.defaultAlign = 'l-r'; - if(this.mouseOffset){this.mouseOffset[0] *= -1;} - } - this.anchor = 'left'; - return this.getTargetXY(); - } - if(axy[0]+sz.width > dw){ - if(this.anchorToTarget){ - this.defaultAlign = 'r-l'; - if(this.mouseOffset){this.mouseOffset[0] *= -1;} - } - this.anchor = 'right'; - return this.getTargetXY(); - } - if(axy[1] < scrollY){ - if(this.anchorToTarget){ - this.defaultAlign = 't-b'; - if(this.mouseOffset){this.mouseOffset[1] *= -1;} - } - this.anchor = 'top'; - return this.getTargetXY(); - } - if(axy[1]+sz.height > dh){ - if(this.anchorToTarget){ - this.defaultAlign = 'b-t'; - if(this.mouseOffset){this.mouseOffset[1] *= -1;} - } - this.anchor = 'bottom'; - return this.getTargetXY(); - } - } - - this.anchorCls = 'x-tip-anchor-'+this.getAnchorPosition(); - this.anchorEl.addClass(this.anchorCls); - this.targetCounter = 0; - return axy; - }else{ - var mouseOffset = this.getMouseOffset(); - return [this.targetXY[0]+mouseOffset[0], this.targetXY[1]+mouseOffset[1]]; - } - }, - - getMouseOffset : function(){ - var offset = this.anchor ? [0,0] : [15,18]; - if(this.mouseOffset){ - offset[0] += this.mouseOffset[0]; - offset[1] += this.mouseOffset[1]; - } - return offset; - }, - - // private - getAnchorPosition : function(){ - if(this.anchor){ - this.tipAnchor = this.anchor.charAt(0); - }else{ - var m = this.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/); - if(!m){ - throw 'AnchorTip.defaultAlign is invalid'; - } - this.tipAnchor = m[1].charAt(0); - } - - switch(this.tipAnchor){ - case 't': return 'top'; - case 'b': return 'bottom'; - case 'r': return 'right'; - } - return 'left'; - }, - - // private - getAnchorAlign : function(){ - switch(this.anchor){ - case 'top' : return 'tl-bl'; - case 'left' : return 'tl-tr'; - case 'right': return 'tr-tl'; - default : return 'bl-tl'; - } - }, - - // private - getOffsets : function(){ - var offsets, - ap = this.getAnchorPosition().charAt(0); - if(this.anchorToTarget && !this.trackMouse){ - switch(ap){ - case 't': - offsets = [0, 9]; - break; - case 'b': - offsets = [0, -13]; - break; - case 'r': - offsets = [-13, 0]; - break; - default: - offsets = [9, 0]; - break; - } - }else{ - switch(ap){ - case 't': - offsets = [-15-this.anchorOffset, 30]; - break; - case 'b': - offsets = [-19-this.anchorOffset, -13-this.el.dom.offsetHeight]; - break; - case 'r': - offsets = [-15-this.el.dom.offsetWidth, -13-this.anchorOffset]; - break; - default: - offsets = [25, -13-this.anchorOffset]; - break; - } - } - var mouseOffset = this.getMouseOffset(); - offsets[0] += mouseOffset[0]; - offsets[1] += mouseOffset[1]; - - return offsets; - }, - - // private - onTargetOver : function(e){ - if(this.disabled || e.within(this.target.dom, true)){ - return; - } - var t = e.getTarget(this.delegate); - if (t) { - this.triggerElement = t; - this.clearTimer('hide'); - this.targetXY = e.getXY(); - this.delayShow(); - } - }, - - // private - delayShow : function(){ - if(this.hidden && !this.showTimer){ - if(this.lastActive.getElapsed() < this.quickShowInterval){ - this.show(); - }else{ - this.showTimer = this.show.defer(this.showDelay, this); - } - }else if(!this.hidden && this.autoHide !== false){ - this.show(); - } - }, - - // private - onTargetOut : function(e){ - if(this.disabled || e.within(this.target.dom, true)){ - return; - } - this.clearTimer('show'); - if(this.autoHide !== false){ - this.delayHide(); - } - }, - - // private - delayHide : function(){ - if(!this.hidden && !this.hideTimer){ - this.hideTimer = this.hide.defer(this.hideDelay, this); - } - }, - - /** - * Hides this tooltip if visible. - */ - hide: function(){ - this.clearTimer('dismiss'); - this.lastActive = new Date(); - if(this.anchorEl){ - this.anchorEl.hide(); - } - Ext.ToolTip.superclass.hide.call(this); - delete this.triggerElement; - }, - - /** - * Shows this tooltip at the current event target XY position. - */ - show : function(){ - if(this.anchor){ - // pre-show it off screen so that the el will have dimensions - // for positioning calcs when getting xy next - this.showAt([-1000,-1000]); - this.origConstrainPosition = this.constrainPosition; - this.constrainPosition = false; - this.anchor = this.origAnchor; - } - this.showAt(this.getTargetXY()); - - if(this.anchor){ - this.syncAnchor(); - this.anchorEl.show(); - this.constrainPosition = this.origConstrainPosition; - }else{ - this.anchorEl.hide(); - } - }, - - // inherit docs - showAt : function(xy){ - this.lastActive = new Date(); - this.clearTimers(); - Ext.ToolTip.superclass.showAt.call(this, xy); - if(this.dismissDelay && this.autoHide !== false){ - this.dismissTimer = this.hide.defer(this.dismissDelay, this); - } - if(this.anchor && !this.anchorEl.isVisible()){ - this.syncAnchor(); - this.anchorEl.show(); - } - }, - - // private - syncAnchor : function(){ - var anchorPos, targetPos, offset; - switch(this.tipAnchor.charAt(0)){ - case 't': - anchorPos = 'b'; - targetPos = 'tl'; - offset = [20+this.anchorOffset, 2]; - break; - case 'r': - anchorPos = 'l'; - targetPos = 'tr'; - offset = [-2, 11+this.anchorOffset]; - break; - case 'b': - anchorPos = 't'; - targetPos = 'bl'; - offset = [20+this.anchorOffset, -2]; - break; - default: - anchorPos = 'r'; - targetPos = 'tl'; - offset = [2, 11+this.anchorOffset]; - break; - } - this.anchorEl.alignTo(this.el, anchorPos+'-'+targetPos, offset); - }, - - // private - setPagePosition : function(x, y){ - Ext.ToolTip.superclass.setPagePosition.call(this, x, y); - if(this.anchor){ - this.syncAnchor(); - } - }, - - // private - clearTimer : function(name){ - name = name + 'Timer'; - clearTimeout(this[name]); - delete this[name]; - }, - - // private - clearTimers : function(){ - this.clearTimer('show'); - this.clearTimer('dismiss'); - this.clearTimer('hide'); - }, - - // private - onShow : function(){ - Ext.ToolTip.superclass.onShow.call(this); - Ext.getDoc().on('mousedown', this.onDocMouseDown, this); - }, - - // private - onHide : function(){ - Ext.ToolTip.superclass.onHide.call(this); - Ext.getDoc().un('mousedown', this.onDocMouseDown, this); - }, - - // private - onDocMouseDown : function(e){ - if(this.autoHide !== true && !this.closable && !e.within(this.el.dom)){ - this.disable(); - this.enable.defer(100, this); - } - }, - - // private - onDisable : function(){ - this.clearTimers(); - this.hide(); - }, - - // private - adjustPosition : function(x, y){ - if(this.contstrainPosition){ - var ay = this.targetXY[1], h = this.getSize().height; - if(y <= ay && (y+h) >= ay){ - y = ay-h-5; - } - } - return {x : x, y: y}; - }, - - beforeDestroy : function(){ - this.clearTimers(); - Ext.destroy(this.anchorEl); - delete this.anchorEl; - delete this.target; - delete this.anchorTarget; - delete this.triggerElement; - Ext.ToolTip.superclass.beforeDestroy.call(this); - }, - - // private - onDestroy : function(){ - Ext.getDoc().un('mousedown', this.onDocMouseDown, this); - Ext.ToolTip.superclass.onDestroy.call(this); - } -}); - -Ext.reg('tooltip', Ext.ToolTip);/** - * @class Ext.QuickTip - * @extends Ext.ToolTip - * @xtype quicktip - * A specialized tooltip class for tooltips that can be specified in markup and automatically managed by the global - * {@link Ext.QuickTips} instance. See the QuickTips class header for additional usage details and examples. - * @constructor - * Create a new Tip - * @param {Object} config The configuration options - */ -Ext.QuickTip = Ext.extend(Ext.ToolTip, { - /** - * @cfg {Mixed} target The target HTMLElement, Ext.Element or id to associate with this quicktip (defaults to the document). - */ - /** - * @cfg {Boolean} interceptTitles True to automatically use the element's DOM title value if available (defaults to false). - */ - interceptTitles : false, - - // private - tagConfig : { - namespace : "ext", - attribute : "qtip", - width : "qwidth", - target : "target", - title : "qtitle", - hide : "hide", - cls : "qclass", - align : "qalign", - anchor : "anchor" - }, - - // private - initComponent : function(){ - this.target = this.target || Ext.getDoc(); - this.targets = this.targets || {}; - Ext.QuickTip.superclass.initComponent.call(this); - }, - - /** - * Configures a new quick tip instance and assigns it to a target element. The following config values are - * supported (for example usage, see the {@link Ext.QuickTips} class header): - * - * autoHide - * cls - * dismissDelay (overrides the singleton value) - * target (required) - * text (required) - * title - * width - * @param {Object} config The config object - */ - register : function(config){ - var cs = Ext.isArray(config) ? config : arguments; - for(var i = 0, len = cs.length; i < len; i++){ - var c = cs[i]; - var target = c.target; - if(target){ - if(Ext.isArray(target)){ - for(var j = 0, jlen = target.length; j < jlen; j++){ - this.targets[Ext.id(target[j])] = c; - } - } else{ - this.targets[Ext.id(target)] = c; - } - } - } - }, - - /** - * Removes this quick tip from its element and destroys it. - * @param {String/HTMLElement/Element} el The element from which the quick tip is to be removed. - */ - unregister : function(el){ - delete this.targets[Ext.id(el)]; - }, - - /** - * Hides a visible tip or cancels an impending show for a particular element. - * @param {String/HTMLElement/Element} el The element that is the target of the tip. - */ - cancelShow: function(el){ - var at = this.activeTarget; - el = Ext.get(el).dom; - if(this.isVisible()){ - if(at && at.el == el){ - this.hide(); - } - }else if(at && at.el == el){ - this.clearTimer('show'); - } - }, - - getTipCfg: function(e) { - var t = e.getTarget(), - ttp, - cfg; - if(this.interceptTitles && t.title && Ext.isString(t.title)){ - ttp = t.title; - t.qtip = ttp; - t.removeAttribute("title"); - e.preventDefault(); - }else{ - cfg = this.tagConfig; - ttp = t.qtip || Ext.fly(t).getAttribute(cfg.attribute, cfg.namespace); - } - return ttp; - }, - - // private - onTargetOver : function(e){ - if(this.disabled){ - return; - } - this.targetXY = e.getXY(); - var t = e.getTarget(); - if(!t || t.nodeType !== 1 || t == document || t == document.body){ - return; - } - if(this.activeTarget && ((t == this.activeTarget.el) || Ext.fly(this.activeTarget.el).contains(t))){ - this.clearTimer('hide'); - this.show(); - return; - } - if(t && this.targets[t.id]){ - this.activeTarget = this.targets[t.id]; - this.activeTarget.el = t; - this.anchor = this.activeTarget.anchor; - if(this.anchor){ - this.anchorTarget = t; - } - this.delayShow(); - return; - } - var ttp, et = Ext.fly(t), cfg = this.tagConfig, ns = cfg.namespace; - if(ttp = this.getTipCfg(e)){ - var autoHide = et.getAttribute(cfg.hide, ns); - this.activeTarget = { - el: t, - text: ttp, - width: et.getAttribute(cfg.width, ns), - autoHide: autoHide != "user" && autoHide !== 'false', - title: et.getAttribute(cfg.title, ns), - cls: et.getAttribute(cfg.cls, ns), - align: et.getAttribute(cfg.align, ns) - - }; - this.anchor = et.getAttribute(cfg.anchor, ns); - if(this.anchor){ - this.anchorTarget = t; - } - this.delayShow(); - } - }, - - // private - onTargetOut : function(e){ - - // If moving within the current target, and it does not have a new tip, ignore the mouseout - if (this.activeTarget && e.within(this.activeTarget.el) && !this.getTipCfg(e)) { - return; - } - - this.clearTimer('show'); - if(this.autoHide !== false){ - this.delayHide(); - } - }, - - // inherit docs - showAt : function(xy){ - var t = this.activeTarget; - if(t){ - if(!this.rendered){ - this.render(Ext.getBody()); - this.activeTarget = t; - } - if(t.width){ - this.setWidth(t.width); - this.body.setWidth(this.adjustBodyWidth(t.width - this.getFrameWidth())); - this.measureWidth = false; - } else{ - this.measureWidth = true; - } - this.setTitle(t.title || ''); - this.body.update(t.text); - this.autoHide = t.autoHide; - this.dismissDelay = t.dismissDelay || this.dismissDelay; - if(this.lastCls){ - this.el.removeClass(this.lastCls); - delete this.lastCls; - } - if(t.cls){ - this.el.addClass(t.cls); - this.lastCls = t.cls; - } - if(this.anchor){ - this.constrainPosition = false; - }else if(t.align){ // TODO: this doesn't seem to work consistently - xy = this.el.getAlignToXY(t.el, t.align); - this.constrainPosition = false; - }else{ - this.constrainPosition = true; - } - } - Ext.QuickTip.superclass.showAt.call(this, xy); - }, - - // inherit docs - hide: function(){ - delete this.activeTarget; - Ext.QuickTip.superclass.hide.call(this); - } -}); -Ext.reg('quicktip', Ext.QuickTip);/** - * @class Ext.QuickTips - * Provides attractive and customizable tooltips for any element. The QuickTips - * singleton is used to configure and manage tooltips globally for multiple elements - * in a generic manner. To create individual tooltips with maximum customizability, - * you should consider either {@link Ext.Tip} or {@link Ext.ToolTip}. - * Quicktips can be configured via tag attributes directly in markup, or by - * registering quick tips programmatically via the {@link #register} method. - * The singleton's instance of {@link Ext.QuickTip} is available via - * {@link #getQuickTip}, and supports all the methods, and all the all the - * configuration properties of Ext.QuickTip. These settings will apply to all - * tooltips shown by the singleton. - * Below is the summary of the configuration properties which can be used. - * For detailed descriptions see {@link #getQuickTip} - * QuickTips singleton configs (all are optional) - * dismissDelay - * hideDelay - * maxWidth - * minWidth - * showDelay - * trackMouse - * Target element configs (optional unless otherwise noted) - * autoHide - * cls - * dismissDelay (overrides singleton value) - * target (required) - * text (required) - * title - * width - * Here is an example showing how some of these config options could be used: - * -// Init the singleton. Any tag-based quick tips will start working. -Ext.QuickTips.init(); - -// Apply a set of config properties to the singleton -Ext.apply(Ext.QuickTips.getQuickTip(), { - maxWidth: 200, - minWidth: 100, - showDelay: 50, - trackMouse: true -}); - -// Manually register a quick tip for a specific element -Ext.QuickTips.register({ - target: 'my-div', - title: 'My Tooltip', - text: 'This tooltip was added in code', - width: 100, - dismissDelay: 20 -}); - - * To register a quick tip in markup, you simply add one or more of the valid QuickTip attributes prefixed with - * the ext: namespace. The HTML element itself is automatically set as the quick tip target. Here is the summary - * of supported attributes (optional unless otherwise noted): - * hide: Specifying "user" is equivalent to setting autoHide = false. Any other value will be the - * same as autoHide = true. - * qclass: A CSS class to be applied to the quick tip (equivalent to the 'cls' target element config). - * qtip (required): The quick tip text (equivalent to the 'text' target element config). - * qtitle: The quick tip title (equivalent to the 'title' target element config). - * qwidth: The quick tip width (equivalent to the 'width' target element config). - * Here is an example of configuring an HTML element to display a tooltip from markup: - * -// Add a quick tip to an HTML button -<input type="button" value="OK" ext:qtitle="OK Button" ext:qwidth="100" - ext:qtip="This is a quick tip from markup!"></input> - - * @singleton - */ -Ext.QuickTips = function(){ - var tip, locks = []; - return { - /** - * Initialize the global QuickTips instance and prepare any quick tips. - * @param {Boolean} autoRender True to render the QuickTips container immediately to preload images. (Defaults to true) - */ - init : function(autoRender){ - if(!tip){ - if(!Ext.isReady){ - Ext.onReady(function(){ - Ext.QuickTips.init(autoRender); - }); - return; - } - tip = new Ext.QuickTip({elements:'header,body'}); - if(autoRender !== false){ - tip.render(Ext.getBody()); - } - } - }, - - /** - * Enable quick tips globally. - */ - enable : function(){ - if(tip){ - locks.pop(); - if(locks.length < 1){ - tip.enable(); - } - } - }, - - /** - * Disable quick tips globally. - */ - disable : function(){ - if(tip){ - tip.disable(); - } - locks.push(1); - }, - - /** - * Returns true if quick tips are enabled, else false. - * @return {Boolean} - */ - isEnabled : function(){ - return tip !== undefined && !tip.disabled; - }, - - /** - * Gets the global QuickTips instance. - */ - getQuickTip : function(){ - return tip; - }, - - /** - * Configures a new quick tip instance and assigns it to a target element. See - * {@link Ext.QuickTip#register} for details. - * @param {Object} config The config object - */ - register : function(){ - tip.register.apply(tip, arguments); - }, - - /** - * Removes any registered quick tip from the target element and destroys it. - * @param {String/HTMLElement/Element} el The element from which the quick tip is to be removed. - */ - unregister : function(){ - tip.unregister.apply(tip, arguments); - }, - - /** - * Alias of {@link #register}. - * @param {Object} config The config object - */ - tips :function(){ - tip.register.apply(tip, arguments); - } - } -}();/** - * @class Ext.tree.TreePanel - * @extends Ext.Panel - * The TreePanel provides tree-structured UI representation of tree-structured data. - * {@link Ext.tree.TreeNode TreeNode}s added to the TreePanel may each contain metadata - * used by your application in their {@link Ext.tree.TreeNode#attributes attributes} property. - * A TreePanel must have a {@link #root} node before it is rendered. This may either be - * specified using the {@link #root} config option, or using the {@link #setRootNode} method. - * An example of tree rendered to an existing div: -var tree = new Ext.tree.TreePanel({ - renderTo: 'tree-div', - useArrows: true, - autoScroll: true, - animate: true, - enableDD: true, - containerScroll: true, - border: false, - // auto create TreeLoader - dataUrl: 'get-nodes.php', - - root: { - nodeType: 'async', - text: 'Ext JS', - draggable: false, - id: 'source' - } -}); - -tree.getRootNode().expand(); - * - * The example above would work with a data packet similar to this: -[{ - "text": "adapter", - "id": "source\/adapter", - "cls": "folder" -}, { - "text": "dd", - "id": "source\/dd", - "cls": "folder" -}, { - "text": "debug.js", - "id": "source\/debug.js", - "leaf": true, - "cls": "file" -}] - * - * An example of tree within a Viewport: -new Ext.Viewport({ - layout: 'border', - items: [{ - region: 'west', - collapsible: true, - title: 'Navigation', - xtype: 'treepanel', - width: 200, - autoScroll: true, - split: true, - loader: new Ext.tree.TreeLoader(), - root: new Ext.tree.AsyncTreeNode({ - expanded: true, - children: [{ - text: 'Menu Option 1', - leaf: true - }, { - text: 'Menu Option 2', - leaf: true - }, { - text: 'Menu Option 3', - leaf: true - }] - }), - rootVisible: false, - listeners: { - click: function(n) { - Ext.Msg.alert('Navigation Tree Click', 'You clicked: "' + n.attributes.text + '"'); - } - } - }, { - region: 'center', - xtype: 'tabpanel', - // remaining code not shown ... - }] -}); - - * - * @cfg {Ext.tree.TreeNode} root The root node for the tree. - * @cfg {Boolean} rootVisible false to hide the root node (defaults to true) - * @cfg {Boolean} lines false to disable tree lines (defaults to true) - * @cfg {Boolean} enableDD true to enable drag and drop - * @cfg {Boolean} enableDrag true to enable just drag - * @cfg {Boolean} enableDrop true to enable just drop - * @cfg {Object} dragConfig Custom config to pass to the {@link Ext.tree.TreeDragZone} instance - * @cfg {Object} dropConfig Custom config to pass to the {@link Ext.tree.TreeDropZone} instance - * @cfg {String} ddGroup The DD group this TreePanel belongs to - * @cfg {Boolean} ddAppendOnly true if the tree should only allow append drops (use for trees which are sorted) - * @cfg {Boolean} ddScroll true to enable body scrolling - * @cfg {Boolean} containerScroll true to register this container with ScrollManager - * @cfg {Boolean} hlDrop false to disable node highlight on drop (defaults to the value of {@link Ext#enableFx}) - * @cfg {String} hlColor The color of the node highlight (defaults to 'C3DAF9') - * @cfg {Boolean} animate true to enable animated expand/collapse (defaults to the value of {@link Ext#enableFx}) - * @cfg {Boolean} singleExpand true if only 1 node per branch may be expanded - * @cfg {Object} selModel A tree selection model to use with this TreePanel (defaults to an {@link Ext.tree.DefaultSelectionModel}) - * @cfg {Boolean} trackMouseOver false to disable mouse over highlighting - * @cfg {Ext.tree.TreeLoader} loader A {@link Ext.tree.TreeLoader} for use with this TreePanel - * @cfg {String} pathSeparator The token used to separate sub-paths in path strings (defaults to '/') - * @cfg {Boolean} useArrows true to use Vista-style arrows in the tree (defaults to false) - * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}). - * - * @constructor - * @param {Object} config - * @xtype treepanel - */ -Ext.tree.TreePanel = Ext.extend(Ext.Panel, { - rootVisible : true, - animate : Ext.enableFx, - lines : true, - enableDD : false, - hlDrop : Ext.enableFx, - pathSeparator : '/', - - /** - * @cfg {Array} bubbleEvents - * An array of events that, when fired, should be bubbled to any parent container. - * See {@link Ext.util.Observable#enableBubble}. - * Defaults to []. - */ - bubbleEvents : [], - - initComponent : function(){ - Ext.tree.TreePanel.superclass.initComponent.call(this); - - if(!this.eventModel){ - this.eventModel = new Ext.tree.TreeEventModel(this); - } - - // initialize the loader - var l = this.loader; - if(!l){ - l = new Ext.tree.TreeLoader({ - dataUrl: this.dataUrl, - requestMethod: this.requestMethod - }); - }else if(Ext.isObject(l) && !l.load){ - l = new Ext.tree.TreeLoader(l); - } - this.loader = l; - - this.nodeHash = {}; - - /** - * The root node of this tree. - * @type Ext.tree.TreeNode - * @property root - */ - if(this.root){ - var r = this.root; - delete this.root; - this.setRootNode(r); - } - - - this.addEvents( - - /** - * @event append - * Fires when a new child node is appended to a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The newly appended node - * @param {Number} index The index of the newly appended node - */ - 'append', - /** - * @event remove - * Fires when a child node is removed from a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node removed - */ - 'remove', - /** - * @event movenode - * Fires when a node is moved to a new location in the tree - * @param {Tree} tree The owner tree - * @param {Node} node The node moved - * @param {Node} oldParent The old parent of this node - * @param {Node} newParent The new parent of this node - * @param {Number} index The index it was moved to - */ - 'movenode', - /** - * @event insert - * Fires when a new child node is inserted in a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node inserted - * @param {Node} refNode The child node the node was inserted before - */ - 'insert', - /** - * @event beforeappend - * Fires before a new child is appended to a node in this tree, return false to cancel the append. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be appended - */ - 'beforeappend', - /** - * @event beforeremove - * Fires before a child is removed from a node in this tree, return false to cancel the remove. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be removed - */ - 'beforeremove', - /** - * @event beforemovenode - * Fires before a node is moved to a new location in the tree. Return false to cancel the move. - * @param {Tree} tree The owner tree - * @param {Node} node The node being moved - * @param {Node} oldParent The parent of the node - * @param {Node} newParent The new parent the node is moving to - * @param {Number} index The index it is being moved to - */ - 'beforemovenode', - /** - * @event beforeinsert - * Fires before a new child is inserted in a node in this tree, return false to cancel the insert. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be inserted - * @param {Node} refNode The child node the node is being inserted before - */ - 'beforeinsert', - - /** - * @event beforeload - * Fires before a node is loaded, return false to cancel - * @param {Node} node The node being loaded - */ - 'beforeload', - /** - * @event load - * Fires when a node is loaded - * @param {Node} node The node that was loaded - */ - 'load', - /** - * @event textchange - * Fires when the text for a node is changed - * @param {Node} node The node - * @param {String} text The new text - * @param {String} oldText The old text - */ - 'textchange', - /** - * @event beforeexpandnode - * Fires before a node is expanded, return false to cancel. - * @param {Node} node The node - * @param {Boolean} deep - * @param {Boolean} anim - */ - 'beforeexpandnode', - /** - * @event beforecollapsenode - * Fires before a node is collapsed, return false to cancel. - * @param {Node} node The node - * @param {Boolean} deep - * @param {Boolean} anim - */ - 'beforecollapsenode', - /** - * @event expandnode - * Fires when a node is expanded - * @param {Node} node The node - */ - 'expandnode', - /** - * @event disabledchange - * Fires when the disabled status of a node changes - * @param {Node} node The node - * @param {Boolean} disabled - */ - 'disabledchange', - /** - * @event collapsenode - * Fires when a node is collapsed - * @param {Node} node The node - */ - 'collapsenode', - /** - * @event beforeclick - * Fires before click processing on a node. Return false to cancel the default action. - * @param {Node} node The node - * @param {Ext.EventObject} e The event object - */ - 'beforeclick', - /** - * @event click - * Fires when a node is clicked - * @param {Node} node The node - * @param {Ext.EventObject} e The event object - */ - 'click', - /** - * @event containerclick - * Fires when the tree container is clicked - * @param {Tree} this - * @param {Ext.EventObject} e The event object - */ - 'containerclick', - /** - * @event checkchange - * Fires when a node with a checkbox's checked property changes - * @param {Node} this This node - * @param {Boolean} checked - */ - 'checkchange', - /** - * @event beforedblclick - * Fires before double click processing on a node. Return false to cancel the default action. - * @param {Node} node The node - * @param {Ext.EventObject} e The event object - */ - 'beforedblclick', - /** - * @event dblclick - * Fires when a node is double clicked - * @param {Node} node The node - * @param {Ext.EventObject} e The event object - */ - 'dblclick', - /** - * @event containerdblclick - * Fires when the tree container is double clicked - * @param {Tree} this - * @param {Ext.EventObject} e The event object - */ - 'containerdblclick', - /** - * @event contextmenu - * Fires when a node is right clicked. To display a context menu in response to this - * event, first create a Menu object (see {@link Ext.menu.Menu} for details), then add - * a handler for this event: -new Ext.tree.TreePanel({ - title: 'My TreePanel', - root: new Ext.tree.AsyncTreeNode({ - text: 'The Root', - children: [ - { text: 'Child node 1', leaf: true }, - { text: 'Child node 2', leaf: true } - ] - }), - contextMenu: new Ext.menu.Menu({ - items: [{ - id: 'delete-node', - text: 'Delete Node' - }], - listeners: { - itemclick: function(item) { - switch (item.id) { - case 'delete-node': - var n = item.parentMenu.contextNode; - if (n.parentNode) { - n.remove(); - } - break; - } - } - } - }), - listeners: { - contextmenu: function(node, e) { -// Register the context node with the menu so that a Menu Item's handler function can access -// it via its {@link Ext.menu.BaseItem#parentMenu parentMenu} property. - node.select(); - var c = node.getOwnerTree().contextMenu; - c.contextNode = node; - c.showAt(e.getXY()); - } - } -}); - - * @param {Node} node The node - * @param {Ext.EventObject} e The event object - */ - 'contextmenu', - /** - * @event containercontextmenu - * Fires when the tree container is right clicked - * @param {Tree} this - * @param {Ext.EventObject} e The event object - */ - 'containercontextmenu', - /** - * @event beforechildrenrendered - * Fires right before the child nodes for a node are rendered - * @param {Node} node The node - */ - 'beforechildrenrendered', - /** - * @event startdrag - * Fires when a node starts being dragged - * @param {Ext.tree.TreePanel} this - * @param {Ext.tree.TreeNode} node - * @param {event} e The raw browser event - */ - 'startdrag', - /** - * @event enddrag - * Fires when a drag operation is complete - * @param {Ext.tree.TreePanel} this - * @param {Ext.tree.TreeNode} node - * @param {event} e The raw browser event - */ - 'enddrag', - /** - * @event dragdrop - * Fires when a dragged node is dropped on a valid DD target - * @param {Ext.tree.TreePanel} this - * @param {Ext.tree.TreeNode} node - * @param {DD} dd The dd it was dropped on - * @param {event} e The raw browser event - */ - 'dragdrop', - /** - * @event beforenodedrop - * Fires when a DD object is dropped on a node in this tree for preprocessing. Return false to cancel the drop. The dropEvent - * passed to handlers has the following properties: - * - * tree - The TreePanel - * target - The node being targeted for the drop - * data - The drag data from the drag source - * point - The point of the drop - append, above or below - * source - The drag source - * rawEvent - Raw mouse event - * dropNode - Drop node(s) provided by the source OR you can supply node(s) - * to be inserted by setting them on this object. - * cancel - Set this to true to cancel the drop. - * dropStatus - If the default drop action is cancelled but the drop is valid, setting this to true - * will prevent the animated 'repair' from appearing. - * - * @param {Object} dropEvent - */ - 'beforenodedrop', - /** - * @event nodedrop - * Fires after a DD object is dropped on a node in this tree. The dropEvent - * passed to handlers has the following properties: - * - * tree - The TreePanel - * target - The node being targeted for the drop - * data - The drag data from the drag source - * point - The point of the drop - append, above or below - * source - The drag source - * rawEvent - Raw mouse event - * dropNode - Dropped node(s). - * - * @param {Object} dropEvent - */ - 'nodedrop', - /** - * @event nodedragover - * Fires when a tree node is being targeted for a drag drop, return false to signal drop not allowed. The dragOverEvent - * passed to handlers has the following properties: - * - * tree - The TreePanel - * target - The node being targeted for the drop - * data - The drag data from the drag source - * point - The point of the drop - append, above or below - * source - The drag source - * rawEvent - Raw mouse event - * dropNode - Drop node(s) provided by the source. - * cancel - Set this to true to signal drop not allowed. - * - * @param {Object} dragOverEvent - */ - 'nodedragover' - ); - if(this.singleExpand){ - this.on('beforeexpandnode', this.restrictExpand, this); - } - }, - - // private - proxyNodeEvent : function(ename, a1, a2, a3, a4, a5, a6){ - if(ename == 'collapse' || ename == 'expand' || ename == 'beforecollapse' || ename == 'beforeexpand' || ename == 'move' || ename == 'beforemove'){ - ename = ename+'node'; - } - // args inline for performance while bubbling events - return this.fireEvent(ename, a1, a2, a3, a4, a5, a6); - }, - - - /** - * Returns this root node for this tree - * @return {Node} - */ - getRootNode : function(){ - return this.root; - }, - - /** - * Sets the root node for this tree. If the TreePanel has already rendered a root node, the - * previous root node (and all of its descendants) are destroyed before the new root node is rendered. - * @param {Node} node - * @return {Node} - */ - setRootNode : function(node){ - Ext.destroy(this.root); - if(!node.render){ // attributes passed - node = this.loader.createNode(node); - } - this.root = node; - node.ownerTree = this; - node.isRoot = true; - this.registerNode(node); - if(!this.rootVisible){ - var uiP = node.attributes.uiProvider; - node.ui = uiP ? new uiP(node) : new Ext.tree.RootTreeNodeUI(node); - } - if(this.innerCt){ - this.clearInnerCt(); - this.renderRoot(); - } - return node; - }, - - clearInnerCt : function(){ - this.innerCt.update(''); - }, - - // private - renderRoot : function(){ - this.root.render(); - if(!this.rootVisible){ - this.root.renderChildren(); - } - }, - - /** - * Gets a node in this tree by its id - * @param {String} id - * @return {Node} - */ - getNodeById : function(id){ - return this.nodeHash[id]; - }, - - // private - registerNode : function(node){ - this.nodeHash[node.id] = node; - }, - - // private - unregisterNode : function(node){ - delete this.nodeHash[node.id]; - }, - - // private - toString : function(){ - return '[Tree'+(this.id?' '+this.id:'')+']'; - }, - - // private - restrictExpand : function(node){ - var p = node.parentNode; - if(p){ - if(p.expandedChild && p.expandedChild.parentNode == p){ - p.expandedChild.collapse(); - } - p.expandedChild = node; - } - }, - - /** - * Retrieve an array of checked nodes, or an array of a specific attribute of checked nodes (e.g. 'id') - * @param {String} attribute (optional) Defaults to null (return the actual nodes) - * @param {TreeNode} startNode (optional) The node to start from, defaults to the root - * @return {Array} - */ - getChecked : function(a, startNode){ - startNode = startNode || this.root; - var r = []; - var f = function(){ - if(this.attributes.checked){ - r.push(!a ? this : (a == 'id' ? this.id : this.attributes[a])); - } - }; - startNode.cascade(f); - return r; - }, - - /** - * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel. - * @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel. - */ - getLoader : function(){ - return this.loader; - }, - - /** - * Expand all nodes - */ - expandAll : function(){ - this.root.expand(true); - }, - - /** - * Collapse all nodes - */ - collapseAll : function(){ - this.root.collapse(true); - }, - - /** - * Returns the selection model used by this TreePanel. - * @return {TreeSelectionModel} The selection model used by this TreePanel - */ - getSelectionModel : function(){ - if(!this.selModel){ - this.selModel = new Ext.tree.DefaultSelectionModel(); - } - return this.selModel; - }, - - /** - * Expands a specified path in this TreePanel. A path can be retrieved from a node with {@link Ext.data.Node#getPath} - * @param {String} path - * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info) - * @param {Function} callback (optional) The callback to call when the expand is complete. The callback will be called with - * (bSuccess, oLastNode) where bSuccess is if the expand was successful and oLastNode is the last node that was expanded. - */ - expandPath : function(path, attr, callback){ - attr = attr || 'id'; - var keys = path.split(this.pathSeparator); - var curNode = this.root; - if(curNode.attributes[attr] != keys[1]){ // invalid root - if(callback){ - callback(false, null); - } - return; - } - var index = 1; - var f = function(){ - if(++index == keys.length){ - if(callback){ - callback(true, curNode); - } - return; - } - var c = curNode.findChild(attr, keys[index]); - if(!c){ - if(callback){ - callback(false, curNode); - } - return; - } - curNode = c; - c.expand(false, false, f); - }; - curNode.expand(false, false, f); - }, - - /** - * Selects the node in this tree at the specified path. A path can be retrieved from a node with {@link Ext.data.Node#getPath} - * @param {String} path - * @param {String} attr (optional) The attribute used in the path (see {@link Ext.data.Node#getPath} for more info) - * @param {Function} callback (optional) The callback to call when the selection is complete. The callback will be called with - * (bSuccess, oSelNode) where bSuccess is if the selection was successful and oSelNode is the selected node. - */ - selectPath : function(path, attr, callback){ - attr = attr || 'id'; - var keys = path.split(this.pathSeparator), - v = keys.pop(); - if(keys.length > 1){ - var f = function(success, node){ - if(success && node){ - var n = node.findChild(attr, v); - if(n){ - n.select(); - if(callback){ - callback(true, n); - } - }else if(callback){ - callback(false, n); - } - }else{ - if(callback){ - callback(false, n); - } - } - }; - this.expandPath(keys.join(this.pathSeparator), attr, f); - }else{ - this.root.select(); - if(callback){ - callback(true, this.root); - } - } - }, - - /** - * Returns the underlying Element for this tree - * @return {Ext.Element} The Element - */ - getTreeEl : function(){ - return this.body; - }, - - // private - onRender : function(ct, position){ - Ext.tree.TreePanel.superclass.onRender.call(this, ct, position); - this.el.addClass('x-tree'); - this.innerCt = this.body.createChild({tag:'ul', - cls:'x-tree-root-ct ' + - (this.useArrows ? 'x-tree-arrows' : this.lines ? 'x-tree-lines' : 'x-tree-no-lines')}); - }, - - // private - initEvents : function(){ - Ext.tree.TreePanel.superclass.initEvents.call(this); - - if(this.containerScroll){ - Ext.dd.ScrollManager.register(this.body); - } - if((this.enableDD || this.enableDrop) && !this.dropZone){ - /** - * The dropZone used by this tree if drop is enabled (see {@link #enableDD} or {@link #enableDrop}) - * @property dropZone - * @type Ext.tree.TreeDropZone - */ - this.dropZone = new Ext.tree.TreeDropZone(this, this.dropConfig || { - ddGroup: this.ddGroup || 'TreeDD', appendOnly: this.ddAppendOnly === true - }); - } - if((this.enableDD || this.enableDrag) && !this.dragZone){ - /** - * The dragZone used by this tree if drag is enabled (see {@link #enableDD} or {@link #enableDrag}) - * @property dragZone - * @type Ext.tree.TreeDragZone - */ - this.dragZone = new Ext.tree.TreeDragZone(this, this.dragConfig || { - ddGroup: this.ddGroup || 'TreeDD', - scroll: this.ddScroll - }); - } - this.getSelectionModel().init(this); - }, - - // private - afterRender : function(){ - Ext.tree.TreePanel.superclass.afterRender.call(this); - this.renderRoot(); - }, - - beforeDestroy : function(){ - if(this.rendered){ - Ext.dd.ScrollManager.unregister(this.body); - Ext.destroy(this.dropZone, this.dragZone); - } - Ext.destroy(this.root, this.loader); - this.nodeHash = this.root = this.loader = null; - Ext.tree.TreePanel.superclass.beforeDestroy.call(this); - } - - /** - * @cfg {String/Number} activeItem - * @hide - */ - /** - * @cfg {Boolean} autoDestroy - * @hide - */ - /** - * @cfg {Object/String/Function} autoLoad - * @hide - */ - /** - * @cfg {Boolean} autoWidth - * @hide - */ - /** - * @cfg {Boolean/Number} bufferResize - * @hide - */ - /** - * @cfg {String} defaultType - * @hide - */ - /** - * @cfg {Object} defaults - * @hide - */ - /** - * @cfg {Boolean} hideBorders - * @hide - */ - /** - * @cfg {Mixed} items - * @hide - */ - /** - * @cfg {String} layout - * @hide - */ - /** - * @cfg {Object} layoutConfig - * @hide - */ - /** - * @cfg {Boolean} monitorResize - * @hide - */ - /** - * @property items - * @hide - */ - /** - * @method cascade - * @hide - */ - /** - * @method doLayout - * @hide - */ - /** - * @method find - * @hide - */ - /** - * @method findBy - * @hide - */ - /** - * @method findById - * @hide - */ - /** - * @method findByType - * @hide - */ - /** - * @method getComponent - * @hide - */ - /** - * @method getLayout - * @hide - */ - /** - * @method getUpdater - * @hide - */ - /** - * @method insert - * @hide - */ - /** - * @method load - * @hide - */ - /** - * @method remove - * @hide - */ - /** - * @event add - * @hide - */ - /** - * @method removeAll - * @hide - */ - /** - * @event afterLayout - * @hide - */ - /** - * @event beforeadd - * @hide - */ - /** - * @event beforeremove - * @hide - */ - /** - * @event remove - * @hide - */ - - - - /** - * @cfg {String} allowDomMove @hide - */ - /** - * @cfg {String} autoEl @hide - */ - /** - * @cfg {String} applyTo @hide - */ - /** - * @cfg {String} contentEl @hide - */ - /** - * @cfg {Mixed} data @hide - */ - /** - * @cfg {Mixed} tpl @hide - */ - /** - * @cfg {String} tplWriteMode @hide - */ - /** - * @cfg {String} disabledClass @hide - */ - /** - * @cfg {String} elements @hide - */ - /** - * @cfg {String} html @hide - */ - /** - * @cfg {Boolean} preventBodyReset - * @hide - */ - /** - * @property disabled - * @hide - */ - /** - * @method applyToMarkup - * @hide - */ - /** - * @method enable - * @hide - */ - /** - * @method disable - * @hide - */ - /** - * @method setDisabled - * @hide - */ -}); - -Ext.tree.TreePanel.nodeTypes = {}; - -Ext.reg('treepanel', Ext.tree.TreePanel);Ext.tree.TreeEventModel = function(tree){ - this.tree = tree; - this.tree.on('render', this.initEvents, this); -} - -Ext.tree.TreeEventModel.prototype = { - initEvents : function(){ - var t = this.tree; - - if(t.trackMouseOver !== false){ - t.mon(t.innerCt, { - scope: this, - mouseover: this.delegateOver, - mouseout: this.delegateOut - }); - } - t.mon(t.getTreeEl(), { - scope: this, - click: this.delegateClick, - dblclick: this.delegateDblClick, - contextmenu: this.delegateContextMenu - }); - }, - - getNode : function(e){ - var t; - if(t = e.getTarget('.x-tree-node-el', 10)){ - var id = Ext.fly(t, '_treeEvents').getAttribute('tree-node-id', 'ext'); - if(id){ - return this.tree.getNodeById(id); - } - } - return null; - }, - - getNodeTarget : function(e){ - var t = e.getTarget('.x-tree-node-icon', 1); - if(!t){ - t = e.getTarget('.x-tree-node-el', 6); - } - return t; - }, - - delegateOut : function(e, t){ - if(!this.beforeEvent(e)){ - return; - } - if(e.getTarget('.x-tree-ec-icon', 1)){ - var n = this.getNode(e); - this.onIconOut(e, n); - if(n == this.lastEcOver){ - delete this.lastEcOver; - } - } - if((t = this.getNodeTarget(e)) && !e.within(t, true)){ - this.onNodeOut(e, this.getNode(e)); - } - }, - - delegateOver : function(e, t){ - if(!this.beforeEvent(e)){ - return; - } - if(Ext.isGecko && !this.trackingDoc){ // prevent hanging in FF - Ext.getBody().on('mouseover', this.trackExit, this); - this.trackingDoc = true; - } - if(this.lastEcOver){ // prevent hung highlight - this.onIconOut(e, this.lastEcOver); - delete this.lastEcOver; - } - if(e.getTarget('.x-tree-ec-icon', 1)){ - this.lastEcOver = this.getNode(e); - this.onIconOver(e, this.lastEcOver); - } - if(t = this.getNodeTarget(e)){ - this.onNodeOver(e, this.getNode(e)); - } - }, - - trackExit : function(e){ - if(this.lastOverNode){ - if(this.lastOverNode.ui && !e.within(this.lastOverNode.ui.getEl())){ - this.onNodeOut(e, this.lastOverNode); - } - delete this.lastOverNode; - Ext.getBody().un('mouseover', this.trackExit, this); - this.trackingDoc = false; - } - - }, - - delegateClick : function(e, t){ - if(this.beforeEvent(e)){ - if(e.getTarget('input[type=checkbox]', 1)){ - this.onCheckboxClick(e, this.getNode(e)); - }else if(e.getTarget('.x-tree-ec-icon', 1)){ - this.onIconClick(e, this.getNode(e)); - }else if(this.getNodeTarget(e)){ - this.onNodeClick(e, this.getNode(e)); - }else{ - this.onContainerEvent(e, 'click'); - } - } - }, - - delegateDblClick : function(e, t){ - if(this.beforeEvent(e)){ - if(this.getNodeTarget(e)){ - this.onNodeDblClick(e, this.getNode(e)); - }else{ - this.onContainerEvent(e, 'dblclick'); - } - } - }, - - delegateContextMenu : function(e, t){ - if(this.beforeEvent(e)){ - if(this.getNodeTarget(e)){ - this.onNodeContextMenu(e, this.getNode(e)); - }else{ - this.onContainerEvent(e, 'contextmenu'); - } - } - }, - - onContainerEvent: function(e, type){ - this.tree.fireEvent('container' + type, this.tree, e); - }, - - onNodeClick : function(e, node){ - node.ui.onClick(e); - }, - - onNodeOver : function(e, node){ - this.lastOverNode = node; - node.ui.onOver(e); - }, - - onNodeOut : function(e, node){ - node.ui.onOut(e); - }, - - onIconOver : function(e, node){ - node.ui.addClass('x-tree-ec-over'); - }, - - onIconOut : function(e, node){ - node.ui.removeClass('x-tree-ec-over'); - }, - - onIconClick : function(e, node){ - node.ui.ecClick(e); - }, - - onCheckboxClick : function(e, node){ - node.ui.onCheckChange(e); - }, - - onNodeDblClick : function(e, node){ - node.ui.onDblClick(e); - }, - - onNodeContextMenu : function(e, node){ - node.ui.onContextMenu(e); - }, - - beforeEvent : function(e){ - var node = this.getNode(e); - if(this.disabled || !node || !node.ui){ - e.stopEvent(); - return false; - } - return true; - }, - - disable: function(){ - this.disabled = true; - }, - - enable: function(){ - this.disabled = false; - } -};/** - * @class Ext.tree.DefaultSelectionModel - * @extends Ext.util.Observable - * The default single selection for a TreePanel. - */ -Ext.tree.DefaultSelectionModel = function(config){ - this.selNode = null; - - this.addEvents( - /** - * @event selectionchange - * Fires when the selected node changes - * @param {DefaultSelectionModel} this - * @param {TreeNode} node the new selection - */ - 'selectionchange', - - /** - * @event beforeselect - * Fires before the selected node changes, return false to cancel the change - * @param {DefaultSelectionModel} this - * @param {TreeNode} node the new selection - * @param {TreeNode} node the old selection - */ - 'beforeselect' - ); - - Ext.apply(this, config); - Ext.tree.DefaultSelectionModel.superclass.constructor.call(this); -}; - -Ext.extend(Ext.tree.DefaultSelectionModel, Ext.util.Observable, { - init : function(tree){ - this.tree = tree; - tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); - tree.on('click', this.onNodeClick, this); - }, - - onNodeClick : function(node, e){ - this.select(node); - }, - - /** - * Select a node. - * @param {TreeNode} node The node to select - * @return {TreeNode} The selected node - */ - select : function(node, /* private*/ selectNextNode){ - // If node is hidden, select the next node in whatever direction was being moved in. - if (!Ext.fly(node.ui.wrap).isVisible() && selectNextNode) { - return selectNextNode.call(this, node); - } - var last = this.selNode; - if(node == last){ - node.ui.onSelectedChange(true); - }else if(this.fireEvent('beforeselect', this, node, last) !== false){ - if(last && last.ui){ - last.ui.onSelectedChange(false); - } - this.selNode = node; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, node, last); - } - return node; - }, - - /** - * Deselect a node. - * @param {TreeNode} node The node to unselect - * @param {Boolean} silent True to stop the selectionchange event from firing. - */ - unselect : function(node, silent){ - if(this.selNode == node){ - this.clearSelections(silent); - } - }, - - /** - * Clear all selections - * @param {Boolean} silent True to stop the selectionchange event from firing. - */ - clearSelections : function(silent){ - var n = this.selNode; - if(n){ - n.ui.onSelectedChange(false); - this.selNode = null; - if(silent !== true){ - this.fireEvent('selectionchange', this, null); - } - } - return n; - }, - - /** - * Get the selected node - * @return {TreeNode} The selected node - */ - getSelectedNode : function(){ - return this.selNode; - }, - - /** - * Returns true if the node is selected - * @param {TreeNode} node The node to check - * @return {Boolean} - */ - isSelected : function(node){ - return this.selNode == node; - }, - - /** - * Selects the node above the selected node in the tree, intelligently walking the nodes - * @return TreeNode The new selection - */ - selectPrevious : function(/* private */ s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; - } - // Here we pass in the current function to select to indicate the direction we're moving - var ps = s.previousSibling; - if(ps){ - if(!ps.isExpanded() || ps.childNodes.length < 1){ - return this.select(ps, this.selectPrevious); - } else{ - var lc = ps.lastChild; - while(lc && lc.isExpanded() && Ext.fly(lc.ui.wrap).isVisible() && lc.childNodes.length > 0){ - lc = lc.lastChild; - } - return this.select(lc, this.selectPrevious); - } - } else if(s.parentNode && (this.tree.rootVisible || !s.parentNode.isRoot)){ - return this.select(s.parentNode, this.selectPrevious); - } - return null; - }, - - /** - * Selects the node above the selected node in the tree, intelligently walking the nodes - * @return TreeNode The new selection - */ - selectNext : function(/* private */ s){ - if(!(s = s || this.selNode || this.lastSelNode)){ - return null; - } - // Here we pass in the current function to select to indicate the direction we're moving - if(s.firstChild && s.isExpanded() && Ext.fly(s.ui.wrap).isVisible()){ - return this.select(s.firstChild, this.selectNext); - }else if(s.nextSibling){ - return this.select(s.nextSibling, this.selectNext); - }else if(s.parentNode){ - var newS = null; - s.parentNode.bubble(function(){ - if(this.nextSibling){ - newS = this.getOwnerTree().selModel.select(this.nextSibling, this.selectNext); - return false; - } - }); - return newS; - } - return null; - }, - - onKeyDown : function(e){ - var s = this.selNode || this.lastSelNode; - // undesirable, but required - var sm = this; - if(!s){ - return; - } - var k = e.getKey(); - switch(k){ - case e.DOWN: - e.stopEvent(); - this.selectNext(); - break; - case e.UP: - e.stopEvent(); - this.selectPrevious(); - break; - case e.RIGHT: - e.preventDefault(); - if(s.hasChildNodes()){ - if(!s.isExpanded()){ - s.expand(); - }else if(s.firstChild){ - this.select(s.firstChild, e); - } - } - break; - case e.LEFT: - e.preventDefault(); - if(s.hasChildNodes() && s.isExpanded()){ - s.collapse(); - }else if(s.parentNode && (this.tree.rootVisible || s.parentNode != this.tree.getRootNode())){ - this.select(s.parentNode, e); - } - break; - }; - } -}); - -/** - * @class Ext.tree.MultiSelectionModel - * @extends Ext.util.Observable - * Multi selection for a TreePanel. - */ -Ext.tree.MultiSelectionModel = function(config){ - this.selNodes = []; - this.selMap = {}; - this.addEvents( - /** - * @event selectionchange - * Fires when the selected nodes change - * @param {MultiSelectionModel} this - * @param {Array} nodes Array of the selected nodes - */ - 'selectionchange' - ); - Ext.apply(this, config); - Ext.tree.MultiSelectionModel.superclass.constructor.call(this); -}; - -Ext.extend(Ext.tree.MultiSelectionModel, Ext.util.Observable, { - init : function(tree){ - this.tree = tree; - tree.mon(tree.getTreeEl(), 'keydown', this.onKeyDown, this); - tree.on('click', this.onNodeClick, this); - }, - - onNodeClick : function(node, e){ - if(e.ctrlKey && this.isSelected(node)){ - this.unselect(node); - }else{ - this.select(node, e, e.ctrlKey); - } - }, - - /** - * Select a node. - * @param {TreeNode} node The node to select - * @param {EventObject} e (optional) An event associated with the selection - * @param {Boolean} keepExisting True to retain existing selections - * @return {TreeNode} The selected node - */ - select : function(node, e, keepExisting){ - if(keepExisting !== true){ - this.clearSelections(true); - } - if(this.isSelected(node)){ - this.lastSelNode = node; - return node; - } - this.selNodes.push(node); - this.selMap[node.id] = node; - this.lastSelNode = node; - node.ui.onSelectedChange(true); - this.fireEvent('selectionchange', this, this.selNodes); - return node; - }, - - /** - * Deselect a node. - * @param {TreeNode} node The node to unselect - */ - unselect : function(node){ - if(this.selMap[node.id]){ - node.ui.onSelectedChange(false); - var sn = this.selNodes; - var index = sn.indexOf(node); - if(index != -1){ - this.selNodes.splice(index, 1); - } - delete this.selMap[node.id]; - this.fireEvent('selectionchange', this, this.selNodes); - } - }, - - /** - * Clear all selections - */ - clearSelections : function(suppressEvent){ - var sn = this.selNodes; - if(sn.length > 0){ - for(var i = 0, len = sn.length; i < len; i++){ - sn[i].ui.onSelectedChange(false); - } - this.selNodes = []; - this.selMap = {}; - if(suppressEvent !== true){ - this.fireEvent('selectionchange', this, this.selNodes); - } - } - }, - - /** - * Returns true if the node is selected - * @param {TreeNode} node The node to check - * @return {Boolean} - */ - isSelected : function(node){ - return this.selMap[node.id] ? true : false; - }, - - /** - * Returns an array of the selected nodes - * @return {Array} - */ - getSelectedNodes : function(){ - return this.selNodes; - }, - - onKeyDown : Ext.tree.DefaultSelectionModel.prototype.onKeyDown, - - selectNext : Ext.tree.DefaultSelectionModel.prototype.selectNext, - - selectPrevious : Ext.tree.DefaultSelectionModel.prototype.selectPrevious -});/** - * @class Ext.data.Tree - * @extends Ext.util.Observable - * Represents a tree data structure and bubbles all the events for its nodes. The nodes - * in the tree have most standard DOM functionality. - * @constructor - * @param {Node} root (optional) The root node - */ -Ext.data.Tree = function(root){ - this.nodeHash = {}; - /** - * The root node for this tree - * @type Node - */ - this.root = null; - if(root){ - this.setRootNode(root); - } - this.addEvents( - /** - * @event append - * Fires when a new child node is appended to a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The newly appended node - * @param {Number} index The index of the newly appended node - */ - "append", - /** - * @event remove - * Fires when a child node is removed from a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node removed - */ - "remove", - /** - * @event move - * Fires when a node is moved to a new location in the tree - * @param {Tree} tree The owner tree - * @param {Node} node The node moved - * @param {Node} oldParent The old parent of this node - * @param {Node} newParent The new parent of this node - * @param {Number} index The index it was moved to - */ - "move", - /** - * @event insert - * Fires when a new child node is inserted in a node in this tree. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node inserted - * @param {Node} refNode The child node the node was inserted before - */ - "insert", - /** - * @event beforeappend - * Fires before a new child is appended to a node in this tree, return false to cancel the append. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be appended - */ - "beforeappend", - /** - * @event beforeremove - * Fires before a child is removed from a node in this tree, return false to cancel the remove. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be removed - */ - "beforeremove", - /** - * @event beforemove - * Fires before a node is moved to a new location in the tree. Return false to cancel the move. - * @param {Tree} tree The owner tree - * @param {Node} node The node being moved - * @param {Node} oldParent The parent of the node - * @param {Node} newParent The new parent the node is moving to - * @param {Number} index The index it is being moved to - */ - "beforemove", - /** - * @event beforeinsert - * Fires before a new child is inserted in a node in this tree, return false to cancel the insert. - * @param {Tree} tree The owner tree - * @param {Node} parent The parent node - * @param {Node} node The child node to be inserted - * @param {Node} refNode The child node the node is being inserted before - */ - "beforeinsert" - ); - - Ext.data.Tree.superclass.constructor.call(this); -}; - -Ext.extend(Ext.data.Tree, Ext.util.Observable, { - /** - * @cfg {String} pathSeparator - * The token used to separate paths in node ids (defaults to '/'). - */ - pathSeparator: "/", - - // private - proxyNodeEvent : function(){ - return this.fireEvent.apply(this, arguments); - }, - - /** - * Returns the root node for this tree. - * @return {Node} - */ - getRootNode : function(){ - return this.root; - }, - - /** - * Sets the root node for this tree. - * @param {Node} node - * @return {Node} - */ - setRootNode : function(node){ - this.root = node; - node.ownerTree = this; - node.isRoot = true; - this.registerNode(node); - return node; - }, - - /** - * Gets a node in this tree by its id. - * @param {String} id - * @return {Node} - */ - getNodeById : function(id){ - return this.nodeHash[id]; - }, - - // private - registerNode : function(node){ - this.nodeHash[node.id] = node; - }, - - // private - unregisterNode : function(node){ - delete this.nodeHash[node.id]; - }, - - toString : function(){ - return "[Tree"+(this.id?" "+this.id:"")+"]"; - } -}); - -/** - * @class Ext.data.Node - * @extends Ext.util.Observable - * @cfg {Boolean} leaf true if this node is a leaf and does not have children - * @cfg {String} id The id for this node. If one is not specified, one is generated. - * @constructor - * @param {Object} attributes The attributes/config for the node - */ -Ext.data.Node = function(attributes){ - /** - * The attributes supplied for the node. You can use this property to access any custom attributes you supplied. - * @type {Object} - */ - this.attributes = attributes || {}; - this.leaf = this.attributes.leaf; - /** - * The node id. @type String - */ - this.id = this.attributes.id; - if(!this.id){ - this.id = Ext.id(null, "xnode-"); - this.attributes.id = this.id; - } - /** - * All child nodes of this node. @type Array - */ - this.childNodes = []; - if(!this.childNodes.indexOf){ // indexOf is a must - this.childNodes.indexOf = function(o){ - for(var i = 0, len = this.length; i < len; i++){ - if(this[i] == o){ - return i; - } - } - return -1; - }; - } - /** - * The parent node for this node. @type Node - */ - this.parentNode = null; - /** - * The first direct child node of this node, or null if this node has no child nodes. @type Node - */ - this.firstChild = null; - /** - * The last direct child node of this node, or null if this node has no child nodes. @type Node - */ - this.lastChild = null; - /** - * The node immediately preceding this node in the tree, or null if there is no sibling node. @type Node - */ - this.previousSibling = null; - /** - * The node immediately following this node in the tree, or null if there is no sibling node. @type Node - */ - this.nextSibling = null; - - this.addEvents({ - /** - * @event append - * Fires when a new child node is appended - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The newly appended node - * @param {Number} index The index of the newly appended node - */ - "append" : true, - /** - * @event remove - * Fires when a child node is removed - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The removed node - */ - "remove" : true, - /** - * @event move - * Fires when this node is moved to a new location in the tree - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} oldParent The old parent of this node - * @param {Node} newParent The new parent of this node - * @param {Number} index The index it was moved to - */ - "move" : true, - /** - * @event insert - * Fires when a new child node is inserted. - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The child node inserted - * @param {Node} refNode The child node the node was inserted before - */ - "insert" : true, - /** - * @event beforeappend - * Fires before a new child is appended, return false to cancel the append. - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The child node to be appended - */ - "beforeappend" : true, - /** - * @event beforeremove - * Fires before a child is removed, return false to cancel the remove. - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The child node to be removed - */ - "beforeremove" : true, - /** - * @event beforemove - * Fires before this node is moved to a new location in the tree. Return false to cancel the move. - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} oldParent The parent of this node - * @param {Node} newParent The new parent this node is moving to - * @param {Number} index The index it is being moved to - */ - "beforemove" : true, - /** - * @event beforeinsert - * Fires before a new child is inserted, return false to cancel the insert. - * @param {Tree} tree The owner tree - * @param {Node} this This node - * @param {Node} node The child node to be inserted - * @param {Node} refNode The child node the node is being inserted before - */ - "beforeinsert" : true - }); - this.listeners = this.attributes.listeners; - Ext.data.Node.superclass.constructor.call(this); -}; - -Ext.extend(Ext.data.Node, Ext.util.Observable, { - // private - fireEvent : function(evtName){ - // first do standard event for this node - if(Ext.data.Node.superclass.fireEvent.apply(this, arguments) === false){ - return false; - } - // then bubble it up to the tree if the event wasn't cancelled - var ot = this.getOwnerTree(); - if(ot){ - if(ot.proxyNodeEvent.apply(ot, arguments) === false){ - return false; - } - } - return true; - }, - - /** - * Returns true if this node is a leaf - * @return {Boolean} - */ - isLeaf : function(){ - return this.leaf === true; - }, - - // private - setFirstChild : function(node){ - this.firstChild = node; - }, - - //private - setLastChild : function(node){ - this.lastChild = node; - }, - - - /** - * Returns true if this node is the last child of its parent - * @return {Boolean} - */ - isLast : function(){ - return (!this.parentNode ? true : this.parentNode.lastChild == this); - }, - - /** - * Returns true if this node is the first child of its parent - * @return {Boolean} - */ - isFirst : function(){ - return (!this.parentNode ? true : this.parentNode.firstChild == this); - }, - - /** - * Returns true if this node has one or more child nodes, else false. - * @return {Boolean} - */ - hasChildNodes : function(){ - return !this.isLeaf() && this.childNodes.length > 0; - }, - - /** - * Returns true if this node has one or more child nodes, or if the expandable - * node attribute is explicitly specified as true (see {@link #attributes}), otherwise returns false. - * @return {Boolean} - */ - isExpandable : function(){ - return this.attributes.expandable || this.hasChildNodes(); - }, - - /** - * Insert node(s) as the last child node of this node. - * @param {Node/Array} node The node or Array of nodes to append - * @return {Node} The appended node if single append, or null if an array was passed - */ - appendChild : function(node){ - var multi = false; - if(Ext.isArray(node)){ - multi = node; - }else if(arguments.length > 1){ - multi = arguments; - } - // if passed an array or multiple args do them one by one - if(multi){ - for(var i = 0, len = multi.length; i < len; i++) { - this.appendChild(multi[i]); - } - }else{ - if(this.fireEvent("beforeappend", this.ownerTree, this, node) === false){ - return false; - } - var index = this.childNodes.length; - var oldParent = node.parentNode; - // it's a move, make sure we move it cleanly - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index) === false){ - return false; - } - oldParent.removeChild(node); - } - index = this.childNodes.length; - if(index === 0){ - this.setFirstChild(node); - } - this.childNodes.push(node); - node.parentNode = this; - var ps = this.childNodes[index-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; - } - node.nextSibling = null; - this.setLastChild(node); - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("append", this.ownerTree, this, node, index); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, index); - } - return node; - } - }, - - /** - * Removes a child node from this node. - * @param {Node} node The node to remove - * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. - * @return {Node} The removed node - */ - removeChild : function(node, destroy){ - var index = this.childNodes.indexOf(node); - if(index == -1){ - return false; - } - if(this.fireEvent("beforeremove", this.ownerTree, this, node) === false){ - return false; - } - - // remove it from childNodes collection - this.childNodes.splice(index, 1); - - // update siblings - if(node.previousSibling){ - node.previousSibling.nextSibling = node.nextSibling; - } - if(node.nextSibling){ - node.nextSibling.previousSibling = node.previousSibling; - } - - // update child refs - if(this.firstChild == node){ - this.setFirstChild(node.nextSibling); - } - if(this.lastChild == node){ - this.setLastChild(node.previousSibling); - } - - node.clear(); - this.fireEvent("remove", this.ownerTree, this, node); - if(destroy){ - node.destroy(); - } - return node; - }, - - // private - clear : function(destroy){ - // clear any references from the node - this.setOwnerTree(null, destroy); - this.parentNode = this.previousSibling = this.nextSibling = null - if(destroy){ - this.firstChild = this.lastChild = null; - } - }, - - /** - * Destroys the node. - */ - destroy : function(){ - this.purgeListeners(); - this.clear(true); - Ext.each(this.childNodes, function(n){ - n.destroy(); - }); - this.childNodes = null; - }, - - /** - * Inserts the first node before the second node in this nodes childNodes collection. - * @param {Node} node The node to insert - * @param {Node} refNode The node to insert before (if null the node is appended) - * @return {Node} The inserted node - */ - insertBefore : function(node, refNode){ - if(!refNode){ // like standard Dom, refNode can be null for append - return this.appendChild(node); - } - // nothing to do - if(node == refNode){ - return false; - } - - if(this.fireEvent("beforeinsert", this.ownerTree, this, node, refNode) === false){ - return false; - } - var index = this.childNodes.indexOf(refNode); - var oldParent = node.parentNode; - var refIndex = index; - - // when moving internally, indexes will change after remove - if(oldParent == this && this.childNodes.indexOf(node) < index){ - refIndex--; - } - - // it's a move, make sure we move it cleanly - if(oldParent){ - if(node.fireEvent("beforemove", node.getOwnerTree(), node, oldParent, this, index, refNode) === false){ - return false; - } - oldParent.removeChild(node); - } - if(refIndex === 0){ - this.setFirstChild(node); - } - this.childNodes.splice(refIndex, 0, node); - node.parentNode = this; - var ps = this.childNodes[refIndex-1]; - if(ps){ - node.previousSibling = ps; - ps.nextSibling = node; - }else{ - node.previousSibling = null; - } - node.nextSibling = refNode; - refNode.previousSibling = node; - node.setOwnerTree(this.getOwnerTree()); - this.fireEvent("insert", this.ownerTree, this, node, refNode); - if(oldParent){ - node.fireEvent("move", this.ownerTree, node, oldParent, this, refIndex, refNode); - } - return node; - }, - - /** - * Removes this node from its parent - * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. - * @return {Node} this - */ - remove : function(destroy){ - this.parentNode.removeChild(this, destroy); - return this; - }, - - /** - * Removes all child nodes from this node. - * @param {Boolean} destroy true to destroy the node upon removal. Defaults to false. - * @return {Node} this - */ - removeAll : function(destroy){ - var cn = this.childNodes, - n; - while((n = cn[0])){ - this.removeChild(n, destroy); - } - return this; - }, - - /** - * Returns the child node at the specified index. - * @param {Number} index - * @return {Node} - */ - item : function(index){ - return this.childNodes[index]; - }, - - /** - * Replaces one child node in this node with another. - * @param {Node} newChild The replacement node - * @param {Node} oldChild The node to replace - * @return {Node} The replaced node - */ - replaceChild : function(newChild, oldChild){ - var s = oldChild ? oldChild.nextSibling : null; - this.removeChild(oldChild); - this.insertBefore(newChild, s); - return oldChild; - }, - - /** - * Returns the index of a child node - * @param {Node} node - * @return {Number} The index of the node or -1 if it was not found - */ - indexOf : function(child){ - return this.childNodes.indexOf(child); - }, - - /** - * Returns the tree this node is in. - * @return {Tree} - */ - getOwnerTree : function(){ - // if it doesn't have one, look for one - if(!this.ownerTree){ - var p = this; - while(p){ - if(p.ownerTree){ - this.ownerTree = p.ownerTree; - break; - } - p = p.parentNode; - } - } - return this.ownerTree; - }, - - /** - * Returns depth of this node (the root node has a depth of 0) - * @return {Number} - */ - getDepth : function(){ - var depth = 0; - var p = this; - while(p.parentNode){ - ++depth; - p = p.parentNode; - } - return depth; - }, - - // private - setOwnerTree : function(tree, destroy){ - // if it is a move, we need to update everyone - if(tree != this.ownerTree){ - if(this.ownerTree){ - this.ownerTree.unregisterNode(this); - } - this.ownerTree = tree; - // If we're destroying, we don't need to recurse since it will be called on each child node - if(destroy !== true){ - Ext.each(this.childNodes, function(n){ - n.setOwnerTree(tree); - }); - } - if(tree){ - tree.registerNode(this); - } - } - }, - - /** - * Changes the id of this node. - * @param {String} id The new id for the node. - */ - setId: function(id){ - if(id !== this.id){ - var t = this.ownerTree; - if(t){ - t.unregisterNode(this); - } - this.id = this.attributes.id = id; - if(t){ - t.registerNode(this); - } - this.onIdChange(id); - } - }, - - // private - onIdChange: Ext.emptyFn, - - /** - * Returns the path for this node. The path can be used to expand or select this node programmatically. - * @param {String} attr (optional) The attr to use for the path (defaults to the node's id) - * @return {String} The path - */ - getPath : function(attr){ - attr = attr || "id"; - var p = this.parentNode; - var b = [this.attributes[attr]]; - while(p){ - b.unshift(p.attributes[attr]); - p = p.parentNode; - } - var sep = this.getOwnerTree().pathSeparator; - return sep + b.join(sep); - }, - - /** - * Bubbles up the tree from this node, calling the specified function with each node. The arguments to the function - * will be the args provided or the current node. If the function returns false at any point, - * the bubble is stopped. - * @param {Function} fn The function to call - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. - * @param {Array} args (optional) The args to call the function with (default to passing the current Node) - */ - bubble : function(fn, scope, args){ - var p = this; - while(p){ - if(fn.apply(scope || p, args || [p]) === false){ - break; - } - p = p.parentNode; - } - }, - - /** - * Cascades down the tree from this node, calling the specified function with each node. The arguments to the function - * will be the args provided or the current node. If the function returns false at any point, - * the cascade is stopped on that branch. - * @param {Function} fn The function to call - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. - * @param {Array} args (optional) The args to call the function with (default to passing the current Node) - */ - cascade : function(fn, scope, args){ - if(fn.apply(scope || this, args || [this]) !== false){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].cascade(fn, scope, args); - } - } - }, - - /** - * Interates the child nodes of this node, calling the specified function with each node. The arguments to the function - * will be the args provided or the current node. If the function returns false at any point, - * the iteration stops. - * @param {Function} fn The function to call - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node in the iteration. - * @param {Array} args (optional) The args to call the function with (default to passing the current Node) - */ - eachChild : function(fn, scope, args){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - if(fn.apply(scope || this, args || [cs[i]]) === false){ - break; - } - } - }, - - /** - * Finds the first child that has the attribute with the specified value. - * @param {String} attribute The attribute name - * @param {Mixed} value The value to search for - * @return {Node} The found child or null if none was found - */ - findChild : function(attribute, value){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - if(cs[i].attributes[attribute] == value){ - return cs[i]; - } - } - return null; - }, - - /** - * Finds the first child by a custom function. The child matches if the function passed returns true. - * @param {Function} fn A function which must return true if the passed Node is the required Node. - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the Node being tested. - * @return {Node} The found child or null if none was found - */ - findChildBy : function(fn, scope){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - if(fn.call(scope||cs[i], cs[i]) === true){ - return cs[i]; - } - } - return null; - }, - - /** - * Sorts this nodes children using the supplied sort function. - * @param {Function} fn A function which, when passed two Nodes, returns -1, 0 or 1 depending upon required sort order. - * @param {Object} scope (optional)The scope (this reference) in which the function is executed. Defaults to the browser window. - */ - sort : function(fn, scope){ - var cs = this.childNodes; - var len = cs.length; - if(len > 0){ - var sortFn = scope ? function(){fn.apply(scope, arguments);} : fn; - cs.sort(sortFn); - for(var i = 0; i < len; i++){ - var n = cs[i]; - n.previousSibling = cs[i-1]; - n.nextSibling = cs[i+1]; - if(i === 0){ - this.setFirstChild(n); - } - if(i == len-1){ - this.setLastChild(n); - } - } - } - }, - - /** - * Returns true if this node is an ancestor (at any point) of the passed node. - * @param {Node} node - * @return {Boolean} - */ - contains : function(node){ - return node.isAncestor(this); - }, - - /** - * Returns true if the passed node is an ancestor (at any point) of this node. - * @param {Node} node - * @return {Boolean} - */ - isAncestor : function(node){ - var p = this.parentNode; - while(p){ - if(p == node){ - return true; - } - p = p.parentNode; - } - return false; - }, - - toString : function(){ - return "[Node"+(this.id?" "+this.id:"")+"]"; - } -});/** - * @class Ext.tree.TreeNode - * @extends Ext.data.Node - * @cfg {String} text The text for this node - * @cfg {Boolean} expanded true to start the node expanded - * @cfg {Boolean} allowDrag False to make this node undraggable if {@link #draggable} = true (defaults to true) - * @cfg {Boolean} allowDrop False if this node cannot have child nodes dropped on it (defaults to true) - * @cfg {Boolean} disabled true to start the node disabled - * @cfg {String} icon The path to an icon for the node. The preferred way to do this - * is to use the cls or iconCls attributes and add the icon via a CSS background image. - * @cfg {String} cls A css class to be added to the node - * @cfg {String} iconCls A css class to be added to the nodes icon element for applying css background images - * @cfg {String} href URL of the link used for the node (defaults to #) - * @cfg {String} hrefTarget target frame for the link - * @cfg {Boolean} hidden True to render hidden. (Defaults to false). - * @cfg {String} qtip An Ext QuickTip for the node - * @cfg {Boolean} expandable If set to true, the node will always show a plus/minus icon, even when empty - * @cfg {String} qtipCfg An Ext QuickTip config for the node (used instead of qtip) - * @cfg {Boolean} singleClickExpand True for single click expand on this node - * @cfg {Function} uiProvider A UI class to use for this node (defaults to Ext.tree.TreeNodeUI) - * @cfg {Boolean} checked True to render a checked checkbox for this node, false to render an unchecked checkbox - * (defaults to undefined with no checkbox rendered) - * @cfg {Boolean} draggable True to make this node draggable (defaults to false) - * @cfg {Boolean} isTarget False to not allow this node to act as a drop target (defaults to true) - * @cfg {Boolean} allowChildren False to not allow this node to have child nodes (defaults to true) - * @cfg {Boolean} editable False to not allow this node to be edited by an {@link Ext.tree.TreeEditor} (defaults to true) + setCheckedItem : function(groupId, itemId){ + var g = groups[groupId]; + if(g){ + for(var i = 0, l = g.length; i < l; i++){ + if(g[i].id == itemId){ + g[i].setChecked(true); + } + } + } + return null; + } + }; +}(); +/** + * @class Ext.menu.BaseItem + * @extends Ext.Component + * The base class for all items that render into menus. BaseItem provides default rendering, activated state + * management and base configuration options shared by all menu components. * @constructor - * @param {Object/String} attributes The attributes/config for the node or just a string with the text for the node + * Creates a new BaseItem + * @param {Object} config Configuration options + * @xtype menubaseitem */ -Ext.tree.TreeNode = function(attributes){ - attributes = attributes || {}; - if(Ext.isString(attributes)){ - attributes = {text: attributes}; - } - this.childrenRendered = false; - this.rendered = false; - Ext.tree.TreeNode.superclass.constructor.call(this, attributes); - this.expanded = attributes.expanded === true; - this.isTarget = attributes.isTarget !== false; - this.draggable = attributes.draggable !== false && attributes.allowDrag !== false; - this.allowChildren = attributes.allowChildren !== false && attributes.allowDrop !== false; - +Ext.menu.BaseItem = Ext.extend(Ext.Component, { /** - * Read-only. The text for this node. To change it use {@link #setText}. - * @type String + * @property parentMenu + * @type Ext.menu.Menu + * The parent Menu of this Item. */ - this.text = attributes.text; /** - * True if this node is disabled. - * @type Boolean + * @cfg {Function} handler + * A function that will handle the click event of this menu item (optional). + * The handler is passed the following parameters: + * b : ItemThis menu Item. + * e : EventObjectThe click event. + * */ - this.disabled = attributes.disabled === true; /** - * True if this node is hidden. - * @type Boolean + * @cfg {Object} scope + * The scope (this reference) in which the handler function will be called. */ - this.hidden = attributes.hidden === true; - - this.addEvents( - /** - * @event textchange - * Fires when the text for this node is changed - * @param {Node} this This node - * @param {String} text The new text - * @param {String} oldText The old text - */ - 'textchange', - /** - * @event beforeexpand - * Fires before this node is expanded, return false to cancel. - * @param {Node} this This node - * @param {Boolean} deep - * @param {Boolean} anim - */ - 'beforeexpand', - /** - * @event beforecollapse - * Fires before this node is collapsed, return false to cancel. - * @param {Node} this This node - * @param {Boolean} deep - * @param {Boolean} anim - */ - 'beforecollapse', - /** - * @event expand - * Fires when this node is expanded - * @param {Node} this This node - */ - 'expand', - /** - * @event disabledchange - * Fires when the disabled status of this node changes - * @param {Node} this This node - * @param {Boolean} disabled - */ - 'disabledchange', - /** - * @event collapse - * Fires when this node is collapsed - * @param {Node} this This node - */ - 'collapse', - /** - * @event beforeclick - * Fires before click processing. Return false to cancel the default action. - * @param {Node} this This node - * @param {Ext.EventObject} e The event object - */ - 'beforeclick', - /** - * @event click - * Fires when this node is clicked - * @param {Node} this This node - * @param {Ext.EventObject} e The event object - */ - 'click', - /** - * @event checkchange - * Fires when a node with a checkbox's checked property changes - * @param {Node} this This node - * @param {Boolean} checked - */ - 'checkchange', - /** - * @event beforedblclick - * Fires before double click processing. Return false to cancel the default action. - * @param {Node} this This node - * @param {Ext.EventObject} e The event object - */ - 'beforedblclick', - /** - * @event dblclick - * Fires when this node is double clicked - * @param {Node} this This node - * @param {Ext.EventObject} e The event object - */ - 'dblclick', - /** - * @event contextmenu - * Fires when this node is right clicked - * @param {Node} this This node - * @param {Ext.EventObject} e The event object - */ - 'contextmenu', - /** - * @event beforechildrenrendered - * Fires right before the child nodes for this node are rendered - * @param {Node} this This node - */ - 'beforechildrenrendered' - ); - - var uiClass = this.attributes.uiProvider || this.defaultUI || Ext.tree.TreeNodeUI; - /** - * Read-only. The UI for this node - * @type TreeNodeUI + * @cfg {Boolean} canActivate True if this item can be visually activated (defaults to false) */ - this.ui = new uiClass(this); -}; -Ext.extend(Ext.tree.TreeNode, Ext.data.Node, { - preventHScroll : true, + canActivate : false, /** - * Returns true if this node is expanded - * @return {Boolean} + * @cfg {String} activeClass The CSS class to use when the item becomes activated (defaults to "x-menu-item-active") */ - isExpanded : function(){ - return this.expanded; - }, - -/** - * Returns the UI object for this node. - * @return {TreeNodeUI} The object which is providing the user interface for this tree - * node. Unless otherwise specified in the {@link #uiProvider}, this will be an instance - * of {@link Ext.tree.TreeNodeUI} - */ - getUI : function(){ - return this.ui; - }, - - getLoader : function(){ - var owner; - return this.loader || ((owner = this.getOwnerTree()) && owner.loader ? owner.loader : (this.loader = new Ext.tree.TreeLoader())); - }, - - // private override - setFirstChild : function(node){ - var of = this.firstChild; - Ext.tree.TreeNode.superclass.setFirstChild.call(this, node); - if(this.childrenRendered && of && node != of){ - of.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); - } - }, - - // private override - setLastChild : function(node){ - var ol = this.lastChild; - Ext.tree.TreeNode.superclass.setLastChild.call(this, node); - if(this.childrenRendered && ol && node != ol){ - ol.renderIndent(true, true); - } - if(this.rendered){ - this.renderIndent(true, true); - } - }, - - // these methods are overridden to provide lazy rendering support - // private override - appendChild : function(n){ - var node, exists; - if(!n.render && !Ext.isArray(n)){ - n = this.getLoader().createNode(n); - }else{ - exists = !n.parentNode; - } - node = Ext.tree.TreeNode.superclass.appendChild.call(this, n); - if(node){ - this.afterAdd(node, exists); - } - this.ui.updateExpandIcon(); - return node; - }, + activeClass : "x-menu-item-active", + /** + * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to true) + */ + hideOnClick : true, + /** + * @cfg {Number} clickHideDelay Length of time in milliseconds to wait before hiding after a click (defaults to 1) + */ + clickHideDelay : 1, - // private override - removeChild : function(node, destroy){ - this.ownerTree.getSelectionModel().unselect(node); - Ext.tree.TreeNode.superclass.removeChild.apply(this, arguments); - // if it's been rendered remove dom node - if(node.ui.rendered){ - node.ui.remove(); - } - if(this.childNodes.length < 1){ - this.collapse(false, false); - }else{ - this.ui.updateExpandIcon(); - } - if(!this.firstChild && !this.isHiddenRoot()) { - this.childrenRendered = false; - } - return node; - }, + // private + ctype : "Ext.menu.BaseItem", - // private override - insertBefore : function(node, refNode){ - var newNode, exists; - if(!node.render){ - node = this.getLoader().createNode(node); - } else { - exists = Ext.isObject(node.parentNode); - } - newNode = Ext.tree.TreeNode.superclass.insertBefore.call(this, node, refNode); - if(newNode && refNode){ - this.afterAdd(newNode, exists); - } - this.ui.updateExpandIcon(); - return newNode; - }, - // private - afterAdd : function(node, exists){ - if(this.childrenRendered){ - // bulk render if the node already exists - node.render(exists); - }else if(exists){ - // make sure we update the indent - node.renderIndent(true, true); - } - }, + actionMode : "container", - /** - * Sets the text for this node - * @param {String} text - */ - setText : function(text){ - var oldText = this.text; - this.text = this.attributes.text = text; - if(this.rendered){ // event without subscribing - this.ui.onTextChange(this, text, oldText); + initComponent : function(){ + Ext.menu.BaseItem.superclass.initComponent.call(this); + this.addEvents( + /** + * @event click + * Fires when this item is clicked + * @param {Ext.menu.BaseItem} this + * @param {Ext.EventObject} e + */ + 'click', + /** + * @event activate + * Fires when this item is activated + * @param {Ext.menu.BaseItem} this + */ + 'activate', + /** + * @event deactivate + * Fires when this item is deactivated + * @param {Ext.menu.BaseItem} this + */ + 'deactivate' + ); + if(this.handler){ + this.on("click", this.handler, this.scope); } - this.fireEvent('textchange', this, text, oldText); }, - /** - * Triggers selection of this node - */ - select : function(){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().select(this); + // private + onRender : function(container, position){ + Ext.menu.BaseItem.superclass.onRender.apply(this, arguments); + if(this.ownerCt && this.ownerCt instanceof Ext.menu.Menu){ + this.parentMenu = this.ownerCt; + }else{ + this.container.addClass('x-menu-list-item'); + this.mon(this.el, { + scope: this, + click: this.onClick, + mouseenter: this.activate, + mouseleave: this.deactivate + }); } }, /** - * Triggers deselection of this node - * @param {Boolean} silent (optional) True to stop selection change events from firing. + * Sets the function that will handle click events for this item (equivalent to passing in the {@link #handler} + * config property). If an existing handler is already registered, it will be unregistered for you. + * @param {Function} handler The function that should be called on click + * @param {Object} scope The scope (this reference) in which the handler function is executed. Defaults to this menu item. */ - unselect : function(silent){ - var t = this.getOwnerTree(); - if(t){ - t.getSelectionModel().unselect(this, silent); + setHandler : function(handler, scope){ + if(this.handler){ + this.un("click", this.handler, this.scope); } + this.on("click", this.handler = handler, this.scope = scope); }, - /** - * Returns true if this node is selected - * @return {Boolean} - */ - isSelected : function(){ - var t = this.getOwnerTree(); - return t ? t.getSelectionModel().isSelected(this) : false; - }, - - /** - * Expand this node. - * @param {Boolean} deep (optional) True to expand all children as well - * @param {Boolean} anim (optional) false to cancel the default animation - * @param {Function} callback (optional) A callback to be called when - * expanding this node completes (does not wait for deep expand to complete). - * Called with 1 parameter, this node. - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. - */ - expand : function(deep, anim, callback, scope){ - if(!this.expanded){ - if(this.fireEvent('beforeexpand', this, deep, anim) === false){ - return; - } - if(!this.childrenRendered){ - this.renderChildren(); - } - this.expanded = true; - if(!this.isHiddenRoot() && (this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animExpand(function(){ - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.expandChildNodes(true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.expand(); - this.fireEvent('expand', this); - this.runCallback(callback, scope || this, [this]); - } + // private + onClick : function(e){ + if(!this.disabled && this.fireEvent("click", this, e) !== false + && (this.parentMenu && this.parentMenu.fireEvent("itemclick", this, e) !== false)){ + this.handleClick(e); }else{ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - this.expandChildNodes(true); + e.stopEvent(); } }, - runCallback : function(cb, scope, args){ - if(Ext.isFunction(cb)){ - cb.apply(scope, args); + // private + activate : function(){ + if(this.disabled){ + return false; } + var li = this.container; + li.addClass(this.activeClass); + this.region = li.getRegion().adjust(2, 2, -2, -2); + this.fireEvent("activate", this); + return true; }, - isHiddenRoot : function(){ - return this.isRoot && !this.getOwnerTree().rootVisible; - }, - - /** - * Collapse this node. - * @param {Boolean} deep (optional) True to collapse all children as well - * @param {Boolean} anim (optional) false to cancel the default animation - * @param {Function} callback (optional) A callback to be called when - * expanding this node completes (does not wait for deep expand to complete). - * Called with 1 parameter, this node. - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. - */ - collapse : function(deep, anim, callback, scope){ - if(this.expanded && !this.isHiddenRoot()){ - if(this.fireEvent('beforecollapse', this, deep, anim) === false){ - return; - } - this.expanded = false; - if((this.getOwnerTree().animate && anim !== false) || anim){ - this.ui.animCollapse(function(){ - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - if(deep === true){ - this.collapseChildNodes(true); - } - }.createDelegate(this)); - return; - }else{ - this.ui.collapse(); - this.fireEvent('collapse', this); - this.runCallback(callback, scope || this, [this]); - } - }else if(!this.expanded){ - this.runCallback(callback, scope || this, [this]); - } - if(deep === true){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(true, false); - } - } + // private + deactivate : function(){ + this.container.removeClass(this.activeClass); + this.fireEvent("deactivate", this); }, // private - delayedExpand : function(delay){ - if(!this.expandProcId){ - this.expandProcId = this.expand.defer(delay, this); - } + shouldDeactivate : function(e){ + return !this.region || !this.region.contains(e.getPoint()); }, // private - cancelExpand : function(){ - if(this.expandProcId){ - clearTimeout(this.expandProcId); + handleClick : function(e){ + var pm = this.parentMenu; + if(this.hideOnClick){ + if(pm.floating){ + pm.hide.defer(this.clickHideDelay, pm, [true]); + }else{ + pm.deactivateActive(); + } } - this.expandProcId = false; }, + // private. Do nothing + expandMenu : Ext.emptyFn, + + // private. Do nothing + hideMenu : Ext.emptyFn +}); +Ext.reg('menubaseitem', Ext.menu.BaseItem);/** + * @class Ext.menu.TextItem + * @extends Ext.menu.BaseItem + * Adds a static text string to a menu, usually used as either a heading or group separator. + * @constructor + * Creates a new TextItem + * @param {Object/String} config If config is a string, it is used as the text to display, otherwise it + * is applied as a config object (and should contain a text property). + * @xtype menutextitem + */ +Ext.menu.TextItem = Ext.extend(Ext.menu.BaseItem, { /** - * Toggles expanded/collapsed state of the node + * @cfg {String} text The text to display for this item (defaults to '') */ - toggle : function(){ - if(this.expanded){ - this.collapse(); - }else{ - this.expand(); + /** + * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to false) + */ + hideOnClick : false, + /** + * @cfg {String} itemCls The default CSS class to use for text items (defaults to "x-menu-text") + */ + itemCls : "x-menu-text", + + constructor : function(config){ + if(typeof config == 'string'){ + config = {text: config} } + Ext.menu.TextItem.superclass.constructor.call(this, config); }, + // private + onRender : function(){ + var s = document.createElement("span"); + s.className = this.itemCls; + s.innerHTML = this.text; + this.el = s; + Ext.menu.TextItem.superclass.onRender.apply(this, arguments); + } +}); +Ext.reg('menutextitem', Ext.menu.TextItem);/** + * @class Ext.menu.Separator + * @extends Ext.menu.BaseItem + * Adds a separator bar to a menu, used to divide logical groups of menu items. Generally you will + * add one of these by using "-" in you call to add() or in your items config rather than creating one directly. + * @constructor + * @param {Object} config Configuration options + * @xtype menuseparator + */ +Ext.menu.Separator = Ext.extend(Ext.menu.BaseItem, { /** - * Ensures all parent nodes are expanded, and if necessary, scrolls - * the node into view. - * @param {Function} callback (optional) A function to call when the node has been made visible. - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this TreeNode. + * @cfg {String} itemCls The default CSS class to use for separators (defaults to "x-menu-sep") */ - ensureVisible : function(callback, scope){ - var tree = this.getOwnerTree(); - tree.expandPath(this.parentNode ? this.parentNode.getPath() : this.getPath(), false, function(){ - var node = tree.getNodeById(this.id); // Somehow if we don't do this, we lose changes that happened to node in the meantime - tree.getTreeEl().scrollChildIntoView(node.ui.anchor); - this.runCallback(callback, scope || this, [this]); - }.createDelegate(this)); - }, + itemCls : "x-menu-sep", + /** + * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to false) + */ + hideOnClick : false, + + /** + * @cfg {String} activeClass + * @hide + */ + activeClass: '', + // private + onRender : function(li){ + var s = document.createElement("span"); + s.className = this.itemCls; + s.innerHTML = " "; + this.el = s; + li.addClass("x-menu-sep-li"); + Ext.menu.Separator.superclass.onRender.apply(this, arguments); + } +}); +Ext.reg('menuseparator', Ext.menu.Separator);/** + * @class Ext.menu.Item + * @extends Ext.menu.BaseItem + * A base class for all menu items that require menu-related functionality (like sub-menus) and are not static + * display items. Item extends the base functionality of {@link Ext.menu.BaseItem} by adding menu-specific + * activation and click handling. + * @constructor + * Creates a new Item + * @param {Object} config Configuration options + * @xtype menuitem + */ +Ext.menu.Item = Ext.extend(Ext.menu.BaseItem, { /** - * Expand all child nodes - * @param {Boolean} deep (optional) true if the child nodes should also expand their child nodes + * @property menu + * @type Ext.menu.Menu + * The submenu associated with this Item if one was configured. */ - expandChildNodes : function(deep){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].expand(deep); + /** + * @cfg {Mixed} menu (optional) Either an instance of {@link Ext.menu.Menu} or the config object for an + * {@link Ext.menu.Menu} which acts as the submenu when this item is activated. + */ + /** + * @cfg {String} icon The path to an icon to display in this item (defaults to Ext.BLANK_IMAGE_URL). If + * icon is specified {@link #iconCls} should not be. + */ + /** + * @cfg {String} iconCls A CSS class that specifies a background image that will be used as the icon for + * this item (defaults to ''). If iconCls is specified {@link #icon} should not be. + */ + /** + * @cfg {String} text The text to display in this item (defaults to ''). + */ + /** + * @cfg {String} href The href attribute to use for the underlying anchor link (defaults to '#'). + */ + /** + * @cfg {String} hrefTarget The target attribute to use for the underlying anchor link (defaults to ''). + */ + /** + * @cfg {String} itemCls The default CSS class to use for menu items (defaults to 'x-menu-item') + */ + itemCls : 'x-menu-item', + /** + * @cfg {Boolean} canActivate True if this item can be visually activated (defaults to true) + */ + canActivate : true, + /** + * @cfg {Number} showDelay Length of time in milliseconds to wait before showing this item (defaults to 200) + */ + showDelay: 200, + // doc'd in BaseItem + hideDelay: 200, + + // private + ctype: 'Ext.menu.Item', + + initComponent : function(){ + Ext.menu.Item.superclass.initComponent.call(this); + if(this.menu){ + this.menu = Ext.menu.MenuMgr.get(this.menu); + this.menu.ownerCt = this; } }, - /** - * Collapse all child nodes - * @param {Boolean} deep (optional) true if the child nodes should also collapse their child nodes - */ - collapseChildNodes : function(deep){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++) { - cs[i].collapse(deep); + // private + onRender : function(container, position){ + if (!this.itemTpl) { + this.itemTpl = Ext.menu.Item.prototype.itemTpl = new Ext.XTemplate( + '', + ' target="{hrefTarget}"', + '', + '>', + '', + '{text}', + '' + ); } + var a = this.getTemplateArgs(); + this.el = position ? this.itemTpl.insertBefore(position, a, true) : this.itemTpl.append(container, a, true); + this.iconEl = this.el.child('img.x-menu-item-icon'); + this.textEl = this.el.child('.x-menu-item-text'); + if(!this.href) { // if no link defined, prevent the default anchor event + this.mon(this.el, 'click', Ext.emptyFn, null, { preventDefault: true }); + } + Ext.menu.Item.superclass.onRender.call(this, container, position); + }, + + getTemplateArgs: function() { + return { + id: this.id, + cls: this.itemCls + (this.menu ? ' x-menu-item-arrow' : '') + (this.cls ? ' ' + this.cls : ''), + href: this.href || '#', + hrefTarget: this.hrefTarget, + icon: this.icon || Ext.BLANK_IMAGE_URL, + iconCls: this.iconCls || '', + text: this.itemText||this.text||' ' + }; }, /** - * Disables this node + * Sets the text to display in this menu item + * @param {String} text The text to display */ - disable : function(){ - this.disabled = true; - this.unselect(); - if(this.rendered && this.ui.onDisableChange){ // event without subscribing - this.ui.onDisableChange(this, true); + setText : function(text){ + this.text = text||' '; + if(this.rendered){ + this.textEl.update(this.text); + this.parentMenu.layout.doAutoSize(); } - this.fireEvent('disabledchange', this, true); }, /** - * Enables this node + * Sets the CSS class to apply to the item's icon element + * @param {String} cls The CSS class to apply */ - enable : function(){ - this.disabled = false; - if(this.rendered && this.ui.onDisableChange){ // event without subscribing - this.ui.onDisableChange(this, false); + setIconClass : function(cls){ + var oldCls = this.iconCls; + this.iconCls = cls; + if(this.rendered){ + this.iconEl.replaceClass(oldCls, this.iconCls); } - this.fireEvent('disabledchange', this, false); }, - // private - renderChildren : function(suppressEvent){ - if(suppressEvent !== false){ - this.fireEvent('beforechildrenrendered', this); - } - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); + //private + beforeDestroy: function(){ + if (this.menu){ + delete this.menu.ownerCt; + this.menu.destroy(); } - this.childrenRendered = true; + Ext.menu.Item.superclass.beforeDestroy.call(this); }, // private - sort : function(fn, scope){ - Ext.tree.TreeNode.superclass.sort.apply(this, arguments); - if(this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].render(true); - } + handleClick : function(e){ + if(!this.href){ // if no link defined, stop the event automatically + e.stopEvent(); } + Ext.menu.Item.superclass.handleClick.apply(this, arguments); }, // private - render : function(bulkRender){ - this.ui.render(bulkRender); - if(!this.rendered){ - // make sure it is registered - this.getOwnerTree().registerNode(this); - this.rendered = true; - if(this.expanded){ - this.expanded = false; - this.expand(false, false); + activate : function(autoExpand){ + if(Ext.menu.Item.superclass.activate.apply(this, arguments)){ + this.focus(); + if(autoExpand){ + this.expandMenu(); } } + return true; }, // private - renderIndent : function(deep, refresh){ - if(refresh){ - this.ui.childIndent = null; - } - this.ui.renderIndent(); - if(deep === true && this.childrenRendered){ - var cs = this.childNodes; - for(var i = 0, len = cs.length; i < len; i++){ - cs[i].renderIndent(true, refresh); + shouldDeactivate : function(e){ + if(Ext.menu.Item.superclass.shouldDeactivate.call(this, e)){ + if(this.menu && this.menu.isVisible()){ + return !this.menu.getEl().getRegion().contains(e.getPoint()); } + return true; } + return false; }, - beginUpdate : function(){ - this.childrenRendered = false; + // private + deactivate : function(){ + Ext.menu.Item.superclass.deactivate.apply(this, arguments); + this.hideMenu(); }, - endUpdate : function(){ - if(this.expanded && this.rendered){ - this.renderChildren(); + // private + expandMenu : function(autoActivate){ + if(!this.disabled && this.menu){ + clearTimeout(this.hideTimer); + delete this.hideTimer; + if(!this.menu.isVisible() && !this.showTimer){ + this.showTimer = this.deferExpand.defer(this.showDelay, this, [autoActivate]); + }else if (this.menu.isVisible() && autoActivate){ + this.menu.tryActivate(0, 1); + } } }, - destroy : function(){ - this.unselect(true); - Ext.tree.TreeNode.superclass.destroy.call(this); - Ext.destroy(this.ui, this.loader); - this.ui = this.loader = null; - }, - // private - onIdChange : function(id){ - this.ui.onIdChange(id); - } -}); - -Ext.tree.TreePanel.nodeTypes.node = Ext.tree.TreeNode;/** - * @class Ext.tree.AsyncTreeNode - * @extends Ext.tree.TreeNode - * @cfg {TreeLoader} loader A TreeLoader to be used by this node (defaults to the loader defined on the tree) - * @constructor - * @param {Object/String} attributes The attributes/config for the node or just a string with the text for the node - */ - Ext.tree.AsyncTreeNode = function(config){ - this.loaded = config && config.loaded === true; - this.loading = false; - Ext.tree.AsyncTreeNode.superclass.constructor.apply(this, arguments); - /** - * @event beforeload - * Fires before this node is loaded, return false to cancel - * @param {Node} this This node - */ - this.addEvents('beforeload', 'load'); - /** - * @event load - * Fires when this node is loaded - * @param {Node} this This node - */ - /** - * The loader used by this node (defaults to using the tree's defined loader) - * @type TreeLoader - * @property loader - */ -}; -Ext.extend(Ext.tree.AsyncTreeNode, Ext.tree.TreeNode, { - expand : function(deep, anim, callback, scope){ - if(this.loading){ // if an async load is already running, waiting til it's done - var timer; - var f = function(){ - if(!this.loading){ // done loading - clearInterval(timer); - this.expand(deep, anim, callback, scope); - } - }.createDelegate(this); - timer = setInterval(f, 200); - return; - } - if(!this.loaded){ - if(this.fireEvent("beforeload", this) === false){ - return; - } - this.loading = true; - this.ui.beforeLoad(this); - var loader = this.loader || this.attributes.loader || this.getOwnerTree().getLoader(); - if(loader){ - loader.load(this, this.loadComplete.createDelegate(this, [deep, anim, callback, scope]), this); - return; - } - } - Ext.tree.AsyncTreeNode.superclass.expand.call(this, deep, anim, callback, scope); - }, - - /** - * Returns true if this node is currently loading - * @return {Boolean} - */ - isLoading : function(){ - return this.loading; - }, - - loadComplete : function(deep, anim, callback, scope){ - this.loading = false; - this.loaded = true; - this.ui.afterLoad(this); - this.fireEvent("load", this); - this.expand(deep, anim, callback, scope); - }, - - /** - * Returns true if this node has been loaded - * @return {Boolean} - */ - isLoaded : function(){ - return this.loaded; - }, - - hasChildNodes : function(){ - if(!this.isLeaf() && !this.loaded){ - return true; - }else{ - return Ext.tree.AsyncTreeNode.superclass.hasChildNodes.call(this); - } - }, - - /** - * Trigger a reload for this node - * @param {Function} callback - * @param {Object} scope (optional) The scope (this reference) in which the callback is executed. Defaults to this Node. - */ - reload : function(callback, scope){ - this.collapse(false, false); - while(this.firstChild){ - this.removeChild(this.firstChild).destroy(); - } - this.childrenRendered = false; - this.loaded = false; - if(this.isHiddenRoot()){ - this.expanded = false; - } - this.expand(false, false, callback, scope); - } -}); - -Ext.tree.TreePanel.nodeTypes.async = Ext.tree.AsyncTreeNode;/** - * @class Ext.tree.TreeNodeUI - * This class provides the default UI implementation for Ext TreeNodes. - * The TreeNode UI implementation is separate from the - * tree implementation, and allows customizing of the appearance of - * tree nodes. - * - * If you are customizing the Tree's user interface, you - * may need to extend this class, but you should never need to instantiate this class. - * - * This class provides access to the user interface components of an Ext TreeNode, through - * {@link Ext.tree.TreeNode#getUI} - */ -Ext.tree.TreeNodeUI = function(node){ - this.node = node; - this.rendered = false; - this.animating = false; - this.wasLeaf = true; - this.ecc = 'x-tree-ec-icon x-tree-elbow'; - this.emptyIcon = Ext.BLANK_IMAGE_URL; -}; - -Ext.tree.TreeNodeUI.prototype = { - // private - removeChild : function(node){ - if(this.rendered){ - this.ctNode.removeChild(node.ui.getEl()); - } - }, - - // private - beforeLoad : function(){ - this.addClass("x-tree-node-loading"); - }, - - // private - afterLoad : function(){ - this.removeClass("x-tree-node-loading"); - }, - - // private - onTextChange : function(node, text, oldText){ - if(this.rendered){ - this.textNode.innerHTML = text; - } - }, - - // private - onDisableChange : function(node, state){ - this.disabled = state; - if (this.checkbox) { - this.checkbox.disabled = state; - } - if(state){ - this.addClass("x-tree-node-disabled"); - }else{ - this.removeClass("x-tree-node-disabled"); - } - }, - - // private - onSelectedChange : function(state){ - if(state){ - this.focus(); - this.addClass("x-tree-selected"); - }else{ - //this.blur(); - this.removeClass("x-tree-selected"); - } - }, - - // private - onMove : function(tree, node, oldParent, newParent, index, refNode){ - this.childIndent = null; - if(this.rendered){ - var targetNode = newParent.ui.getContainer(); - if(!targetNode){//target not rendered - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); - return; - } - var insertBefore = refNode ? refNode.ui.getEl() : null; - if(insertBefore){ - targetNode.insertBefore(this.wrap, insertBefore); - }else{ - targetNode.appendChild(this.wrap); - } - this.node.renderIndent(true, oldParent != newParent); - } - }, - -/** - * Adds one or more CSS classes to the node's UI element. - * Duplicate classes are automatically filtered out. - * @param {String/Array} className The CSS class to add, or an array of classes - */ - addClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).addClass(cls); - } - }, - -/** - * Removes one or more CSS classes from the node's UI element. - * @param {String/Array} className The CSS class to remove, or an array of classes - */ - removeClass : function(cls){ - if(this.elNode){ - Ext.fly(this.elNode).removeClass(cls); - } - }, - - // private - remove : function(){ - if(this.rendered){ - this.holder = document.createElement("div"); - this.holder.appendChild(this.wrap); - } - }, - - // private - fireEvent : function(){ - return this.node.fireEvent.apply(this.node, arguments); - }, - - // private - initEvents : function(){ - this.node.on("move", this.onMove, this); - - if(this.node.disabled){ - this.onDisableChange(this.node, true); - } - if(this.node.hidden){ - this.hide(); - } - var ot = this.node.getOwnerTree(); - var dd = ot.enableDD || ot.enableDrag || ot.enableDrop; - if(dd && (!this.node.isRoot || ot.rootVisible)){ - Ext.dd.Registry.register(this.elNode, { - node: this.node, - handles: this.getDDHandles(), - isHandle: false - }); - } - }, - - // private - getDDHandles : function(){ - return [this.iconNode, this.textNode, this.elNode]; - }, - -/** - * Hides this node. - */ - hide : function(){ - this.node.hidden = true; - if(this.wrap){ - this.wrap.style.display = "none"; - } - }, - -/** - * Shows this node. - */ - show : function(){ - this.node.hidden = false; - if(this.wrap){ - this.wrap.style.display = ""; - } - }, - - // private - onContextMenu : function(e){ - if (this.node.hasListener("contextmenu") || this.node.getOwnerTree().hasListener("contextmenu")) { - e.preventDefault(); - this.focus(); - this.fireEvent("contextmenu", this.node, e); - } - }, - - // private - onClick : function(e){ - if(this.dropping){ - e.stopEvent(); - return; - } - if(this.fireEvent("beforeclick", this.node, e) !== false){ - var a = e.getTarget('a'); - if(!this.disabled && this.node.attributes.href && a){ - this.fireEvent("click", this.node, e); - return; - }else if(a && e.ctrlKey){ - e.stopEvent(); - } - e.preventDefault(); - if(this.disabled){ - return; - } - - if(this.node.attributes.singleClickExpand && !this.animating && this.node.isExpandable()){ - this.node.toggle(); - } - - this.fireEvent("click", this.node, e); - }else{ - e.stopEvent(); - } - }, - - // private - onDblClick : function(e){ - e.preventDefault(); - if(this.disabled){ - return; - } - if(this.fireEvent("beforedblclick", this.node, e) !== false){ - if(this.checkbox){ - this.toggleCheck(); - } - if(!this.animating && this.node.isExpandable()){ - this.node.toggle(); - } - this.fireEvent("dblclick", this.node, e); - } - }, - - onOver : function(e){ - this.addClass('x-tree-node-over'); - }, - - onOut : function(e){ - this.removeClass('x-tree-node-over'); - }, - - // private - onCheckChange : function(){ - var checked = this.checkbox.checked; - // fix for IE6 - this.checkbox.defaultChecked = checked; - this.node.attributes.checked = checked; - this.fireEvent('checkchange', this.node, checked); - }, - - // private - ecClick : function(e){ - if(!this.animating && this.node.isExpandable()){ - this.node.toggle(); - } - }, - - // private - startDrop : function(){ - this.dropping = true; - }, - - // delayed drop so the click event doesn't get fired on a drop - endDrop : function(){ - setTimeout(function(){ - this.dropping = false; - }.createDelegate(this), 50); - }, - - // private - expand : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - }, - - // private - focus : function(){ - if(!this.node.preventHScroll){ - try{this.anchor.focus(); - }catch(e){} - }else{ - try{ - var noscroll = this.node.getOwnerTree().getTreeEl().dom; - var l = noscroll.scrollLeft; - this.anchor.focus(); - noscroll.scrollLeft = l; - }catch(e){} - } - }, - -/** - * Sets the checked status of the tree node to the passed value, or, if no value was passed, - * toggles the checked status. If the node was rendered with no checkbox, this has no effect. - * @param {Boolean} (optional) The new checked status. - */ - toggleCheck : function(value){ - var cb = this.checkbox; - if(cb){ - cb.checked = (value === undefined ? !cb.checked : value); - this.onCheckChange(); - } - }, - - // private - blur : function(){ - try{ - this.anchor.blur(); - }catch(e){} - }, - - // private - animExpand : function(callback){ - var ct = Ext.get(this.ctNode); - ct.stopFx(); - if(!this.node.isExpandable()){ - this.updateExpandIcon(); - this.ctNode.style.display = ""; - Ext.callback(callback); - return; - } - this.animating = true; - this.updateExpandIcon(); - - ct.slideIn('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, - - // private - highlight : function(){ - var tree = this.node.getOwnerTree(); - Ext.fly(this.wrap).highlight( - tree.hlColor || "C3DAF9", - {endColor: tree.hlBaseColor} - ); - }, - - // private - collapse : function(){ - this.updateExpandIcon(); - this.ctNode.style.display = "none"; - }, - - // private - animCollapse : function(callback){ - var ct = Ext.get(this.ctNode); - ct.enableDisplayMode('block'); - ct.stopFx(); - - this.animating = true; - this.updateExpandIcon(); - - ct.slideOut('t', { - callback : function(){ - this.animating = false; - Ext.callback(callback); - }, - scope: this, - duration: this.node.ownerTree.duration || .25 - }); - }, - - // private - getContainer : function(){ - return this.ctNode; - }, - -/** - * Returns the element which encapsulates this node. - * @return {HtmlElement} The DOM element. The default implementation uses a <li>. - */ - getEl : function(){ - return this.wrap; - }, - - // private - appendDDGhost : function(ghostNode){ - ghostNode.appendChild(this.elNode.cloneNode(true)); - }, - - // private - getDDRepairXY : function(){ - return Ext.lib.Dom.getXY(this.iconNode); - }, - - // private - onRender : function(){ - this.render(); - }, - - // private - render : function(bulkRender){ - var n = this.node, a = n.attributes; - var targetNode = n.parentNode ? - n.parentNode.ui.getContainer() : n.ownerTree.innerCt.dom; - - if(!this.rendered){ - this.rendered = true; - - this.renderElements(n, a, targetNode, bulkRender); - - if(a.qtip){ - if(this.textNode.setAttributeNS){ - this.textNode.setAttributeNS("ext", "qtip", a.qtip); - if(a.qtipTitle){ - this.textNode.setAttributeNS("ext", "qtitle", a.qtipTitle); - } - }else{ - this.textNode.setAttribute("ext:qtip", a.qtip); - if(a.qtipTitle){ - this.textNode.setAttribute("ext:qtitle", a.qtipTitle); - } - } - }else if(a.qtipCfg){ - a.qtipCfg.target = Ext.id(this.textNode); - Ext.QuickTips.register(a.qtipCfg); - } - this.initEvents(); - if(!this.node.expanded){ - this.updateExpandIcon(true); - } - }else{ - if(bulkRender === true) { - targetNode.appendChild(this.wrap); - } - } - }, - - // private - renderElements : function(n, a, targetNode, bulkRender){ - // add some indent caching, this helps performance when rendering a large tree - this.indentMarkup = n.parentNode ? n.parentNode.ui.getChildIndent() : ''; - - var cb = Ext.isBoolean(a.checked), - nel, - href = a.href ? a.href : Ext.isGecko ? "" : "#", - buf = [' ', - '',this.indentMarkup,"", - '', - '', - cb ? ('' : '/>')) : '', - '',n.text,"", - '', - ""].join(''); - - if(bulkRender !== true && n.nextSibling && (nel = n.nextSibling.ui.getEl())){ - this.wrap = Ext.DomHelper.insertHtml("beforeBegin", nel, buf); - }else{ - this.wrap = Ext.DomHelper.insertHtml("beforeEnd", targetNode, buf); - } - - this.elNode = this.wrap.childNodes[0]; - this.ctNode = this.wrap.childNodes[1]; - var cs = this.elNode.childNodes; - this.indentNode = cs[0]; - this.ecNode = cs[1]; - this.iconNode = cs[2]; - var index = 3; - if(cb){ - this.checkbox = cs[3]; - // fix for IE6 - this.checkbox.defaultChecked = this.checkbox.checked; - index++; - } - this.anchor = cs[index]; - this.textNode = cs[index].firstChild; - }, - -/** - * Returns the <a> element that provides focus for the node's UI. - * @return {HtmlElement} The DOM anchor element. - */ - getAnchor : function(){ - return this.anchor; - }, - -/** - * Returns the text node. - * @return {HtmlNode} The DOM text node. - */ - getTextEl : function(){ - return this.textNode; - }, - -/** - * Returns the icon <img> element. - * @return {HtmlElement} The DOM image element. - */ - getIconEl : function(){ - return this.iconNode; - }, - -/** - * Returns the checked status of the node. If the node was rendered with no - * checkbox, it returns false. - * @return {Boolean} The checked flag. - */ - isChecked : function(){ - return this.checkbox ? this.checkbox.checked : false; - }, - - // private - updateExpandIcon : function(){ - if(this.rendered){ - var n = this.node, - c1, - c2, - cls = n.isLast() ? "x-tree-elbow-end" : "x-tree-elbow", - hasChild = n.hasChildNodes(); - if(hasChild || n.attributes.expandable){ - if(n.expanded){ - cls += "-minus"; - c1 = "x-tree-node-collapsed"; - c2 = "x-tree-node-expanded"; - }else{ - cls += "-plus"; - c1 = "x-tree-node-expanded"; - c2 = "x-tree-node-collapsed"; - } - if(this.wasLeaf){ - this.removeClass("x-tree-node-leaf"); - this.wasLeaf = false; - } - if(this.c1 != c1 || this.c2 != c2){ - Ext.fly(this.elNode).replaceClass(c1, c2); - this.c1 = c1; this.c2 = c2; - } - }else{ - if(!this.wasLeaf){ - Ext.fly(this.elNode).replaceClass("x-tree-node-expanded", "x-tree-node-collapsed"); - delete this.c1; - delete this.c2; - this.wasLeaf = true; - } - } - var ecc = "x-tree-ec-icon "+cls; - if(this.ecc != ecc){ - this.ecNode.className = ecc; - this.ecc = ecc; - } - } - }, - - // private - onIdChange: function(id){ - if(this.rendered){ - this.elNode.setAttribute('ext:tree-node-id', id); - } - }, - - // private - getChildIndent : function(){ - if(!this.childIndent){ - var buf = [], - p = this.node; - while(p){ - if(!p.isRoot || (p.isRoot && p.ownerTree.rootVisible)){ - if(!p.isLast()) { - buf.unshift(''); - } else { - buf.unshift(''); - } - } - p = p.parentNode; - } - this.childIndent = buf.join(""); - } - return this.childIndent; - }, - - // private - renderIndent : function(){ - if(this.rendered){ - var indent = "", - p = this.node.parentNode; - if(p){ - indent = p.ui.getChildIndent(); - } - if(this.indentMarkup != indent){ // don't rerender if not required - this.indentNode.innerHTML = indent; - this.indentMarkup = indent; - } - this.updateExpandIcon(); - } - }, - - destroy : function(){ - if(this.elNode){ - Ext.dd.Registry.unregister(this.elNode.id); - } - - Ext.each(['textnode', 'anchor', 'checkbox', 'indentNode', 'ecNode', 'iconNode', 'elNode', 'ctNode', 'wrap', 'holder'], function(el){ - if(this[el]){ - Ext.fly(this[el]).remove(); - delete this[el]; - } - }, this); - delete this.node; - } -}; - -/** - * @class Ext.tree.RootTreeNodeUI - * This class provides the default UI implementation for root Ext TreeNodes. - * The RootTreeNode UI implementation allows customizing the appearance of the root tree node. - * - * If you are customizing the Tree's user interface, you - * may need to extend this class, but you should never need to instantiate this class. - */ -Ext.tree.RootTreeNodeUI = Ext.extend(Ext.tree.TreeNodeUI, { - // private - render : function(){ - if(!this.rendered){ - var targetNode = this.node.ownerTree.innerCt.dom; - this.node.expanded = true; - targetNode.innerHTML = ' '; - this.wrap = this.ctNode = targetNode.firstChild; - } - }, - collapse : Ext.emptyFn, - expand : Ext.emptyFn -});/** - * @class Ext.tree.TreeLoader - * @extends Ext.util.Observable - * A TreeLoader provides for lazy loading of an {@link Ext.tree.TreeNode}'s child - * nodes from a specified URL. The response must be a JavaScript Array definition - * whose elements are node definition objects. e.g.: - * - [{ - id: 1, - text: 'A leaf Node', - leaf: true - },{ - id: 2, - text: 'A folder Node', - children: [{ - id: 3, - text: 'A child Node', - leaf: true - }] - }] - - * - * A server request is sent, and child nodes are loaded only when a node is expanded. - * The loading node's id is passed to the server under the parameter name "node" to - * enable the server to produce the correct child nodes. - * - * To pass extra parameters, an event handler may be attached to the "beforeload" - * event, and the parameters specified in the TreeLoader's baseParams property: - * - myTreeLoader.on("beforeload", function(treeLoader, node) { - this.baseParams.category = node.attributes.category; - }, this); - - * This would pass an HTTP parameter called "category" to the server containing - * the value of the Node's "category" attribute. - * @constructor - * Creates a new Treeloader. - * @param {Object} config A config object containing config properties. - */ -Ext.tree.TreeLoader = function(config){ - this.baseParams = {}; - Ext.apply(this, config); - - this.addEvents( - /** - * @event beforeload - * Fires before a network request is made to retrieve the Json text which specifies a node's children. - * @param {Object} This TreeLoader object. - * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. - * @param {Object} callback The callback function specified in the {@link #load} call. - */ - "beforeload", - /** - * @event load - * Fires when the node has been successfuly loaded. - * @param {Object} This TreeLoader object. - * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. - * @param {Object} response The response object containing the data from the server. - */ - "load", - /** - * @event loadexception - * Fires if the network request failed. - * @param {Object} This TreeLoader object. - * @param {Object} node The {@link Ext.tree.TreeNode} object being loaded. - * @param {Object} response The response object containing the data from the server. - */ - "loadexception" - ); - Ext.tree.TreeLoader.superclass.constructor.call(this); - if(Ext.isString(this.paramOrder)){ - this.paramOrder = this.paramOrder.split(/[\s,|]/); - } -}; - -Ext.extend(Ext.tree.TreeLoader, Ext.util.Observable, { - /** - * @cfg {String} dataUrl The URL from which to request a Json string which - * specifies an array of node definition objects representing the child nodes - * to be loaded. - */ - /** - * @cfg {String} requestMethod The HTTP request method for loading data (defaults to the value of {@link Ext.Ajax#method}). - */ - /** - * @cfg {String} url Equivalent to {@link #dataUrl}. - */ - /** - * @cfg {Boolean} preloadChildren If set to true, the loader recursively loads "children" attributes when doing the first load on nodes. - */ - /** - * @cfg {Object} baseParams (optional) An object containing properties which - * specify HTTP parameters to be passed to each request for child nodes. - */ - /** - * @cfg {Object} baseAttrs (optional) An object containing attributes to be added to all nodes - * created by this loader. If the attributes sent by the server have an attribute in this object, - * they take priority. - */ - /** - * @cfg {Object} uiProviders (optional) An object containing properties which - * specify custom {@link Ext.tree.TreeNodeUI} implementations. If the optional - * uiProvider attribute of a returned child node is a string rather - * than a reference to a TreeNodeUI implementation, then that string value - * is used as a property name in the uiProviders object. - */ - uiProviders : {}, - - /** - * @cfg {Boolean} clearOnLoad (optional) Default to true. Remove previously existing - * child nodes before loading. - */ - clearOnLoad : true, - - /** - * @cfg {Array/String} paramOrder Defaults to undefined. Only used when using directFn. - * Specifies the params in the order in which they must be passed to the server-side Direct method - * as either (1) an Array of String values, or (2) a String of params delimited by either whitespace, - * comma, or pipe. For example, - * any of the following would be acceptable: -nodeParameter: 'node', -paramOrder: ['param1','param2','param3'] -paramOrder: 'node param1 param2 param3' -paramOrder: 'param1,node,param2,param3' -paramOrder: 'param1|param2|param|node' - - */ - paramOrder: undefined, - - /** - * @cfg {Boolean} paramsAsHash Only used when using directFn. - * Send parameters as a collection of named arguments (defaults to false). Providing a - * {@link #paramOrder} nullifies this configuration. - */ - paramsAsHash: false, - - /** - * @cfg {String} nodeParameter The name of the parameter sent to the server which contains - * the identifier of the node. Defaults to 'node'. - */ - nodeParameter: 'node', - - /** - * @cfg {Function} directFn - * Function to call when executing a request. - */ - directFn : undefined, - - /** - * Load an {@link Ext.tree.TreeNode} from the URL specified in the constructor. - * This is called automatically when a node is expanded, but may be used to reload - * a node (or append new children if the {@link #clearOnLoad} option is false.) - * @param {Ext.tree.TreeNode} node - * @param {Function} callback Function to call after the node has been loaded. The - * function is passed the TreeNode which was requested to be loaded. - * @param (Object) scope The cope (this reference) in which the callback is executed. - * defaults to the loaded TreeNode. - */ - load : function(node, callback, scope){ - if(this.clearOnLoad){ - while(node.firstChild){ - node.removeChild(node.firstChild); - } - } - if(this.doPreload(node)){ // preloaded json children - this.runCallback(callback, scope || node, [node]); - }else if(this.directFn || this.dataUrl || this.url){ - this.requestData(node, callback, scope || node); - } - }, - - doPreload : function(node){ - if(node.attributes.children){ - if(node.childNodes.length < 1){ // preloaded? - var cs = node.attributes.children; - node.beginUpdate(); - for(var i = 0, len = cs.length; i < len; i++){ - var cn = node.appendChild(this.createNode(cs[i])); - if(this.preloadChildren){ - this.doPreload(cn); - } - } - node.endUpdate(); - } - return true; - } - return false; - }, - - getParams: function(node){ - var bp = Ext.apply({}, this.baseParams), - np = this.nodeParameter, - po = this.paramOrder; - - np && (bp[ np ] = node.id); - - if(this.directFn){ - var buf = [node.id]; - if(po){ - // reset 'buf' if the nodeParameter was included in paramOrder - if(np && po.indexOf(np) > -1){ - buf = []; - } - - for(var i = 0, len = po.length; i < len; i++){ - buf.push(bp[ po[i] ]); - } - }else if(this.paramsAsHash){ - buf = [bp]; - } - return buf; - }else{ - return bp; - } - }, - - requestData : function(node, callback, scope){ - if(this.fireEvent("beforeload", this, node, callback) !== false){ - if(this.directFn){ - var args = this.getParams(node); - args.push(this.processDirectResponse.createDelegate(this, [{callback: callback, node: node, scope: scope}], true)); - this.directFn.apply(window, args); - }else{ - this.transId = Ext.Ajax.request({ - method:this.requestMethod, - url: this.dataUrl||this.url, - success: this.handleResponse, - failure: this.handleFailure, - scope: this, - argument: {callback: callback, node: node, scope: scope}, - params: this.getParams(node) - }); - } - }else{ - // if the load is cancelled, make sure we notify - // the node that we are done - this.runCallback(callback, scope || node, []); - } - }, - - processDirectResponse: function(result, response, args){ - if(response.status){ - this.handleResponse({ - responseData: Ext.isArray(result) ? result : null, - responseText: result, - argument: args - }); - }else{ - this.handleFailure({ - argument: args - }); - } - }, - - // private - runCallback: function(cb, scope, args){ - if(Ext.isFunction(cb)){ - cb.apply(scope, args); - } - }, - - isLoading : function(){ - return !!this.transId; - }, - - abort : function(){ - if(this.isLoading()){ - Ext.Ajax.abort(this.transId); - } - }, - - /** - * Override this function for custom TreeNode node implementation, or to - * modify the attributes at creation time. - * Example: -new Ext.tree.TreePanel({ - ... - loader: new Ext.tree.TreeLoader({ - url: 'dataUrl', - createNode: function(attr) { -// Allow consolidation consignments to have -// consignments dropped into them. - if (attr.isConsolidation) { - attr.iconCls = 'x-consol', - attr.allowDrop = true; - } - return Ext.tree.TreeLoader.prototype.createNode.call(this, attr); - } - }), - ... -}); - - * @param attr {Object} The attributes from which to create the new node. - */ - createNode : function(attr){ - // apply baseAttrs, nice idea Corey! - if(this.baseAttrs){ - Ext.applyIf(attr, this.baseAttrs); - } - if(this.applyLoader !== false && !attr.loader){ - attr.loader = this; - } - if(Ext.isString(attr.uiProvider)){ - attr.uiProvider = this.uiProviders[attr.uiProvider] || eval(attr.uiProvider); - } - if(attr.nodeType){ - return new Ext.tree.TreePanel.nodeTypes[attr.nodeType](attr); - }else{ - return attr.leaf ? - new Ext.tree.TreeNode(attr) : - new Ext.tree.AsyncTreeNode(attr); - } - }, - - processResponse : function(response, node, callback, scope){ - var json = response.responseText; - try { - var o = response.responseData || Ext.decode(json); - node.beginUpdate(); - for(var i = 0, len = o.length; i < len; i++){ - var n = this.createNode(o[i]); - if(n){ - node.appendChild(n); - } - } - node.endUpdate(); - this.runCallback(callback, scope || node, [node]); - }catch(e){ - this.handleFailure(response); - } - }, - - handleResponse : function(response){ - this.transId = false; - var a = response.argument; - this.processResponse(response, a.node, a.callback, a.scope); - this.fireEvent("load", this, a.node, response); - }, - - handleFailure : function(response){ - this.transId = false; - var a = response.argument; - this.fireEvent("loadexception", this, a.node, response); - this.runCallback(a.callback, a.scope || a.node, [a.node]); - }, - - destroy : function(){ - this.abort(); - this.purgeListeners(); - } -});/** - * @class Ext.tree.TreeFilter - * Note this class is experimental and doesn't update the indent (lines) or expand collapse icons of the nodes - * @param {TreePanel} tree - * @param {Object} config (optional) - */ -Ext.tree.TreeFilter = function(tree, config){ - this.tree = tree; - this.filtered = {}; - Ext.apply(this, config); -}; - -Ext.tree.TreeFilter.prototype = { - clearBlank:false, - reverse:false, - autoClear:false, - remove:false, - - /** - * Filter the data by a specific attribute. - * @param {String/RegExp} value Either string that the attribute value - * should start with or a RegExp to test against the attribute - * @param {String} attr (optional) The attribute passed in your node's attributes collection. Defaults to "text". - * @param {TreeNode} startNode (optional) The node to start the filter at. - */ - filter : function(value, attr, startNode){ - attr = attr || "text"; - var f; - if(typeof value == "string"){ - var vlen = value.length; - // auto clear empty filter - if(vlen == 0 && this.clearBlank){ - this.clear(); - return; - } - value = value.toLowerCase(); - f = function(n){ - return n.attributes[attr].substr(0, vlen).toLowerCase() == value; - }; - }else if(value.exec){ // regex? - f = function(n){ - return value.test(n.attributes[attr]); - }; - }else{ - throw 'Illegal filter type, must be string or regex'; + deferExpand : function(autoActivate){ + delete this.showTimer; + this.menu.show(this.container, this.parentMenu.subMenuAlign || 'tl-tr?', this.parentMenu); + if(autoActivate){ + this.menu.tryActivate(0, 1); } - this.filterBy(f, null, startNode); - }, + }, - /** - * Filter by a function. The passed function will be called with each - * node in the tree (or from the startNode). If the function returns true, the node is kept - * otherwise it is filtered. If a node is filtered, its children are also filtered. - * @param {Function} fn The filter function - * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the current Node. - */ - filterBy : function(fn, scope, startNode){ - startNode = startNode || this.tree.root; - if(this.autoClear){ - this.clear(); - } - var af = this.filtered, rv = this.reverse; - var f = function(n){ - if(n == startNode){ - return true; - } - if(af[n.id]){ - return false; - } - var m = fn.call(scope || n, n); - if(!m || rv){ - af[n.id] = n; - n.ui.hide(); - return false; - } - return true; - }; - startNode.cascade(f); - if(this.remove){ - for(var id in af){ - if(typeof id != "function"){ - var n = af[id]; - if(n && n.parentNode){ - n.parentNode.removeChild(n); - } - } - } + // private + hideMenu : function(){ + clearTimeout(this.showTimer); + delete this.showTimer; + if(!this.hideTimer && this.menu && this.menu.isVisible()){ + this.hideTimer = this.deferHide.defer(this.hideDelay, this); } }, - /** - * Clears the current filter. Note: with the "remove" option - * set a filter cannot be cleared. - */ - clear : function(){ - var t = this.tree; - var af = this.filtered; - for(var id in af){ - if(typeof id != "function"){ - var n = af[id]; - if(n){ - n.ui.show(); - } - } + // private + deferHide : function(){ + delete this.hideTimer; + if(this.menu.over){ + this.parentMenu.setActiveItem(this, false); + }else{ + this.menu.hide(); } - this.filtered = {}; } -}; -/** - * @class Ext.tree.TreeSorter - * Provides sorting of nodes in a {@link Ext.tree.TreePanel}. The TreeSorter automatically monitors events on the - * associated TreePanel that might affect the tree's sort order (beforechildrenrendered, append, insert and textchange). - * Example usage: - * -new Ext.tree.TreeSorter(myTree, { - folderSort: true, - dir: "desc", - sortType: function(node) { - // sort by a custom, typed attribute: - return parseInt(node.id, 10); - } -}); - - * @constructor - * @param {TreePanel} tree - * @param {Object} config - */ -Ext.tree.TreeSorter = function(tree, config){ - /** - * @cfg {Boolean} folderSort True to sort leaf nodes under non-leaf nodes (defaults to false) - */ - /** - * @cfg {String} property The named attribute on the node to sort by (defaults to "text"). Note that this - * property is only used if no {@link #sortType} function is specified, otherwise it is ignored. - */ - /** - * @cfg {String} dir The direction to sort ("asc" or "desc," case-insensitive, defaults to "asc") - */ - /** - * @cfg {String} leafAttr The attribute used to determine leaf nodes when {@link #folderSort} = true (defaults to "leaf") - */ - /** - * @cfg {Boolean} caseSensitive true for case-sensitive sort (defaults to false) - */ - /** - * @cfg {Function} sortType A custom "casting" function used to convert node values before sorting. The function - * will be called with a single parameter (the {@link Ext.tree.TreeNode} being evaluated) and is expected to return - * the node's sort value cast to the specific data type required for sorting. This could be used, for example, when - * a node's text (or other attribute) should be sorted as a date or numeric value. See the class description for - * example usage. Note that if a sortType is specified, any {@link #property} config will be ignored. - */ - - Ext.apply(this, config); - tree.on("beforechildrenrendered", this.doSort, this); - tree.on("append", this.updateSort, this); - tree.on("insert", this.updateSort, this); - tree.on("textchange", this.updateSortParent, this); - - var dsc = this.dir && this.dir.toLowerCase() == "desc"; - var p = this.property || "text"; - var sortType = this.sortType; - var fs = this.folderSort; - var cs = this.caseSensitive === true; - var leafAttr = this.leafAttr || 'leaf'; - - this.sortFn = function(n1, n2){ - if(fs){ - if(n1.attributes[leafAttr] && !n2.attributes[leafAttr]){ - return 1; - } - if(!n1.attributes[leafAttr] && n2.attributes[leafAttr]){ - return -1; - } - } - var v1 = sortType ? sortType(n1) : (cs ? n1.attributes[p] : n1.attributes[p].toUpperCase()); - var v2 = sortType ? sortType(n2) : (cs ? n2.attributes[p] : n2.attributes[p].toUpperCase()); - if(v1 < v2){ - return dsc ? +1 : -1; - }else if(v1 > v2){ - return dsc ? -1 : +1; - }else{ - return 0; - } - }; -}; - -Ext.tree.TreeSorter.prototype = { - doSort : function(node){ - node.sort(this.sortFn); - }, - - compareNodes : function(n1, n2){ - return (n1.text.toUpperCase() > n2.text.toUpperCase() ? 1 : -1); - }, - - updateSort : function(tree, node){ - if(node.childrenRendered){ - this.doSort.defer(1, this, [node]); - } - }, - - updateSortParent : function(node){ - var p = node.parentNode; - if(p && p.childrenRendered){ - this.doSort.defer(1, this, [p]); - } - } -};/** - * @class Ext.tree.TreeDropZone - * @extends Ext.dd.DropZone - * @constructor - * @param {String/HTMLElement/Element} tree The {@link Ext.tree.TreePanel} for which to enable dropping - * @param {Object} config - */ -if(Ext.dd.DropZone){ - -Ext.tree.TreeDropZone = function(tree, config){ - /** - * @cfg {Boolean} allowParentInsert - * Allow inserting a dragged node between an expanded parent node and its first child that will become a - * sibling of the parent when dropped (defaults to false) - */ - this.allowParentInsert = config.allowParentInsert || false; - /** - * @cfg {String} allowContainerDrop - * True if drops on the tree container (outside of a specific tree node) are allowed (defaults to false) - */ - this.allowContainerDrop = config.allowContainerDrop || false; - /** - * @cfg {String} appendOnly - * True if the tree should only allow append drops (use for trees which are sorted, defaults to false) - */ - this.appendOnly = config.appendOnly || false; - - Ext.tree.TreeDropZone.superclass.constructor.call(this, tree.getTreeEl(), config); - /** - * The TreePanel for this drop zone - * @type Ext.tree.TreePanel - * @property - */ - this.tree = tree; - /** - * Arbitrary data that can be associated with this tree and will be included in the event object that gets - * passed to any nodedragover event handler (defaults to {}) - * @type Ext.tree.TreePanel - * @property - */ - this.dragOverData = {}; - // private - this.lastInsertClass = "x-tree-no-status"; -}; - -Ext.extend(Ext.tree.TreeDropZone, Ext.dd.DropZone, { - /** - * @cfg {String} ddGroup - * A named drag drop group to which this object belongs. If a group is specified, then this object will only - * interact with other drag drop objects in the same group (defaults to 'TreeDD'). - */ - ddGroup : "TreeDD", - - /** - * @cfg {String} expandDelay - * The delay in milliseconds to wait before expanding a target tree node while dragging a droppable node - * over the target (defaults to 1000) - */ - expandDelay : 1000, - - // private - expandNode : function(node){ - if(node.hasChildNodes() && !node.isExpanded()){ - node.expand(false, null, this.triggerCacheRefresh.createDelegate(this)); - } - }, - - // private - queueExpand : function(node){ - this.expandProcId = this.expandNode.defer(this.expandDelay, this, [node]); - }, - - // private - cancelExpand : function(){ - if(this.expandProcId){ - clearTimeout(this.expandProcId); - this.expandProcId = false; - } - }, - - // private - isValidDropPoint : function(n, pt, dd, e, data){ - if(!n || !data){ return false; } - var targetNode = n.node; - var dropNode = data.node; - // default drop rules - if(!(targetNode && targetNode.isTarget && pt)){ - return false; - } - if(pt == "append" && targetNode.allowChildren === false){ - return false; - } - if((pt == "above" || pt == "below") && (targetNode.parentNode && targetNode.parentNode.allowChildren === false)){ - return false; - } - if(dropNode && (targetNode == dropNode || dropNode.contains(targetNode))){ - return false; - } - // reuse the object - var overEvent = this.dragOverData; - overEvent.tree = this.tree; - overEvent.target = targetNode; - overEvent.data = data; - overEvent.point = pt; - overEvent.source = dd; - overEvent.rawEvent = e; - overEvent.dropNode = dropNode; - overEvent.cancel = false; - var result = this.tree.fireEvent("nodedragover", overEvent); - return overEvent.cancel === false && result !== false; - }, - - // private - getDropPoint : function(e, n, dd){ - var tn = n.node; - if(tn.isRoot){ - return tn.allowChildren !== false ? "append" : false; // always append for root - } - var dragEl = n.ddel; - var t = Ext.lib.Dom.getY(dragEl), b = t + dragEl.offsetHeight; - var y = Ext.lib.Event.getPageY(e); - var noAppend = tn.allowChildren === false || tn.isLeaf(); - if(this.appendOnly || tn.parentNode.allowChildren === false){ - return noAppend ? false : "append"; - } - var noBelow = false; - if(!this.allowParentInsert){ - noBelow = tn.hasChildNodes() && tn.isExpanded(); - } - var q = (b - t) / (noAppend ? 2 : 3); - if(y >= t && y < (t + q)){ - return "above"; - }else if(!noBelow && (noAppend || y >= b-q && y <= b)){ - return "below"; - }else{ - return "append"; - } - }, - - // private - onNodeEnter : function(n, dd, e, data){ - this.cancelExpand(); - }, - - onContainerOver : function(dd, e, data) { - if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) { - return this.dropAllowed; - } - return this.dropNotAllowed; - }, - - // private - onNodeOver : function(n, dd, e, data){ - var pt = this.getDropPoint(e, n, dd); - var node = n.node; - - // auto node expand check - if(!this.expandProcId && pt == "append" && node.hasChildNodes() && !n.node.isExpanded()){ - this.queueExpand(node); - }else if(pt != "append"){ - this.cancelExpand(); - } - - // set the insert point style on the target node - var returnCls = this.dropNotAllowed; - if(this.isValidDropPoint(n, pt, dd, e, data)){ - if(pt){ - var el = n.ddel; - var cls; - if(pt == "above"){ - returnCls = n.node.isFirst() ? "x-tree-drop-ok-above" : "x-tree-drop-ok-between"; - cls = "x-tree-drag-insert-above"; - }else if(pt == "below"){ - returnCls = n.node.isLast() ? "x-tree-drop-ok-below" : "x-tree-drop-ok-between"; - cls = "x-tree-drag-insert-below"; - }else{ - returnCls = "x-tree-drop-ok-append"; - cls = "x-tree-drag-append"; - } - if(this.lastInsertClass != cls){ - Ext.fly(el).replaceClass(this.lastInsertClass, cls); - this.lastInsertClass = cls; - } - } - } - return returnCls; - }, - - // private - onNodeOut : function(n, dd, e, data){ - this.cancelExpand(); - this.removeDropIndicators(n); - }, - - // private - onNodeDrop : function(n, dd, e, data){ - var point = this.getDropPoint(e, n, dd); - var targetNode = n.node; - targetNode.ui.startDrop(); - if(!this.isValidDropPoint(n, point, dd, e, data)){ - targetNode.ui.endDrop(); - return false; - } - // first try to find the drop node - var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, point, e) : null); - return this.processDrop(targetNode, data, point, dd, e, dropNode); - }, - - onContainerDrop : function(dd, e, data){ - if (this.allowContainerDrop && this.isValidDropPoint({ ddel: this.tree.getRootNode().ui.elNode, node: this.tree.getRootNode() }, "append", dd, e, data)) { - var targetNode = this.tree.getRootNode(); - targetNode.ui.startDrop(); - var dropNode = data.node || (dd.getTreeNode ? dd.getTreeNode(data, targetNode, 'append', e) : null); - return this.processDrop(targetNode, data, 'append', dd, e, dropNode); - } - return false; - }, - - // private - processDrop: function(target, data, point, dd, e, dropNode){ - var dropEvent = { - tree : this.tree, - target: target, - data: data, - point: point, - source: dd, - rawEvent: e, - dropNode: dropNode, - cancel: !dropNode, - dropStatus: false - }; - var retval = this.tree.fireEvent("beforenodedrop", dropEvent); - if(retval === false || dropEvent.cancel === true || !dropEvent.dropNode){ - target.ui.endDrop(); - return dropEvent.dropStatus; - } - - target = dropEvent.target; - if(point == 'append' && !target.isExpanded()){ - target.expand(false, null, function(){ - this.completeDrop(dropEvent); - }.createDelegate(this)); - }else{ - this.completeDrop(dropEvent); - } - return true; - }, - - // private - completeDrop : function(de){ - var ns = de.dropNode, p = de.point, t = de.target; - if(!Ext.isArray(ns)){ - ns = [ns]; - } - var n; - for(var i = 0, len = ns.length; i < len; i++){ - n = ns[i]; - if(p == "above"){ - t.parentNode.insertBefore(n, t); - }else if(p == "below"){ - t.parentNode.insertBefore(n, t.nextSibling); - }else{ - t.appendChild(n); - } - } - n.ui.focus(); - if(Ext.enableFx && this.tree.hlDrop){ - n.ui.highlight(); - } - t.ui.endDrop(); - this.tree.fireEvent("nodedrop", de); - }, - - // private - afterNodeMoved : function(dd, data, e, targetNode, dropNode){ - if(Ext.enableFx && this.tree.hlDrop){ - dropNode.ui.focus(); - dropNode.ui.highlight(); - } - this.tree.fireEvent("nodedrop", this.tree, targetNode, data, dd, e); - }, - - // private - getTree : function(){ - return this.tree; - }, - - // private - removeDropIndicators : function(n){ - if(n && n.ddel){ - var el = n.ddel; - Ext.fly(el).removeClass([ - "x-tree-drag-insert-above", - "x-tree-drag-insert-below", - "x-tree-drag-append"]); - this.lastInsertClass = "_noclass"; - } - }, - - // private - beforeDragDrop : function(target, e, id){ - this.cancelExpand(); - return true; - }, - - // private - afterRepair : function(data){ - if(data && Ext.enableFx){ - data.node.ui.highlight(); - } - this.hideProxy(); - } -}); - -}/** - * @class Ext.tree.TreeDragZone - * @extends Ext.dd.DragZone - * @constructor - * @param {String/HTMLElement/Element} tree The {@link Ext.tree.TreePanel} for which to enable dragging - * @param {Object} config - */ -if(Ext.dd.DragZone){ -Ext.tree.TreeDragZone = function(tree, config){ - Ext.tree.TreeDragZone.superclass.constructor.call(this, tree.innerCt, config); - /** - * The TreePanel for this drag zone - * @type Ext.tree.TreePanel - * @property - */ - this.tree = tree; -}; - -Ext.extend(Ext.tree.TreeDragZone, Ext.dd.DragZone, { - /** - * @cfg {String} ddGroup - * A named drag drop group to which this object belongs. If a group is specified, then this object will only - * interact with other drag drop objects in the same group (defaults to 'TreeDD'). - */ - ddGroup : "TreeDD", - - // private - onBeforeDrag : function(data, e){ - var n = data.node; - return n && n.draggable && !n.disabled; - }, - - // private - onInitDrag : function(e){ - var data = this.dragData; - this.tree.getSelectionModel().select(data.node); - this.tree.eventModel.disable(); - this.proxy.update(""); - data.node.ui.appendDDGhost(this.proxy.ghost.dom); - this.tree.fireEvent("startdrag", this.tree, data.node, e); - }, - - // private - getRepairXY : function(e, data){ - return data.node.ui.getDDRepairXY(); - }, - - // private - onEndDrag : function(data, e){ - this.tree.eventModel.enable.defer(100, this.tree.eventModel); - this.tree.fireEvent("enddrag", this.tree, data.node, e); - }, - - // private - onValidDrop : function(dd, e, id){ - this.tree.fireEvent("dragdrop", this.tree, this.dragData.node, dd, e); - this.hideProxy(); - }, - - // private - beforeInvalidDrop : function(e, id){ - // this scrolls the original position back into view - var sm = this.tree.getSelectionModel(); - sm.clearSelections(); - sm.select(this.dragData.node); - }, - - // private - afterRepair : function(){ - if (Ext.enableFx && this.tree.hlDrop) { - Ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || "c3daf9"); - } - this.dragging = false; - } -}); -}/** - * @class Ext.tree.TreeEditor - * @extends Ext.Editor - * Provides editor functionality for inline tree node editing. Any valid {@link Ext.form.Field} subclass can be used - * as the editor field. +}); +Ext.reg('menuitem', Ext.menu.Item);/** + * @class Ext.menu.CheckItem + * @extends Ext.menu.Item + * Adds a menu item that contains a checkbox by default, but can also be part of a radio group. * @constructor - * @param {TreePanel} tree - * @param {Object} fieldConfig (optional) Either a prebuilt {@link Ext.form.Field} instance or a Field config object - * that will be applied to the default field instance (defaults to a {@link Ext.form.TextField}). - * @param {Object} config (optional) A TreeEditor config object + * Creates a new CheckItem + * @param {Object} config Configuration options + * @xtype menucheckitem */ -Ext.tree.TreeEditor = function(tree, fc, config){ - fc = fc || {}; - var field = fc.events ? fc : new Ext.form.TextField(fc); - - Ext.tree.TreeEditor.superclass.constructor.call(this, field, config); - - this.tree = tree; - - if(!tree.rendered){ - tree.on('render', this.initEditor, this); - }else{ - this.initEditor(tree); - } -}; - -Ext.extend(Ext.tree.TreeEditor, Ext.Editor, { - /** - * @cfg {String} alignment - * The position to align to (see {@link Ext.Element#alignTo} for more details, defaults to "l-l"). - */ - alignment: "l-l", - // inherit - autoSize: false, - /** - * @cfg {Boolean} hideEl - * True to hide the bound element while the editor is displayed (defaults to false) - */ - hideEl : false, - /** - * @cfg {String} cls - * CSS class to apply to the editor (defaults to "x-small-editor x-tree-editor") - */ - cls: "x-small-editor x-tree-editor", +Ext.menu.CheckItem = Ext.extend(Ext.menu.Item, { /** - * @cfg {Boolean} shim - * True to shim the editor if selects/iframes could be displayed beneath it (defaults to false) + * @cfg {String} group + * All check items with the same group name will automatically be grouped into a single-select + * radio button group (defaults to '') */ - shim:false, - // inherit - shadow:"frame", /** - * @cfg {Number} maxWidth - * The maximum width in pixels of the editor field (defaults to 250). Note that if the maxWidth would exceed - * the containing tree element's size, it will be automatically limited for you to the container width, taking - * scroll and client offsets into account prior to each edit. + * @cfg {String} itemCls The default CSS class to use for check items (defaults to "x-menu-item x-menu-check-item") */ - maxWidth: 250, + itemCls : "x-menu-item x-menu-check-item", /** - * @cfg {Number} editDelay The number of milliseconds between clicks to register a double-click that will trigger - * editing on the current node (defaults to 350). If two clicks occur on the same node within this time span, - * the editor for the node will display, otherwise it will be processed as a regular click. + * @cfg {String} groupClass The default CSS class to use for radio group check items (defaults to "x-menu-group-item") */ - editDelay : 350, - - initEditor : function(tree){ - tree.on({ - scope : this, - beforeclick: this.beforeNodeClick, - dblclick : this.onNodeDblClick - }); - - this.on({ - scope : this, - complete : this.updateNode, - beforestartedit: this.fitToTree, - specialkey : this.onSpecialKey - }); - - this.on('startedit', this.bindScroll, this, {delay:10}); - }, - - // private - fitToTree : function(ed, el){ - var td = this.tree.getTreeEl().dom, nd = el.dom; - if(td.scrollLeft > nd.offsetLeft){ // ensure the node left point is visible - td.scrollLeft = nd.offsetLeft; - } - var w = Math.min( - this.maxWidth, - (td.clientWidth > 20 ? td.clientWidth : td.offsetWidth) - Math.max(0, nd.offsetLeft-td.scrollLeft) - /*cushion*/5); - this.setSize(w, ''); - }, + groupClass : "x-menu-group-item", /** - * Edit the text of the passed {@link Ext.tree.TreeNode TreeNode}. - * @param node {Ext.tree.TreeNode} The TreeNode to edit. The TreeNode must be {@link Ext.tree.TreeNode#editable editable}. + * @cfg {Boolean} checked True to initialize this checkbox as checked (defaults to false). Note that + * if this checkbox is part of a radio group (group = true) only the last item in the group that is + * initialized with checked = true will be rendered as checked. */ - triggerEdit : function(node, defer){ - this.completeEdit(); - if(node.attributes.editable !== false){ - /** - * The {@link Ext.tree.TreeNode TreeNode} this editor is bound to. Read-only. - * @type Ext.tree.TreeNode - * @property editNode - */ - this.editNode = node; - if(this.tree.autoScroll){ - Ext.fly(node.ui.getEl()).scrollIntoView(this.tree.body); - } - var value = node.text || ''; - if (!Ext.isGecko && Ext.isEmpty(node.text)){ - node.setText(' '); - } - this.autoEditTimer = this.startEdit.defer(this.editDelay, this, [node.ui.textNode, value]); - return false; - } - }, + checked: false, // private - bindScroll : function(){ - this.tree.getTreeEl().on('scroll', this.cancelEdit, this); + ctype: "Ext.menu.CheckItem", + + initComponent : function(){ + Ext.menu.CheckItem.superclass.initComponent.call(this); + this.addEvents( + /** + * @event beforecheckchange + * Fires before the checked value is set, providing an opportunity to cancel if needed + * @param {Ext.menu.CheckItem} this + * @param {Boolean} checked The new checked value that will be set + */ + "beforecheckchange" , + /** + * @event checkchange + * Fires after the checked value has been set + * @param {Ext.menu.CheckItem} this + * @param {Boolean} checked The checked value that was set + */ + "checkchange" + ); + /** + * A function that handles the checkchange event. The function is undefined by default, but if an implementation + * is provided, it will be called automatically when the checkchange event fires. + * @param {Ext.menu.CheckItem} this + * @param {Boolean} checked The checked value that was set + * @method checkHandler + */ + if(this.checkHandler){ + this.on('checkchange', this.checkHandler, this.scope); + } + Ext.menu.MenuMgr.registerCheckable(this); }, // private - beforeNodeClick : function(node, e){ - clearTimeout(this.autoEditTimer); - if(this.tree.getSelectionModel().isSelected(node)){ - e.stopEvent(); - return this.triggerEdit(node); + onRender : function(c){ + Ext.menu.CheckItem.superclass.onRender.apply(this, arguments); + if(this.group){ + this.el.addClass(this.groupClass); + } + if(this.checked){ + this.checked = false; + this.setChecked(true, true); } }, - onNodeDblClick : function(node, e){ - clearTimeout(this.autoEditTimer); - }, - // private - updateNode : function(ed, value){ - this.tree.getTreeEl().un('scroll', this.cancelEdit, this); - this.editNode.setText(value); + destroy : function(){ + Ext.menu.MenuMgr.unregisterCheckable(this); + Ext.menu.CheckItem.superclass.destroy.apply(this, arguments); }, - // private - onHide : function(){ - Ext.tree.TreeEditor.superclass.onHide.call(this); - if(this.editNode){ - this.editNode.ui.focus.defer(50, this.editNode.ui); + /** + * Set the checked state of this item + * @param {Boolean} checked The new checked value + * @param {Boolean} suppressEvent (optional) True to prevent the checkchange event from firing (defaults to false) + */ + setChecked : function(state, suppressEvent){ + var suppress = suppressEvent === true; + if(this.checked != state && (suppress || this.fireEvent("beforecheckchange", this, state) !== false)){ + if(this.container){ + this.container[state ? "addClass" : "removeClass"]("x-menu-item-checked"); + } + this.checked = state; + if(!suppress){ + this.fireEvent("checkchange", this, state); + } } }, // private - onSpecialKey : function(field, e){ - var k = e.getKey(); - if(k == e.ESC){ - e.stopEvent(); - this.cancelEdit(); - }else if(k == e.ENTER && !e.hasModifier()){ - e.stopEvent(); - this.completeEdit(); - } - }, - - onDestroy : function(){ - clearTimeout(this.autoEditTimer); - Ext.tree.TreeEditor.superclass.onDestroy.call(this); - var tree = this.tree; - tree.un('beforeclick', this.beforeNodeClick, this); - tree.un('dblclick', this.onNodeDblClick, this); + handleClick : function(e){ + if(!this.disabled && !(this.checked && this.group)){// disable unselect on radio item + this.setChecked(!this.checked); + } + Ext.menu.CheckItem.superclass.handleClick.apply(this, arguments); } -});/*! SWFObject v2.2 - is released under the MIT License -*/ - -var swfobject = function() { - - var UNDEF = "undefined", - OBJECT = "object", - SHOCKWAVE_FLASH = "Shockwave Flash", - SHOCKWAVE_FLASH_AX = "ShockwaveFlash.ShockwaveFlash", - FLASH_MIME_TYPE = "application/x-shockwave-flash", - EXPRESS_INSTALL_ID = "SWFObjectExprInst", - ON_READY_STATE_CHANGE = "onreadystatechange", - - win = window, - doc = document, - nav = navigator, - - plugin = false, - domLoadFnArr = [main], - regObjArr = [], - objIdArr = [], - listenersArr = [], - storedAltContent, - storedAltContentId, - storedCallbackFn, - storedCallbackObj, - isDomLoaded = false, - isExpressInstallActive = false, - dynamicStylesheet, - dynamicStylesheetMedia, - autoHideShow = true, - - /* Centralized function for browser feature detection - - User agent string detection is only used when no good alternative is possible - - Is executed directly for optimal performance - */ - ua = function() { - var w3cdom = typeof doc.getElementById != UNDEF && typeof doc.getElementsByTagName != UNDEF && typeof doc.createElement != UNDEF, - u = nav.userAgent.toLowerCase(), - p = nav.platform.toLowerCase(), - windows = p ? /win/.test(p) : /win/.test(u), - mac = p ? /mac/.test(p) : /mac/.test(u), - webkit = /webkit/.test(u) ? parseFloat(u.replace(/^.*webkit\/(\d+(\.\d+)?).*$/, "$1")) : false, // returns either the webkit version or false if not webkit - ie = !+"\v1", // feature detection based on Andrea Giammarchi's solution: http://webreflection.blogspot.com/2009/01/32-bytes-to-know-if-your-browser-is-ie.html - playerVersion = [0,0,0], - d = null; - if (typeof nav.plugins != UNDEF && typeof nav.plugins[SHOCKWAVE_FLASH] == OBJECT) { - d = nav.plugins[SHOCKWAVE_FLASH].description; - if (d && !(typeof nav.mimeTypes != UNDEF && nav.mimeTypes[FLASH_MIME_TYPE] && !nav.mimeTypes[FLASH_MIME_TYPE].enabledPlugin)) { // navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin indicates whether plug-ins are enabled or disabled in Safari 3+ - plugin = true; - ie = false; // cascaded feature detection for Internet Explorer - d = d.replace(/^.*\s+(\S+\s+\S+$)/, "$1"); - playerVersion[0] = parseInt(d.replace(/^(.*)\..*$/, "$1"), 10); - playerVersion[1] = parseInt(d.replace(/^.*\.(.*)\s.*$/, "$1"), 10); - playerVersion[2] = /[a-zA-Z]/.test(d) ? parseInt(d.replace(/^.*[a-zA-Z]+(.*)$/, "$1"), 10) : 0; - } - } - else if (typeof win.ActiveXObject != UNDEF) { - try { - var a = new ActiveXObject(SHOCKWAVE_FLASH_AX); - if (a) { // a will return null when ActiveX is disabled - d = a.GetVariable("$version"); - if (d) { - ie = true; // cascaded feature detection for Internet Explorer - d = d.split(" ")[1].split(","); - playerVersion = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)]; - } - } - } - catch(e) {} - } - return { w3:w3cdom, pv:playerVersion, wk:webkit, ie:ie, win:windows, mac:mac }; - }(), - - /* Cross-browser onDomLoad - - Will fire an event as soon as the DOM of a web page is loaded - - Internet Explorer workaround based on Diego Perini's solution: http://javascript.nwbox.com/IEContentLoaded/ - - Regular onload serves as fallback - */ - onDomLoad = function() { - if (!ua.w3) { return; } - if ((typeof doc.readyState != UNDEF && doc.readyState == "complete") || (typeof doc.readyState == UNDEF && (doc.getElementsByTagName("body")[0] || doc.body))) { // function is fired after onload, e.g. when script is inserted dynamically - callDomLoadFunctions(); - } - if (!isDomLoaded) { - if (typeof doc.addEventListener != UNDEF) { - doc.addEventListener("DOMContentLoaded", callDomLoadFunctions, false); - } - if (ua.ie && ua.win) { - doc.attachEvent(ON_READY_STATE_CHANGE, function() { - if (doc.readyState == "complete") { - doc.detachEvent(ON_READY_STATE_CHANGE, arguments.callee); - callDomLoadFunctions(); - } - }); - if (win == top) { // if not inside an iframe - (function(){ - if (isDomLoaded) { return; } - try { - doc.documentElement.doScroll("left"); - } - catch(e) { - setTimeout(arguments.callee, 0); - return; - } - callDomLoadFunctions(); - })(); - } - } - if (ua.wk) { - (function(){ - if (isDomLoaded) { return; } - if (!/loaded|complete/.test(doc.readyState)) { - setTimeout(arguments.callee, 0); - return; - } - callDomLoadFunctions(); - })(); - } - addLoadEvent(callDomLoadFunctions); - } - }(); - - function callDomLoadFunctions() { - if (isDomLoaded) { return; } - try { // test if we can really add/remove elements to/from the DOM; we don't want to fire it too early - var t = doc.getElementsByTagName("body")[0].appendChild(createElement("span")); - t.parentNode.removeChild(t); - } - catch (e) { return; } - isDomLoaded = true; - var dl = domLoadFnArr.length; - for (var i = 0; i < dl; i++) { - domLoadFnArr[i](); - } - } - - function addDomLoadEvent(fn) { - if (isDomLoaded) { - fn(); - } - else { - domLoadFnArr[domLoadFnArr.length] = fn; // Array.push() is only available in IE5.5+ - } - } - - /* Cross-browser onload - - Based on James Edwards' solution: http://brothercake.com/site/resources/scripts/onload/ - - Will fire an event as soon as a web page including all of its assets are loaded - */ - function addLoadEvent(fn) { - if (typeof win.addEventListener != UNDEF) { - win.addEventListener("load", fn, false); - } - else if (typeof doc.addEventListener != UNDEF) { - doc.addEventListener("load", fn, false); - } - else if (typeof win.attachEvent != UNDEF) { - addListener(win, "onload", fn); - } - else if (typeof win.onload == "function") { - var fnOld = win.onload; - win.onload = function() { - fnOld(); - fn(); - }; - } - else { - win.onload = fn; - } - } - - /* Main function - - Will preferably execute onDomLoad, otherwise onload (as a fallback) - */ - function main() { - if (plugin) { - testPlayerVersion(); - } - else { - matchVersions(); - } - } - - /* Detect the Flash Player version for non-Internet Explorer browsers - - Detecting the plug-in version via the object element is more precise than using the plugins collection item's description: - a. Both release and build numbers can be detected - b. Avoid wrong descriptions by corrupt installers provided by Adobe - c. Avoid wrong descriptions by multiple Flash Player entries in the plugin Array, caused by incorrect browser imports - - Disadvantage of this method is that it depends on the availability of the DOM, while the plugins collection is immediately available - */ - function testPlayerVersion() { - var b = doc.getElementsByTagName("body")[0]; - var o = createElement(OBJECT); - o.setAttribute("type", FLASH_MIME_TYPE); - var t = b.appendChild(o); - if (t) { - var counter = 0; - (function(){ - if (typeof t.GetVariable != UNDEF) { - var d = t.GetVariable("$version"); - if (d) { - d = d.split(" ")[1].split(","); - ua.pv = [parseInt(d[0], 10), parseInt(d[1], 10), parseInt(d[2], 10)]; - } - } - else if (counter < 10) { - counter++; - setTimeout(arguments.callee, 10); - return; - } - b.removeChild(o); - t = null; - matchVersions(); - })(); - } - else { - matchVersions(); - } - } - - /* Perform Flash Player and SWF version matching; static publishing only - */ - function matchVersions() { - var rl = regObjArr.length; - if (rl > 0) { - for (var i = 0; i < rl; i++) { // for each registered object element - var id = regObjArr[i].id; - var cb = regObjArr[i].callbackFn; - var cbObj = {success:false, id:id}; - if (ua.pv[0] > 0) { - var obj = getElementById(id); - if (obj) { - if (hasPlayerVersion(regObjArr[i].swfVersion) && !(ua.wk && ua.wk < 312)) { // Flash Player version >= published SWF version: Houston, we have a match! - setVisibility(id, true); - if (cb) { - cbObj.success = true; - cbObj.ref = getObjectById(id); - cb(cbObj); - } - } - else if (regObjArr[i].expressInstall && canExpressInstall()) { // show the Adobe Express Install dialog if set by the web page author and if supported - var att = {}; - att.data = regObjArr[i].expressInstall; - att.width = obj.getAttribute("width") || "0"; - att.height = obj.getAttribute("height") || "0"; - if (obj.getAttribute("class")) { att.styleclass = obj.getAttribute("class"); } - if (obj.getAttribute("align")) { att.align = obj.getAttribute("align"); } - // parse HTML object param element's name-value pairs - var par = {}; - var p = obj.getElementsByTagName("param"); - var pl = p.length; - for (var j = 0; j < pl; j++) { - if (p[j].getAttribute("name").toLowerCase() != "movie") { - par[p[j].getAttribute("name")] = p[j].getAttribute("value"); - } - } - showExpressInstall(att, par, id, cb); - } - else { // Flash Player and SWF version mismatch or an older Webkit engine that ignores the HTML object element's nested param elements: display alternative content instead of SWF - displayAltContent(obj); - if (cb) { cb(cbObj); } - } - } - } - else { // if no Flash Player is installed or the fp version cannot be detected we let the HTML object element do its job (either show a SWF or alternative content) - setVisibility(id, true); - if (cb) { - var o = getObjectById(id); // test whether there is an HTML object element or not - if (o && typeof o.SetVariable != UNDEF) { - cbObj.success = true; - cbObj.ref = o; - } - cb(cbObj); - } - } - } - } - } - - function getObjectById(objectIdStr) { - var r = null; - var o = getElementById(objectIdStr); - if (o && o.nodeName == "OBJECT") { - if (typeof o.SetVariable != UNDEF) { - r = o; - } - else { - var n = o.getElementsByTagName(OBJECT)[0]; - if (n) { - r = n; - } - } - } - return r; - } - - /* Requirements for Adobe Express Install - - only one instance can be active at a time - - fp 6.0.65 or higher - - Win/Mac OS only - - no Webkit engines older than version 312 - */ - function canExpressInstall() { - return !isExpressInstallActive && hasPlayerVersion("6.0.65") && (ua.win || ua.mac) && !(ua.wk && ua.wk < 312); - } - - /* Show the Adobe Express Install dialog - - Reference: http://www.adobe.com/cfusion/knowledgebase/index.cfm?id=6a253b75 - */ - function showExpressInstall(att, par, replaceElemIdStr, callbackFn) { - isExpressInstallActive = true; - storedCallbackFn = callbackFn || null; - storedCallbackObj = {success:false, id:replaceElemIdStr}; - var obj = getElementById(replaceElemIdStr); - if (obj) { - if (obj.nodeName == "OBJECT") { // static publishing - storedAltContent = abstractAltContent(obj); - storedAltContentId = null; - } - else { // dynamic publishing - storedAltContent = obj; - storedAltContentId = replaceElemIdStr; - } - att.id = EXPRESS_INSTALL_ID; - if (typeof att.width == UNDEF || (!/%$/.test(att.width) && parseInt(att.width, 10) < 310)) { att.width = "310"; } - if (typeof att.height == UNDEF || (!/%$/.test(att.height) && parseInt(att.height, 10) < 137)) { att.height = "137"; } - doc.title = doc.title.slice(0, 47) + " - Flash Player Installation"; - var pt = ua.ie && ua.win ? "ActiveX" : "PlugIn", - fv = "MMredirectURL=" + win.location.toString().replace(/&/g,"%26") + "&MMplayerType=" + pt + "&MMdoctitle=" + doc.title; - if (typeof par.flashvars != UNDEF) { - par.flashvars += "&" + fv; - } - else { - par.flashvars = fv; - } - // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, - // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work - if (ua.ie && ua.win && obj.readyState != 4) { - var newObj = createElement("div"); - replaceElemIdStr += "SWFObjectNew"; - newObj.setAttribute("id", replaceElemIdStr); - obj.parentNode.insertBefore(newObj, obj); // insert placeholder div that will be replaced by the object element that loads expressinstall.swf - obj.style.display = "none"; - (function(){ - if (obj.readyState == 4) { - obj.parentNode.removeChild(obj); - } - else { - setTimeout(arguments.callee, 10); - } - })(); - } - createSWF(att, par, replaceElemIdStr); - } - } - - /* Functions to abstract and display alternative content - */ - function displayAltContent(obj) { - if (ua.ie && ua.win && obj.readyState != 4) { - // IE only: when a SWF is loading (AND: not available in cache) wait for the readyState of the object element to become 4 before removing it, - // because you cannot properly cancel a loading SWF file without breaking browser load references, also obj.onreadystatechange doesn't work - var el = createElement("div"); - obj.parentNode.insertBefore(el, obj); // insert placeholder div that will be replaced by the alternative content - el.parentNode.replaceChild(abstractAltContent(obj), el); - obj.style.display = "none"; - (function(){ - if (obj.readyState == 4) { - obj.parentNode.removeChild(obj); - } - else { - setTimeout(arguments.callee, 10); - } - })(); - } - else { - obj.parentNode.replaceChild(abstractAltContent(obj), obj); - } - } - - function abstractAltContent(obj) { - var ac = createElement("div"); - if (ua.win && ua.ie) { - ac.innerHTML = obj.innerHTML; - } - else { - var nestedObj = obj.getElementsByTagName(OBJECT)[0]; - if (nestedObj) { - var c = nestedObj.childNodes; - if (c) { - var cl = c.length; - for (var i = 0; i < cl; i++) { - if (!(c[i].nodeType == 1 && c[i].nodeName == "PARAM") && !(c[i].nodeType == 8)) { - ac.appendChild(c[i].cloneNode(true)); - } - } - } - } - } - return ac; - } - - /* Cross-browser dynamic SWF creation - */ - function createSWF(attObj, parObj, id) { - var r, el = getElementById(id); - if (ua.wk && ua.wk < 312) { return r; } - if (el) { - if (typeof attObj.id == UNDEF) { // if no 'id' is defined for the object element, it will inherit the 'id' from the alternative content - attObj.id = id; - } - if (ua.ie && ua.win) { // Internet Explorer + the HTML object element + W3C DOM methods do not combine: fall back to outerHTML - var att = ""; - for (var i in attObj) { - if (attObj[i] != Object.prototype[i]) { // filter out prototype additions from other potential libraries - if (i.toLowerCase() == "data") { - parObj.movie = attObj[i]; - } - else if (i.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword - att += ' class="' + attObj[i] + '"'; - } - else if (i.toLowerCase() != "classid") { - att += ' ' + i + '="' + attObj[i] + '"'; - } - } - } - var par = ""; - for (var j in parObj) { - if (parObj[j] != Object.prototype[j]) { // filter out prototype additions from other potential libraries - par += ''; - } - } - el.outerHTML = ''; - objIdArr[objIdArr.length] = attObj.id; // stored to fix object 'leaks' on unload (dynamic publishing only) - r = getElementById(attObj.id); - } - else { // well-behaving browsers - var o = createElement(OBJECT); - o.setAttribute("type", FLASH_MIME_TYPE); - for (var m in attObj) { - if (attObj[m] != Object.prototype[m]) { // filter out prototype additions from other potential libraries - if (m.toLowerCase() == "styleclass") { // 'class' is an ECMA4 reserved keyword - o.setAttribute("class", attObj[m]); - } - else if (m.toLowerCase() != "classid") { // filter out IE specific attribute - o.setAttribute(m, attObj[m]); - } - } - } - for (var n in parObj) { - if (parObj[n] != Object.prototype[n] && n.toLowerCase() != "movie") { // filter out prototype additions from other potential libraries and IE specific param element - createObjParam(o, n, parObj[n]); - } - } - el.parentNode.replaceChild(o, el); - r = o; - } - } - return r; - } - - function createObjParam(el, pName, pValue) { - var p = createElement("param"); - p.setAttribute("name", pName); - p.setAttribute("value", pValue); - el.appendChild(p); - } - - /* Cross-browser SWF removal - - Especially needed to safely and completely remove a SWF in Internet Explorer - */ - function removeSWF(id) { - var obj = getElementById(id); - if (obj && obj.nodeName == "OBJECT") { - if (ua.ie && ua.win) { - obj.style.display = "none"; - (function(){ - if (obj.readyState == 4) { - removeObjectInIE(id); - } - else { - setTimeout(arguments.callee, 10); - } - })(); - } - else { - obj.parentNode.removeChild(obj); - } - } - } - - function removeObjectInIE(id) { - var obj = getElementById(id); - if (obj) { - for (var i in obj) { - if (typeof obj[i] == "function") { - obj[i] = null; - } - } - obj.parentNode.removeChild(obj); - } - } - - /* Functions to optimize JavaScript compression - */ - function getElementById(id) { - var el = null; - try { - el = doc.getElementById(id); - } - catch (e) {} - return el; - } - - function createElement(el) { - return doc.createElement(el); - } - - /* Updated attachEvent function for Internet Explorer - - Stores attachEvent information in an Array, so on unload the detachEvent functions can be called to avoid memory leaks - */ - function addListener(target, eventType, fn) { - target.attachEvent(eventType, fn); - listenersArr[listenersArr.length] = [target, eventType, fn]; - } - - /* Flash Player and SWF content version matching - */ - function hasPlayerVersion(rv) { - var pv = ua.pv, v = rv.split("."); - v[0] = parseInt(v[0], 10); - v[1] = parseInt(v[1], 10) || 0; // supports short notation, e.g. "9" instead of "9.0.0" - v[2] = parseInt(v[2], 10) || 0; - return (pv[0] > v[0] || (pv[0] == v[0] && pv[1] > v[1]) || (pv[0] == v[0] && pv[1] == v[1] && pv[2] >= v[2])) ? true : false; - } - - /* Cross-browser dynamic CSS creation - - Based on Bobby van der Sluis' solution: http://www.bobbyvandersluis.com/articles/dynamicCSS.php - */ - function createCSS(sel, decl, media, newStyle) { - if (ua.ie && ua.mac) { return; } - var h = doc.getElementsByTagName("head")[0]; - if (!h) { return; } // to also support badly authored HTML pages that lack a head element - var m = (media && typeof media == "string") ? media : "screen"; - if (newStyle) { - dynamicStylesheet = null; - dynamicStylesheetMedia = null; - } - if (!dynamicStylesheet || dynamicStylesheetMedia != m) { - // create dynamic stylesheet + get a global reference to it - var s = createElement("style"); - s.setAttribute("type", "text/css"); - s.setAttribute("media", m); - dynamicStylesheet = h.appendChild(s); - if (ua.ie && ua.win && typeof doc.styleSheets != UNDEF && doc.styleSheets.length > 0) { - dynamicStylesheet = doc.styleSheets[doc.styleSheets.length - 1]; - } - dynamicStylesheetMedia = m; - } - // add style rule - if (ua.ie && ua.win) { - if (dynamicStylesheet && typeof dynamicStylesheet.addRule == OBJECT) { - dynamicStylesheet.addRule(sel, decl); - } - } - else { - if (dynamicStylesheet && typeof doc.createTextNode != UNDEF) { - dynamicStylesheet.appendChild(doc.createTextNode(sel + " {" + decl + "}")); - } - } - } - - function setVisibility(id, isVisible) { - if (!autoHideShow) { return; } - var v = isVisible ? "visible" : "hidden"; - if (isDomLoaded && getElementById(id)) { - getElementById(id).style.visibility = v; - } - else { - createCSS("#" + id, "visibility:" + v); - } - } - - /* Filter to avoid XSS attacks - */ - function urlEncodeIfNecessary(s) { - var regex = /[\\\"<>\.;]/; - var hasBadChars = regex.exec(s) != null; - return hasBadChars && typeof encodeURIComponent != UNDEF ? encodeURIComponent(s) : s; - } - - /* Release memory to avoid memory leaks caused by closures, fix hanging audio/video threads and force open sockets/NetConnections to disconnect (Internet Explorer only) - */ - var cleanup = function() { - if (ua.ie && ua.win) { - window.attachEvent("onunload", function() { - // remove listeners to avoid memory leaks - var ll = listenersArr.length; - for (var i = 0; i < ll; i++) { - listenersArr[i][0].detachEvent(listenersArr[i][1], listenersArr[i][2]); - } - // cleanup dynamically embedded objects to fix audio/video threads and force open sockets and NetConnections to disconnect - var il = objIdArr.length; - for (var j = 0; j < il; j++) { - removeSWF(objIdArr[j]); - } - // cleanup library's main closures to avoid memory leaks - for (var k in ua) { - ua[k] = null; - } - ua = null; - for (var l in swfobject) { - swfobject[l] = null; - } - swfobject = null; - }); - } - }(); - - return { - /* Public API - - Reference: http://code.google.com/p/swfobject/wiki/documentation - */ - registerObject: function(objectIdStr, swfVersionStr, xiSwfUrlStr, callbackFn) { - if (ua.w3 && objectIdStr && swfVersionStr) { - var regObj = {}; - regObj.id = objectIdStr; - regObj.swfVersion = swfVersionStr; - regObj.expressInstall = xiSwfUrlStr; - regObj.callbackFn = callbackFn; - regObjArr[regObjArr.length] = regObj; - setVisibility(objectIdStr, false); - } - else if (callbackFn) { - callbackFn({success:false, id:objectIdStr}); - } - }, - - getObjectById: function(objectIdStr) { - if (ua.w3) { - return getObjectById(objectIdStr); - } - }, - - embedSWF: function(swfUrlStr, replaceElemIdStr, widthStr, heightStr, swfVersionStr, xiSwfUrlStr, flashvarsObj, parObj, attObj, callbackFn) { - var callbackObj = {success:false, id:replaceElemIdStr}; - if (ua.w3 && !(ua.wk && ua.wk < 312) && swfUrlStr && replaceElemIdStr && widthStr && heightStr && swfVersionStr) { - setVisibility(replaceElemIdStr, false); - addDomLoadEvent(function() { - widthStr += ""; // auto-convert to string - heightStr += ""; - var att = {}; - if (attObj && typeof attObj === OBJECT) { - for (var i in attObj) { // copy object to avoid the use of references, because web authors often reuse attObj for multiple SWFs - att[i] = attObj[i]; - } - } - att.data = swfUrlStr; - att.width = widthStr; - att.height = heightStr; - var par = {}; - if (parObj && typeof parObj === OBJECT) { - for (var j in parObj) { // copy object to avoid the use of references, because web authors often reuse parObj for multiple SWFs - par[j] = parObj[j]; - } - } - if (flashvarsObj && typeof flashvarsObj === OBJECT) { - for (var k in flashvarsObj) { // copy object to avoid the use of references, because web authors often reuse flashvarsObj for multiple SWFs - if (typeof par.flashvars != UNDEF) { - par.flashvars += "&" + k + "=" + flashvarsObj[k]; - } - else { - par.flashvars = k + "=" + flashvarsObj[k]; - } - } - } - if (hasPlayerVersion(swfVersionStr)) { // create SWF - var obj = createSWF(att, par, replaceElemIdStr); - if (att.id == replaceElemIdStr) { - setVisibility(replaceElemIdStr, true); - } - callbackObj.success = true; - callbackObj.ref = obj; - } - else if (xiSwfUrlStr && canExpressInstall()) { // show Adobe Express Install - att.data = xiSwfUrlStr; - showExpressInstall(att, par, replaceElemIdStr, callbackFn); - return; - } - else { // show alternative content - setVisibility(replaceElemIdStr, true); - } - if (callbackFn) { callbackFn(callbackObj); } - }); - } - else if (callbackFn) { callbackFn(callbackObj); } - }, - - switchOffAutoHideShow: function() { - autoHideShow = false; - }, - - ua: ua, - - getFlashPlayerVersion: function() { - return { major:ua.pv[0], minor:ua.pv[1], release:ua.pv[2] }; - }, - - hasFlashPlayerVersion: hasPlayerVersion, - - createSWF: function(attObj, parObj, replaceElemIdStr) { - if (ua.w3) { - return createSWF(attObj, parObj, replaceElemIdStr); - } - else { - return undefined; - } - }, - - showExpressInstall: function(att, par, replaceElemIdStr, callbackFn) { - if (ua.w3 && canExpressInstall()) { - showExpressInstall(att, par, replaceElemIdStr, callbackFn); - } - }, - - removeSWF: function(objElemIdStr) { - if (ua.w3) { - removeSWF(objElemIdStr); - } - }, - - createCSS: function(selStr, declStr, mediaStr, newStyleBoolean) { - if (ua.w3) { - createCSS(selStr, declStr, mediaStr, newStyleBoolean); - } - }, - - addDomLoadEvent: addDomLoadEvent, - - addLoadEvent: addLoadEvent, - - getQueryParamValue: function(param) { - var q = doc.location.search || doc.location.hash; - if (q) { - if (/\?/.test(q)) { q = q.split("?")[1]; } // strip question mark - if (param == null) { - return urlEncodeIfNecessary(q); - } - var pairs = q.split("&"); - for (var i = 0; i < pairs.length; i++) { - if (pairs[i].substring(0, pairs[i].indexOf("=")) == param) { - return urlEncodeIfNecessary(pairs[i].substring((pairs[i].indexOf("=") + 1))); - } - } - } - return ""; - }, - - // For internal usage only - expressInstallCallback: function() { - if (isExpressInstallActive) { - var obj = getElementById(EXPRESS_INSTALL_ID); - if (obj && storedAltContent) { - obj.parentNode.replaceChild(storedAltContent, obj); - if (storedAltContentId) { - setVisibility(storedAltContentId, true); - if (ua.ie && ua.win) { storedAltContent.style.display = "block"; } - } - if (storedCallbackFn) { storedCallbackFn(storedCallbackObj); } - } - isExpressInstallActive = false; - } - } - }; -}(); -/** - * @class Ext.FlashComponent - * @extends Ext.BoxComponent - * @constructor - * @xtype flash +}); +Ext.reg('menucheckitem', Ext.menu.CheckItem);/** + * @class Ext.menu.DateMenu + * @extends Ext.menu.Menu + * A menu containing an {@link Ext.DatePicker} Component. + * Notes: + * Although not listed here, the constructor for this class + * accepts all of the configuration options of {@link Ext.DatePicker}. + * If subclassing DateMenu, any configuration options for the DatePicker must be + * applied to the initialConfig property of the DateMenu. + * Applying {@link Ext.DatePicker DatePicker} configuration settings to + * this will not affect the DatePicker's configuration. + * + * @xtype datemenu */ -Ext.FlashComponent = Ext.extend(Ext.BoxComponent, { - /** - * @cfg {String} flashVersion - * Indicates the version the flash content was published for. Defaults to '9.0.45'. + Ext.menu.DateMenu = Ext.extend(Ext.menu.Menu, { + /** + * @cfg {Boolean} enableScrolling + * @hide */ - flashVersion : '9.0.115', - + enableScrolling : false, /** - * @cfg {String} backgroundColor - * The background color of the chart. Defaults to '#ffffff'. + * @cfg {Function} handler + * Optional. A function that will handle the select event of this menu. + * The handler is passed the following parameters: + * picker : DatePickerThe Ext.DatePicker. + * date : DateThe selected date. + * */ - backgroundColor: '#ffffff', - /** - * @cfg {String} wmode - * The wmode of the flash object. This can be used to control layering. Defaults to 'opaque'. + * @cfg {Object} scope + * The scope (this reference) in which the {@link #handler} + * function will be called. Defaults to this DateMenu instance. + */ + /** + * @cfg {Boolean} hideOnClick + * False to continue showing the menu after a date is selected, defaults to true. */ - wmode: 'opaque', + hideOnClick : true, - /** - * @cfg {Object} flashVars - * A set of key value pairs to be passed to the flash object as flash variables. Defaults to undefined. + /** + * @cfg {String} pickerId + * An id to assign to the underlying date picker. Defaults to null. */ - flashVars: undefined, + pickerId : null, + /** + * @cfg {Number} maxHeight + * @hide + */ + /** + * @cfg {Number} scrollIncrement + * @hide + */ /** - * @cfg {Object} flashParams - * A set of key value pairs to be passed to the flash object as parameters. Possible parameters can be found here: - * http://kb2.adobe.com/cps/127/tn_12701.html Defaults to undefined. + * The {@link Ext.DatePicker} instance for this DateMenu + * @property picker + * @type DatePicker */ - flashParams: undefined, - + cls : 'x-date-menu', + /** - * @cfg {String} url - * The URL of the chart to include. Defaults to undefined. + * @event click + * @hide */ - url: undefined, - swfId : undefined, - swfWidth: '100%', - swfHeight: '100%', - + /** - * @cfg {Boolean} expressInstall - * True to prompt the user to install flash if not installed. Note that this uses - * Ext.FlashComponent.EXPRESS_INSTALL_URL, which should be set to the local resource. Defaults to false. + * @event itemclick + * @hide */ - expressInstall: false, initComponent : function(){ - Ext.FlashComponent.superclass.initComponent.call(this); - - this.addEvents( - /** - * @event initialize - * - * @param {Chart} this - */ - 'initialize' - ); - }, - - onRender : function(){ - Ext.FlashComponent.superclass.onRender.apply(this, arguments); - - var params = Ext.apply({ - allowScriptAccess: 'always', - bgcolor: this.backgroundColor, - wmode: this.wmode - }, this.flashParams), vars = Ext.apply({ - allowedDomain: document.location.hostname, - elementID: this.getId(), - eventHandler: 'Ext.FlashEventProxy.onEvent' - }, this.flashVars); - - new swfobject.embedSWF(this.url, this.id, this.swfWidth, this.swfHeight, this.flashVersion, - this.expressInstall ? Ext.FlashComponent.EXPRESS_INSTALL_URL : undefined, vars, params); - - this.swf = Ext.getDom(this.id); - this.el = Ext.get(this.swf); - }, - - getSwfId : function(){ - return this.swfId || (this.swfId = "extswf" + (++Ext.Component.AUTO_ID)); - }, - - getId : function(){ - return this.id || (this.id = "extflashcmp" + (++Ext.Component.AUTO_ID)); + this.on('beforeshow', this.onBeforeShow, this); + if(this.strict = (Ext.isIE7 && Ext.isStrict)){ + this.on('show', this.onShow, this, {single: true, delay: 20}); + } + Ext.apply(this, { + plain: true, + showSeparator: false, + items: this.picker = new Ext.DatePicker(Ext.applyIf({ + internalRender: this.strict || !Ext.isIE, + ctCls: 'x-menu-date-item', + id: this.pickerId + }, this.initialConfig)) + }); + this.picker.purgeListeners(); + Ext.menu.DateMenu.superclass.initComponent.call(this); + /** + * @event select + * Fires when a date is selected from the {@link #picker Ext.DatePicker} + * @param {DatePicker} picker The {@link #picker Ext.DatePicker} + * @param {Date} date The selected date + */ + this.relayEvents(this.picker, ['select']); + this.on('show', this.picker.focus, this.picker); + this.on('select', this.menuHide, this); + if(this.handler){ + this.on('select', this.handler, this.scope || this); + } }, - onFlashEvent : function(e){ - switch(e.type){ - case "swfReady": - this.initSwf(); - return; - case "log": - return; + menuHide : function() { + if(this.hideOnClick){ + this.hide(true); } - e.component = this; - this.fireEvent(e.type.toLowerCase().replace(/event$/, ''), e); }, - initSwf : function(){ - this.onSwfReady(!!this.isInitialized); - this.isInitialized = true; - this.fireEvent('initialize', this); + onBeforeShow : function(){ + if(this.picker){ + this.picker.hideMonthPicker(true); + } }, - beforeDestroy: function(){ - if(this.rendered){ - swfobject.removeSWF(this.swf.id); + onShow : function(){ + var el = this.picker.getEl(); + el.setWidth(el.getWidth()); //nasty hack for IE7 strict mode + } + }); + Ext.reg('datemenu', Ext.menu.DateMenu); + /** + * @class Ext.menu.ColorMenu + * @extends Ext.menu.Menu + * A menu containing a {@link Ext.ColorPalette} Component. + * Notes: + * Although not listed here, the constructor for this class + * accepts all of the configuration options of {@link Ext.ColorPalette}. + * If subclassing ColorMenu, any configuration options for the ColorPalette must be + * applied to the initialConfig property of the ColorMenu. + * Applying {@link Ext.ColorPalette ColorPalette} configuration settings to + * this will not affect the ColorPalette's configuration. + * * + * @xtype colormenu + */ + Ext.menu.ColorMenu = Ext.extend(Ext.menu.Menu, { + /** + * @cfg {Boolean} enableScrolling + * @hide + */ + enableScrolling : false, + /** + * @cfg {Function} handler + * Optional. A function that will handle the select event of this menu. + * The handler is passed the following parameters: + * palette : ColorPaletteThe {@link #palette Ext.ColorPalette}. + * color : StringThe 6-digit color hex code (without the # symbol). + * + */ + /** + * @cfg {Object} scope + * The scope (this reference) in which the {@link #handler} + * function will be called. Defaults to this ColorMenu instance. + */ + + /** + * @cfg {Boolean} hideOnClick + * False to continue showing the menu after a color is selected, defaults to true. + */ + hideOnClick : true, + + cls : 'x-color-menu', + + /** + * @cfg {String} paletteId + * An id to assign to the underlying color palette. Defaults to null. + */ + paletteId : null, + + /** + * @cfg {Number} maxHeight + * @hide + */ + /** + * @cfg {Number} scrollIncrement + * @hide + */ + /** + * @property palette + * @type ColorPalette + * The {@link Ext.ColorPalette} instance for this ColorMenu + */ + + + /** + * @event click + * @hide + */ + + /** + * @event itemclick + * @hide + */ + + initComponent : function(){ + Ext.apply(this, { + plain: true, + showSeparator: false, + items: this.palette = new Ext.ColorPalette(Ext.applyIf({ + id: this.paletteId + }, this.initialConfig)) + }); + this.palette.purgeListeners(); + Ext.menu.ColorMenu.superclass.initComponent.call(this); + /** + * @event select + * Fires when a color is selected from the {@link #palette Ext.ColorPalette} + * @param {Ext.ColorPalette} palette The {@link #palette Ext.ColorPalette} + * @param {String} color The 6-digit color hex code (without the # symbol) + */ + this.relayEvents(this.palette, ['select']); + this.on('select', this.menuHide, this); + if(this.handler){ + this.on('select', this.handler, this.scope || this); } - Ext.FlashComponent.superclass.beforeDestroy.call(this); }, - onSwfReady : Ext.emptyFn + menuHide : function(){ + if(this.hideOnClick){ + this.hide(true); + } + } }); - +Ext.reg('colormenu', Ext.menu.ColorMenu); /** - * Sets the url for installing flash if it doesn't exist. This should be set to a local resource. - * @static - * @type String - */ -Ext.FlashComponent.EXPRESS_INSTALL_URL = 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'; - -Ext.reg('flash', Ext.FlashComponent);/** - * @class Ext.FlashProxy - * @singleton - */ -Ext.FlashEventProxy = { - onEvent : function(id, e){ - var fp = Ext.getCmp(id); - if(fp){ - fp.onFlashEvent(e); - }else{ - arguments.callee.defer(10, this, [id, e]); - } - } -}/** - * @class Ext.chart.Chart - * @extends Ext.FlashComponent - * The Ext.chart package provides the capability to visualize data with flash based charting. - * Each chart binds directly to an Ext.data.Store enabling automatic updates of the chart. - * To change the look and feel of a chart, see the {@link #chartStyle} and {@link #extraStyle} config options. - * @constructor - * @xtype chart - */ - - Ext.chart.Chart = Ext.extend(Ext.FlashComponent, { - refreshBuffer: 100, - - /** - * @cfg {String} backgroundColor - * @hide - */ - - /** - * @cfg {Object} chartStyle - * Sets styles for this chart. This contains default styling, so modifying this property will override - * the built in styles of the chart. Use {@link #extraStyle} to add customizations to the default styling. - */ - chartStyle: { - padding: 10, - animationEnabled: true, - font: { - name: 'Tahoma', - color: 0x444444, - size: 11 - }, - dataTip: { - padding: 5, - border: { - color: 0x99bbe8, - size:1 - }, - background: { - color: 0xDAE7F6, - alpha: .9 - }, - font: { - name: 'Tahoma', - color: 0x15428B, - size: 10, - bold: true - } - } - }, - - /** - * @cfg {String} url - * The url to load the chart from. This defaults to Ext.chart.Chart.CHART_URL, which should - * be modified to point to the local charts resource. - */ - - /** - * @cfg {Object} extraStyle - * Contains extra styles that will be added or overwritten to the default chartStyle. Defaults to null. - * For a detailed list of the options available, visit the YUI Charts site - * at http://developer.yahoo.com/yui/charts/#basicstyles - * Some of the options availabe: - * - * padding - The space around the edge of the chart's contents. Padding does not increase the size of the chart. - * animationEnabled - A Boolean value that specifies whether marker animations are enabled or not. Enabled by default. - * font - An Object defining the font style to be used in the chart. Defaults to { name: 'Tahoma', color: 0x444444, size: 11 } - * - * name - font name - * color - font color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) - * size - font size in points (numeric portion only, ie: 11) - * bold - boolean - * italic - boolean - * underline - boolean - * - * - * border - An object defining the border style around the chart. The chart itself will decrease in dimensions to accomodate the border. - * - * color - border color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) - * size - border size in pixels (numeric portion only, ie: 1) - * - * - * background - An object defining the background style of the chart. - * - * color - border color (hex code, ie: "#ff0000", "ff0000" or 0xff0000) - * image - an image URL. May be relative to the current document or absolute. - * - * - * legend - An object defining the legend style - * - * display - location of the legend. Possible values are "none", "left", "right", "top", and "bottom". - * spacing - an image URL. May be relative to the current document or absolute. - * padding, border, background, font - same options as described above. - * - * dataTip - An object defining the style of the data tip (tooltip). - * - * padding, border, background, font - same options as described above. - * - * xAxis and yAxis - An object defining the style of the style of either axis. - * - * color - same option as described above. - * size - same option as described above. - * showLabels - boolean - * labelRotation - a value in degrees from -90 through 90. Default is zero. - * - * majorGridLines and minorGridLines - An object defining the style of the style of the grid lines. - * - * color, size - same options as described above. - * - * zeroGridLine - An object defining the style of the style of the zero grid line. - * - * color, size - same options as described above. - * - * majorTicks and minorTicks - An object defining the style of the style of ticks in the chart. - * - * color, size - same options as described above. - * length - the length of each tick in pixels extending from the axis. - * display - how the ticks are drawn. Possible values are "none", "inside", "outside", and "cross". - * - * - */ - extraStyle: null, - - /** - * @cfg {Object} seriesStyles - * Contains styles to apply to the series after a refresh. Defaults to null. - */ - seriesStyles: null, - - /** - * @cfg {Boolean} disableCaching - * True to add a "cache buster" to the end of the chart url. Defaults to true for Opera and IE. - */ - disableCaching: Ext.isIE || Ext.isOpera, - disableCacheParam: '_dc', - - initComponent : function(){ - Ext.chart.Chart.superclass.initComponent.call(this); - if(!this.url){ - this.url = Ext.chart.Chart.CHART_URL; - } - if(this.disableCaching){ - this.url = Ext.urlAppend(this.url, String.format('{0}={1}', this.disableCacheParam, new Date().getTime())); - } - this.addEvents( - 'itemmouseover', - 'itemmouseout', - 'itemclick', - 'itemdoubleclick', - 'itemdragstart', - 'itemdrag', - 'itemdragend', - /** - * @event beforerefresh - * Fires before a refresh to the chart data is called. If the beforerefresh handler returns - * false the {@link #refresh} action will be cancelled. - * @param {Chart} this - */ - 'beforerefresh', - /** - * @event refresh - * Fires after the chart data has been refreshed. - * @param {Chart} this - */ - 'refresh' - ); - this.store = Ext.StoreMgr.lookup(this.store); - }, - - /** - * Sets a single style value on the Chart instance. - * - * @param name {String} Name of the Chart style value to change. - * @param value {Object} New value to pass to the Chart style. - */ - setStyle: function(name, value){ - this.swf.setStyle(name, Ext.encode(value)); - }, - - /** - * Resets all styles on the Chart instance. - * - * @param styles {Object} Initializer for all Chart styles. - */ - setStyles: function(styles){ - this.swf.setStyles(Ext.encode(styles)); - }, - - /** - * Sets the styles on all series in the Chart. - * - * @param styles {Array} Initializer for all Chart series styles. - */ - setSeriesStyles: function(styles){ - this.seriesStyles = styles; - var s = []; - Ext.each(styles, function(style){ - s.push(Ext.encode(style)); - }); - this.swf.setSeriesStyles(s); - }, - - setCategoryNames : function(names){ - this.swf.setCategoryNames(names); - }, - - setTipRenderer : function(fn){ - var chart = this; - this.tipFnName = this.createFnProxy(function(item, index, series){ - var record = chart.store.getAt(index); - return fn(chart, record, index, series); - }, this.tipFnName); - this.swf.setDataTipFunction(this.tipFnName); - }, - - setSeries : function(series){ - this.series = series; - this.refresh(); - }, - - /** - * Changes the data store bound to this chart and refreshes it. - * @param {Store} store The store to bind to this chart - */ - bindStore : function(store, initial){ - if(!initial && this.store){ - if(store !== this.store && this.store.autoDestroy){ - this.store.destroy(); - }else{ - this.store.un("datachanged", this.refresh, this); - this.store.un("add", this.delayRefresh, this); - this.store.un("remove", this.delayRefresh, this); - this.store.un("update", this.delayRefresh, this); - this.store.un("clear", this.refresh, this); - } - } - if(store){ - store = Ext.StoreMgr.lookup(store); - store.on({ - scope: this, - datachanged: this.refresh, - add: this.delayRefresh, - remove: this.delayRefresh, - update: this.delayRefresh, - clear: this.refresh - }); - } - this.store = store; - if(store && !initial){ - this.refresh(); - } - }, - - onSwfReady : function(isReset){ - Ext.chart.Chart.superclass.onSwfReady.call(this, isReset); - this.swf.setType(this.type); - - if(this.chartStyle){ - this.setStyles(Ext.apply({}, this.extraStyle, this.chartStyle)); - } - - if(this.categoryNames){ - this.setCategoryNames(this.categoryNames); - } - - if(this.tipRenderer){ - this.setTipRenderer(this.tipRenderer); - } - if(!isReset){ - this.bindStore(this.store, true); - } - this.refresh.defer(10, this); - }, - - delayRefresh : function(){ - if(!this.refreshTask){ - this.refreshTask = new Ext.util.DelayedTask(this.refresh, this); - } - this.refreshTask.delay(this.refreshBuffer); - }, - - refresh : function(){ - if(this.fireEvent('beforerefresh', this) !== false){ - var styleChanged = false; - // convert the store data into something YUI charts can understand - var data = [], rs = this.store.data.items; - for(var j = 0, len = rs.length; j < len; j++){ - data[j] = rs[j].data; - } - //make a copy of the series definitions so that we aren't - //editing them directly. - var dataProvider = []; - var seriesCount = 0; - var currentSeries = null; - var i = 0; - if(this.series){ - seriesCount = this.series.length; - for(i = 0; i < seriesCount; i++){ - currentSeries = this.series[i]; - var clonedSeries = {}; - for(var prop in currentSeries){ - if(prop == "style" && currentSeries.style !== null){ - clonedSeries.style = Ext.encode(currentSeries.style); - styleChanged = true; - //we don't want to modify the styles again next time - //so null out the style property. - // this causes issues - // currentSeries.style = null; - } else{ - clonedSeries[prop] = currentSeries[prop]; - } - } - dataProvider.push(clonedSeries); - } - } - - if(seriesCount > 0){ - for(i = 0; i < seriesCount; i++){ - currentSeries = dataProvider[i]; - if(!currentSeries.type){ - currentSeries.type = this.type; - } - currentSeries.dataProvider = data; - } - } else{ - dataProvider.push({type: this.type, dataProvider: data}); - } - this.swf.setDataProvider(dataProvider); - if(this.seriesStyles){ - this.setSeriesStyles(this.seriesStyles); - } - this.fireEvent('refresh', this); - } - }, - - createFnProxy : function(fn, old){ - if(old){ - delete window[old]; - } - var fnName = "extFnProxy" + (++Ext.chart.Chart.PROXY_FN_ID); - window[fnName] = fn; - return fnName; - }, - - onDestroy: function(){ - Ext.chart.Chart.superclass.onDestroy.call(this); - this.bindStore(null); - var tip = this.tipFnName; - if(!Ext.isEmpty(tip)){ - delete window[tip]; - } - } -}); -Ext.reg('chart', Ext.chart.Chart); -Ext.chart.Chart.PROXY_FN_ID = 0; - -/** - * Sets the url to load the chart from. This should be set to a local resource. - * @static - * @type String - */ -Ext.chart.Chart.CHART_URL = 'http:/' + '/yui.yahooapis.com/2.7.0/build/charts/assets/charts.swf'; - -/** - * @class Ext.chart.PieChart - * @extends Ext.chart.Chart - * @constructor - * @xtype piechart - */ -Ext.chart.PieChart = Ext.extend(Ext.chart.Chart, { - type: 'pie', - - onSwfReady : function(isReset){ - Ext.chart.PieChart.superclass.onSwfReady.call(this, isReset); - - this.setDataField(this.dataField); - this.setCategoryField(this.categoryField); - }, - - setDataField : function(field){ - this.dataField = field; - this.swf.setDataField(field); - }, - - setCategoryField : function(field){ - this.categoryField = field; - this.swf.setCategoryField(field); - } -}); -Ext.reg('piechart', Ext.chart.PieChart); - -/** - * @class Ext.chart.CartesianChart - * @extends Ext.chart.Chart - * @constructor - * @xtype cartesianchart - */ -Ext.chart.CartesianChart = Ext.extend(Ext.chart.Chart, { - onSwfReady : function(isReset){ - Ext.chart.CartesianChart.superclass.onSwfReady.call(this, isReset); - - if(this.xField){ - this.setXField(this.xField); - } - if(this.yField){ - this.setYField(this.yField); - } - if(this.xAxis){ - this.setXAxis(this.xAxis); - } - if(this.yAxis){ - this.setYAxis(this.yAxis); - } - }, - - setXField : function(value){ - this.xField = value; - this.swf.setHorizontalField(value); - }, - - setYField : function(value){ - this.yField = value; - this.swf.setVerticalField(value); - }, - - setXAxis : function(value){ - this.xAxis = this.createAxis('xAxis', value); - this.swf.setHorizontalAxis(this.xAxis); - }, - - setYAxis : function(value){ - this.yAxis = this.createAxis('yAxis', value); - this.swf.setVerticalAxis(this.yAxis); - }, - - createAxis : function(axis, value){ - var o = Ext.apply({}, value), oldFn = null; - if(this[axis]){ - oldFn = this[axis].labelFunction; - } - if(o.labelRenderer){ - var fn = o.labelRenderer; - o.labelFunction = this.createFnProxy(function(v){ - return fn(v); - }, oldFn); - delete o.labelRenderer; - } - return o; - } -}); -Ext.reg('cartesianchart', Ext.chart.CartesianChart); - -/** - * @class Ext.chart.LineChart - * @extends Ext.chart.CartesianChart - * @constructor - * @xtype linechart - */ -Ext.chart.LineChart = Ext.extend(Ext.chart.CartesianChart, { - type: 'line' -}); -Ext.reg('linechart', Ext.chart.LineChart); - -/** - * @class Ext.chart.ColumnChart - * @extends Ext.chart.CartesianChart - * @constructor - * @xtype columnchart - */ -Ext.chart.ColumnChart = Ext.extend(Ext.chart.CartesianChart, { - type: 'column' -}); -Ext.reg('columnchart', Ext.chart.ColumnChart); - -/** - * @class Ext.chart.StackedColumnChart - * @extends Ext.chart.CartesianChart - * @constructor - * @xtype stackedcolumnchart - */ -Ext.chart.StackedColumnChart = Ext.extend(Ext.chart.CartesianChart, { - type: 'stackcolumn' -}); -Ext.reg('stackedcolumnchart', Ext.chart.StackedColumnChart); - -/** - * @class Ext.chart.BarChart - * @extends Ext.chart.CartesianChart - * @constructor - * @xtype barchart - */ -Ext.chart.BarChart = Ext.extend(Ext.chart.CartesianChart, { - type: 'bar' -}); -Ext.reg('barchart', Ext.chart.BarChart); - -/** - * @class Ext.chart.StackedBarChart - * @extends Ext.chart.CartesianChart - * @constructor - * @xtype stackedbarchart - */ -Ext.chart.StackedBarChart = Ext.extend(Ext.chart.CartesianChart, { - type: 'stackbar' -}); -Ext.reg('stackedbarchart', Ext.chart.StackedBarChart); - - - -/** - * @class Ext.chart.Axis - * Defines a CartesianChart's vertical or horizontal axis. - * @constructor - */ -Ext.chart.Axis = function(config){ - Ext.apply(this, config); -}; - -Ext.chart.Axis.prototype = -{ - /** - * The type of axis. - * - * @property type - * @type String - */ - type: null, - - /** - * The direction in which the axis is drawn. May be "horizontal" or "vertical". - * - * @property orientation - * @type String - */ - orientation: "horizontal", - - /** - * If true, the items on the axis will be drawn in opposite direction. - * - * @property reverse - * @type Boolean - */ - reverse: false, - - /** - * A string reference to the globally-accessible function that may be called to - * determine each of the label values for this axis. - * - * @property labelFunction - * @type String - */ - labelFunction: null, - - /** - * If true, labels that overlap previously drawn labels on the axis will be hidden. - * - * @property hideOverlappingLabels - * @type Boolean - */ - hideOverlappingLabels: true -}; - -/** - * @class Ext.chart.NumericAxis - * @extends Ext.chart.Axis - * A type of axis whose units are measured in numeric values. - * @constructor - */ -Ext.chart.NumericAxis = Ext.extend(Ext.chart.Axis, { - type: "numeric", - - /** - * The minimum value drawn by the axis. If not set explicitly, the axis minimum - * will be calculated automatically. - * - * @property minimum - * @type Number - */ - minimum: NaN, - - /** - * The maximum value drawn by the axis. If not set explicitly, the axis maximum - * will be calculated automatically. - * - * @property maximum - * @type Number - */ - maximum: NaN, - - /** - * The spacing between major intervals on this axis. - * - * @property majorUnit - * @type Number - */ - majorUnit: NaN, - - /** - * The spacing between minor intervals on this axis. - * - * @property minorUnit - * @type Number - */ - minorUnit: NaN, - - /** - * If true, the labels, ticks, gridlines, and other objects will snap to - * the nearest major or minor unit. If false, their position will be based - * on the minimum value. - * - * @property snapToUnits - * @type Boolean - */ - snapToUnits: true, - - /** - * If true, and the bounds are calculated automatically, either the minimum or - * maximum will be set to zero. - * - * @property alwaysShowZero - * @type Boolean - */ - alwaysShowZero: true, - - /** - * The scaling algorithm to use on this axis. May be "linear" or "logarithmic". - * - * @property scale - * @type String - */ - scale: "linear" -}); - -/** - * @class Ext.chart.TimeAxis - * @extends Ext.chart.Axis - * A type of axis whose units are measured in time-based values. - * @constructor - */ -Ext.chart.TimeAxis = Ext.extend(Ext.chart.Axis, { - type: "time", - - /** - * The minimum value drawn by the axis. If not set explicitly, the axis minimum - * will be calculated automatically. - * - * @property minimum - * @type Date - */ - minimum: null, - - /** - * The maximum value drawn by the axis. If not set explicitly, the axis maximum - * will be calculated automatically. - * - * @property maximum - * @type Number - */ - maximum: null, - - /** - * The spacing between major intervals on this axis. - * - * @property majorUnit - * @type Number - */ - majorUnit: NaN, - - /** - * The time unit used by the majorUnit. - * - * @property majorTimeUnit - * @type String - */ - majorTimeUnit: null, - - /** - * The spacing between minor intervals on this axis. - * - * @property majorUnit - * @type Number - */ - minorUnit: NaN, - - /** - * The time unit used by the minorUnit. - * - * @property majorTimeUnit - * @type String - */ - minorTimeUnit: null, - - /** - * If true, the labels, ticks, gridlines, and other objects will snap to - * the nearest major or minor unit. If false, their position will be based - * on the minimum value. - * - * @property snapToUnits - * @type Boolean - */ - snapToUnits: true -}); - -/** - * @class Ext.chart.CategoryAxis - * @extends Ext.chart.Axis - * A type of axis that displays items in categories. - * @constructor - */ -Ext.chart.CategoryAxis = Ext.extend(Ext.chart.Axis, { - type: "category", - - /** - * A list of category names to display along this axis. - * - * @property categoryNames - * @type Array - */ - categoryNames: null -}); - -/** - * @class Ext.chart.Series - * Series class for the charts widget. - * @constructor - */ -Ext.chart.Series = function(config) { Ext.apply(this, config); }; - -Ext.chart.Series.prototype = -{ - /** - * The type of series. - * - * @property type - * @type String - */ - type: null, - - /** - * The human-readable name of the series. - * - * @property displayName - * @type String - */ - displayName: null -}; - -/** - * @class Ext.chart.CartesianSeries - * @extends Ext.chart.Series - * CartesianSeries class for the charts widget. - * @constructor - */ -Ext.chart.CartesianSeries = Ext.extend(Ext.chart.Series, { - /** - * The field used to access the x-axis value from the items from the data source. - * - * @property xField - * @type String - */ - xField: null, - - /** - * The field used to access the y-axis value from the items from the data source. - * - * @property yField - * @type String - */ - yField: null -}); - -/** - * @class Ext.chart.ColumnSeries - * @extends Ext.chart.CartesianSeries - * ColumnSeries class for the charts widget. - * @constructor - */ -Ext.chart.ColumnSeries = Ext.extend(Ext.chart.CartesianSeries, { - type: "column" -}); - -/** - * @class Ext.chart.LineSeries - * @extends Ext.chart.CartesianSeries - * LineSeries class for the charts widget. - * @constructor - */ -Ext.chart.LineSeries = Ext.extend(Ext.chart.CartesianSeries, { - type: "line" -}); - -/** - * @class Ext.chart.BarSeries - * @extends Ext.chart.CartesianSeries - * BarSeries class for the charts widget. - * @constructor - */ -Ext.chart.BarSeries = Ext.extend(Ext.chart.CartesianSeries, { - type: "bar" -}); - - -/** - * @class Ext.chart.PieSeries - * @extends Ext.chart.Series - * PieSeries class for the charts widget. - * @constructor - */ -Ext.chart.PieSeries = Ext.extend(Ext.chart.Series, { - type: "pie", - dataField: null, - categoryField: null -});/** - * @class Ext.menu.Menu - * @extends Ext.Container - * A menu object. This is the container to which you may add menu items. Menu can also serve as a base class - * when you want a specialized menu based off of another component (like {@link Ext.menu.DateMenu} for example). - * Menus may contain either {@link Ext.menu.Item menu items}, or general {@link Ext.Component Component}s. - * To make a contained general {@link Ext.Component Component} line up with other {@link Ext.menu.Item menu items} - * specify iconCls: 'no-icon'. This reserves a space for an icon, and indents the Component in line - * with the other menu items. See {@link Ext.form.ComboBox}.{@link Ext.form.ComboBox#getListParent getListParent} - * for an example. - * By default, Menus are absolutely positioned, floating Components. By configuring a Menu with - * {@link #floating}:false, a Menu may be used as child of a Container. - * - * @xtype menu + * @class Ext.form.Field + * @extends Ext.BoxComponent + * Base class for form fields that provides default event handling, sizing, value handling and other functionality. + * @constructor + * Creates a new Field + * @param {Object} config Configuration options + * @xtype field */ -Ext.menu.Menu = Ext.extend(Ext.Container, { +Ext.form.Field = Ext.extend(Ext.BoxComponent, { /** - * @cfg {Object} defaults - * A config object that will be applied to all items added to this container either via the {@link #items} - * config or via the {@link #add} method. The defaults config can contain any number of - * name/value property pairs to be added to each item, and should be valid for the types of items - * being added to the menu. + * The label Element associated with this Field. Only available after this Field has been rendered by a + * {@link form Ext.layout.FormLayout} layout manager. + * @type Ext.Element + * @property label */ /** - * @cfg {Mixed} items - * An array of items to be added to this menu. Menus may contain either {@link Ext.menu.Item menu items}, - * or general {@link Ext.Component Component}s. + * @cfg {String} inputType The type attribute for input fields -- e.g. radio, text, password, file (defaults + * to 'text'). The types 'file' and 'password' must be used to render those field types currently -- there are + * no separate Ext components for those. Note that if you use inputType:'file', {@link #emptyText} + * is not supported and should be avoided. */ /** - * @cfg {Number} minWidth The minimum width of the menu in pixels (defaults to 120) + * @cfg {Number} tabIndex The tabIndex for this field. Note this only applies to fields that are rendered, + * not those which are built via applyTo (defaults to undefined). */ - minWidth : 120, /** - * @cfg {Boolean/String} shadow True or 'sides' for the default effect, 'frame' for 4-way shadow, and 'drop' - * for bottom-right shadow (defaults to 'sides') + * @cfg {Mixed} value A value to initialize this field with (defaults to undefined). */ - shadow : 'sides', /** - * @cfg {String} subMenuAlign The {@link Ext.Element#alignTo} anchor position value to use for submenus of - * this menu (defaults to 'tl-tr?') + * @cfg {String} name The field's HTML name attribute (defaults to ''). + * Note: this property must be set if this field is to be automatically included with + * {@link Ext.form.BasicForm#submit form submit()}. */ - subMenuAlign : 'tl-tr?', /** - * @cfg {String} defaultAlign The default {@link Ext.Element#alignTo} anchor position value for this menu - * relative to its element of origin (defaults to 'tl-bl?') + * @cfg {String} cls A custom CSS class to apply to the field's underlying element (defaults to ''). */ - defaultAlign : 'tl-bl?', + /** - * @cfg {Boolean} allowOtherMenus True to allow multiple menus to be displayed at the same time (defaults to false) + * @cfg {String} invalidClass The CSS class to use when marking a field invalid (defaults to 'x-form-invalid') */ - allowOtherMenus : false, + invalidClass : 'x-form-invalid', /** - * @cfg {Boolean} ignoreParentClicks True to ignore clicks on any item in this menu that is a parent item (displays - * a submenu) so that the submenu is not dismissed when clicking the parent item (defaults to false). + * @cfg {String} invalidText The error text to use when marking a field invalid and no message is provided + * (defaults to 'The value in this field is invalid') */ - ignoreParentClicks : false, + invalidText : 'The value in this field is invalid', /** - * @cfg {Boolean} enableScrolling True to allow the menu container to have scroller controls if the menu is too long (defaults to true). + * @cfg {String} focusClass The CSS class to use when the field receives focus (defaults to 'x-form-focus') */ - enableScrolling : true, + focusClass : 'x-form-focus', /** - * @cfg {Number} maxHeight The maximum height of the menu. Only applies when enableScrolling is set to True (defaults to null). + * @cfg {Boolean} preventMark + * true to disable {@link #markInvalid marking the field invalid}. + * Defaults to false. */ - maxHeight : null, /** - * @cfg {Number} scrollIncrement The amount to scroll the menu. Only applies when enableScrolling is set to True (defaults to 24). + * @cfg {String/Boolean} validationEvent The event that should initiate field validation. Set to false to disable + automatic validation (defaults to 'keyup'). */ - scrollIncrement : 24, + validationEvent : 'keyup', /** - * @cfg {Boolean} showSeparator True to show the icon separator. (defaults to true). + * @cfg {Boolean} validateOnBlur Whether the field should validate when it loses focus (defaults to true). */ - showSeparator : true, + validateOnBlur : true, /** - * @cfg {Array} defaultOffsets An array specifying the [x, y] offset in pixels by which to - * change the default Menu popup position after aligning according to the {@link #defaultAlign} - * configuration. Defaults to [0, 0]. + * @cfg {Number} validationDelay The length of time in milliseconds after user input begins until validation + * is initiated (defaults to 250) */ - defaultOffsets : [0, 0], - + validationDelay : 250, /** - * @cfg {Boolean} plain - * True to remove the incised line down the left side of the menu. Defaults to false. + * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default + * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. + * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: + * {tag: 'input', type: 'text', size: '20', autocomplete: 'off'} */ - plain : false, - + defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'}, /** - * @cfg {Boolean} floating - * By default, a Menu configured as floating:true - * will be rendered as an {@link Ext.Layer} (an absolutely positioned, - * floating Component with zindex=15000). - * If configured as floating:false, the Menu may be - * used as child item of another Container instead of a free-floating - * {@link Ext.Layer Layer}. + * @cfg {String} fieldClass The default CSS class for the field (defaults to 'x-form-field') */ - floating : true, - - + fieldClass : 'x-form-field', /** - * @cfg {Number} zIndex - * zIndex to use when the menu is floating. + * @cfg {String} msgTarget The location where the message text set through {@link #markInvalid} should display. + * Must be one of the following values: + * + * qtip Display a quick tip containing the message when the user hovers over the field. This is the default. + * {@link Ext.QuickTips#init Ext.QuickTips.init} must have been called for this setting to work. + * title Display the message in a default browser title attribute popup. + * under Add a block div beneath the field containing the error message. + * side Add an error icon to the right of the field, displaying the message in a popup on hover. + * [element id] Add the error message directly to the innerHTML of the specified element. + * */ - zIndex: 15000, + msgTarget : 'qtip', + /** + * @cfg {String} msgFx Experimental The effect used when displaying a validation message under the field + * (defaults to 'normal'). + */ + msgFx : 'normal', + /** + * @cfg {Boolean} readOnly true to mark the field as readOnly in HTML + * (defaults to false). + * Note: this only sets the element's readOnly DOM attribute. + * Setting readOnly=true, for example, will not disable triggering a + * ComboBox or DateField; it gives you the option of forcing the user to choose + * via the trigger without typing in the text box. To hide the trigger use + * {@link Ext.form.TriggerField#hideTrigger hideTrigger}. + */ + readOnly : false, + /** + * @cfg {Boolean} disabled True to disable the field (defaults to false). + * Be aware that conformant with the HTML specification, + * disabled Fields will not be {@link Ext.form.BasicForm#submit submitted}. + */ + disabled : false, + /** + * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post. + * Defaults to true. + */ + submitValue: true, // private - hidden : true, + isFormField : true, - /** - * @cfg {String/Object} layout - * This class assigns a default layout (layout:'menu'). - * Developers may override this configuration option if another layout is required. - * See {@link Ext.Container#layout} for additional information. - */ - layout : 'menu', - hideMode : 'offsets', // Important for laying out Components - scrollerHeight : 8, - autoLayout : true, // Provided for backwards compat - defaultType : 'menuitem', - bufferResize : false, + // private + msgDisplay: '', + + // private + hasFocus : false, + // private initComponent : function(){ - if(Ext.isArray(this.initialConfig)){ - Ext.apply(this, {items:this.initialConfig}); - } + Ext.form.Field.superclass.initComponent.call(this); this.addEvents( /** - * @event click - * Fires when this menu is clicked (or when the enter key is pressed while it is active) - * @param {Ext.menu.Menu} this - * @param {Ext.menu.Item} menuItem The menu item that was clicked - * @param {Ext.EventObject} e + * @event focus + * Fires when this field receives input focus. + * @param {Ext.form.Field} this */ - 'click', + 'focus', /** - * @event mouseover - * Fires when the mouse is hovering over this menu - * @param {Ext.menu.Menu} this - * @param {Ext.EventObject} e - * @param {Ext.menu.Item} menuItem The menu item that was clicked + * @event blur + * Fires when this field loses input focus. + * @param {Ext.form.Field} this */ - 'mouseover', + 'blur', /** - * @event mouseout - * Fires when the mouse exits this menu - * @param {Ext.menu.Menu} this - * @param {Ext.EventObject} e - * @param {Ext.menu.Item} menuItem The menu item that was clicked + * @event specialkey + * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. + * To handle other keys see {@link Ext.Panel#keys} or {@link Ext.KeyMap}. + * You can check {@link Ext.EventObject#getKey} to determine which key was pressed. + * For example: +var form = new Ext.form.FormPanel({ + ... + items: [{ + fieldLabel: 'Field 1', + name: 'field1', + allowBlank: false + },{ + fieldLabel: 'Field 2', + name: 'field2', + listeners: { + specialkey: function(field, e){ + // e.HOME, e.END, e.PAGE_UP, e.PAGE_DOWN, + // e.TAB, e.ESC, arrow keys: e.LEFT, e.RIGHT, e.UP, e.DOWN + if (e.{@link Ext.EventObject#getKey getKey()} == e.ENTER) { + var form = field.ownerCt.getForm(); + form.submit(); + } + } + } + } + ], + ... +}); + * + * @param {Ext.form.Field} this + * @param {Ext.EventObject} e The event object */ - 'mouseout', + 'specialkey', /** - * @event itemclick - * Fires when a menu item contained in this menu is clicked - * @param {Ext.menu.BaseItem} baseItem The BaseItem that was clicked - * @param {Ext.EventObject} e + * @event change + * Fires just before the field blurs if the field value has changed. + * @param {Ext.form.Field} this + * @param {Mixed} newValue The new value + * @param {Mixed} oldValue The original value */ - 'itemclick' - ); - Ext.menu.MenuMgr.register(this); - if(this.floating){ - Ext.EventManager.onWindowResize(this.hide, this); - }else{ - if(this.initialConfig.hidden !== false){ - this.hidden = false; - } - this.internalDefaults = {hideOnClick: false}; - } - Ext.menu.Menu.superclass.initComponent.call(this); - if(this.autoLayout){ - var fn = this.doLayout.createDelegate(this, []); - this.on({ - add: fn, - remove: fn - }); - } + 'change', + /** + * @event invalid + * Fires after the field has been marked as invalid. + * @param {Ext.form.Field} this + * @param {String} msg The validation message + */ + 'invalid', + /** + * @event valid + * Fires after the field has been validated with no errors. + * @param {Ext.form.Field} this + */ + 'valid' + ); }, - //private - getLayoutTarget : function() { - return this.ul; + /** + * Returns the {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName} + * attribute of the field if available. + * @return {String} name The field {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName} + */ + getName : function(){ + return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || ''; }, // private onRender : function(ct, position){ - if(!ct){ - ct = Ext.getBody(); - } + if(!this.el){ + var cfg = this.getAutoCreate(); - var dh = { - id: this.getId(), - cls: 'x-menu ' + ((this.floating) ? 'x-menu-floating x-layer ' : '') + (this.cls || '') + (this.plain ? ' x-menu-plain' : '') + (this.showSeparator ? '' : ' x-menu-nosep'), - style: this.style, - cn: [ - {tag: 'a', cls: 'x-menu-focus', href: '#', onclick: 'return false;', tabIndex: '-1'}, - {tag: 'ul', cls: 'x-menu-list'} - ] - }; - if(this.floating){ - this.el = new Ext.Layer({ - shadow: this.shadow, - dh: dh, - constrain: false, - parentEl: ct, - zindex: this.zIndex - }); - }else{ - this.el = ct.createChild(dh); + if(!cfg.name){ + cfg.name = this.name || this.id; + } + if(this.inputType){ + cfg.type = this.inputType; + } + this.autoEl = cfg; } - Ext.menu.Menu.superclass.onRender.call(this, ct, position); - - if(!this.keyNav){ - this.keyNav = new Ext.menu.MenuNav(this); + Ext.form.Field.superclass.onRender.call(this, ct, position); + if(this.submitValue === false){ + this.el.dom.removeAttribute('name'); } - // generic focus element - this.focusEl = this.el.child('a.x-menu-focus'); - this.ul = this.el.child('ul.x-menu-list'); - this.mon(this.ul, { - scope: this, - click: this.onClick, - mouseover: this.onMouseOver, - mouseout: this.onMouseOut - }); - if(this.enableScrolling){ - this.mon(this.el, { - scope: this, - delegate: '.x-menu-scroller', - click: this.onScroll, - mouseover: this.deactivateActive - }); + var type = this.el.dom.type; + if(type){ + if(type == 'password'){ + type = 'text'; + } + this.el.addClass('x-form-'+type); + } + if(this.readOnly){ + this.setReadOnly(true); + } + if(this.tabIndex !== undefined){ + this.el.dom.setAttribute('tabIndex', this.tabIndex); } + + this.el.addClass([this.fieldClass, this.cls]); }, // private - findTargetItem : function(e){ - var t = e.getTarget('.x-menu-list-item', this.ul, true); - if(t && t.menuItemId){ - return this.items.get(t.menuItemId); - } + getItemCt : function(){ + return this.itemCt; }, // private - onClick : function(e){ - var t = this.findTargetItem(e); - if(t){ - if(t.isFormField){ - this.setActiveItem(t); - }else if(t instanceof Ext.menu.BaseItem){ - if(t.menu && this.ignoreParentClicks){ - t.expandMenu(); - e.preventDefault(); - }else if(t.onClick){ - t.onClick(e); - this.fireEvent('click', this, t, e); - } - } + initValue : function(){ + if(this.value !== undefined){ + this.setValue(this.value); + }else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){ + this.setValue(this.el.dom.value); } + /** + * The original value of the field as configured in the {@link #value} configuration, or + * as loaded by the last form load operation if the form's {@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} + * setting is true. + * @type mixed + * @property originalValue + */ + this.originalValue = this.getValue(); }, - // private - setActiveItem : function(item, autoExpand){ - if(item != this.activeItem){ - this.deactivateActive(); - if((this.activeItem = item).isFormField){ - item.focus(); - }else{ - item.activate(autoExpand); - } - }else if(autoExpand){ - item.expandMenu(); + /** + * Returns true if the value of this Field has been changed from its original value. + * Will return false if the field is disabled or has not been rendered yet. + * Note that if the owning {@link Ext.form.BasicForm form} was configured with + * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} + * then the original value is updated when the values are loaded by + * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#setValues setValues}. + * @return {Boolean} True if this field has been changed from its original value (and + * is not disabled), false otherwise. + */ + isDirty : function() { + if(this.disabled || !this.rendered) { + return false; } + return String(this.getValue()) !== String(this.originalValue); }, - deactivateActive : function(){ - var a = this.activeItem; - if(a){ - if(a.isFormField){ - //Fields cannot deactivate, but Combos must collapse - if(a.collapse){ - a.collapse(); - } - }else{ - a.deactivate(); - } - delete this.activeItem; + /** + * Sets the read only state of this field. + * @param {Boolean} readOnly Whether the field should be read only. + */ + setReadOnly : function(readOnly){ + if(this.rendered){ + this.el.dom.readOnly = readOnly; } + this.readOnly = readOnly; }, // private - tryActivate : function(start, step){ - var items = this.items; - for(var i = start, len = items.length; i >= 0 && i < len; i+= step){ - var item = items.get(i); - if(!item.disabled && (item.canActivate || item.isFormField)){ - this.setActiveItem(item, false); - return item; - } - } - return false; + afterRender : function(){ + Ext.form.Field.superclass.afterRender.call(this); + this.initEvents(); + this.initValue(); }, // private - onMouseOver : function(e){ - var t = this.findTargetItem(e); - if(t){ - if(t.canActivate && !t.disabled){ - this.setActiveItem(t, true); - } + fireKey : function(e){ + if(e.isSpecialKey()){ + this.fireEvent('specialkey', this, e); } - this.over = true; - this.fireEvent('mouseover', this, e, t); + }, + + /** + * Resets the current field value to the originally loaded value and clears any validation messages. + * See {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} + */ + reset : function(){ + this.setValue(this.originalValue); + this.clearInvalid(); }, // private - onMouseOut : function(e){ - var t = this.findTargetItem(e); - if(t){ - if(t == this.activeItem && t.shouldDeactivate && t.shouldDeactivate(e)){ - this.activeItem.deactivate(); - delete this.activeItem; - } - } - this.over = false; - this.fireEvent('mouseout', this, e, t); + initEvents : function(){ + this.mon(this.el, Ext.EventManager.useKeydown ? 'keydown' : 'keypress', this.fireKey, this); + this.mon(this.el, 'focus', this.onFocus, this); + + // standardise buffer across all browsers + OS-es for consistent event order. + // (the 10ms buffer for Editors fixes a weird FF/Win editor issue when changing OS window focus) + this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null); }, // private - onScroll : function(e, t){ - if(e){ - e.stopEvent(); + preFocus: Ext.emptyFn, + + // private + onFocus : function(){ + this.preFocus(); + if(this.focusClass){ + this.el.addClass(this.focusClass); } - var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top'); - ul.scrollTop += this.scrollIncrement * (top ? -1 : 1); - if(top ? ul.scrollTop <= 0 : ul.scrollTop + this.activeMax >= ul.scrollHeight){ - this.onScrollerOut(null, t); + if(!this.hasFocus){ + this.hasFocus = true; + /** + * The value that the Field had at the time it was last focused. This is the value that is passed + * to the {@link #change} event which is fired if the value has been changed when the Field is blurred. + * This will be undefined until the Field has been visited. Compare {@link #originalValue}. + * @type mixed + * @property startValue + */ + this.startValue = this.getValue(); + this.fireEvent('focus', this); } }, // private - onScrollerIn : function(e, t){ - var ul = this.ul.dom, top = Ext.fly(t).is('.x-menu-scroller-top'); - if(top ? ul.scrollTop > 0 : ul.scrollTop + this.activeMax < ul.scrollHeight){ - Ext.fly(t).addClass(['x-menu-item-active', 'x-menu-scroller-active']); + beforeBlur : Ext.emptyFn, + + // private + onBlur : function(){ + this.beforeBlur(); + if(this.focusClass){ + this.el.removeClass(this.focusClass); + } + this.hasFocus = false; + if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){ + this.validate(); + } + var v = this.getValue(); + if(String(v) !== String(this.startValue)){ + this.fireEvent('change', this, v, this.startValue); } + this.fireEvent('blur', this); + this.postBlur(); }, // private - onScrollerOut : function(e, t){ - Ext.fly(t).removeClass(['x-menu-item-active', 'x-menu-scroller-active']); - }, + postBlur : Ext.emptyFn, /** - * If {@link #floating}=true, shows this menu relative to - * another element using {@link #showat}, otherwise uses {@link Ext.Component#show}. - * @param {Mixed} element The element to align to - * @param {String} position (optional) The {@link Ext.Element#alignTo} anchor position to use in aligning to - * the element (defaults to this.defaultAlign) - * @param {Ext.menu.Menu} parentMenu (optional) This menu's parent menu, if applicable (defaults to undefined) + * Returns whether or not the field value is currently valid by + * {@link #validateValue validating} the {@link #processValue processed value} + * of the field. Note: {@link #disabled} fields are ignored. + * @param {Boolean} preventMark True to disable marking the field invalid + * @return {Boolean} True if the value is valid, else false */ - show : function(el, pos, parentMenu){ - if(this.floating){ - this.parentMenu = parentMenu; - if(!this.el){ - this.render(); - this.doLayout(false, true); - } - this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign, this.defaultOffsets), parentMenu); - }else{ - Ext.menu.Menu.superclass.show.call(this); + isValid : function(preventMark){ + if(this.disabled){ + return true; } + var restore = this.preventMark; + this.preventMark = preventMark === true; + var v = this.validateValue(this.processValue(this.getRawValue())); + this.preventMark = restore; + return v; }, /** - * Displays this menu at a specific xy position and fires the 'show' event if a - * handler for the 'beforeshow' event does not return false cancelling the operation. - * @param {Array} xyPosition Contains X & Y [x, y] values for the position at which to show the menu (coordinates are page-based) - * @param {Ext.menu.Menu} parentMenu (optional) This menu's parent menu, if applicable (defaults to undefined) + * Validates the field value + * @return {Boolean} True if the value is valid, else false */ - showAt : function(xy, parentMenu){ - if(this.fireEvent('beforeshow', this) !== false){ - this.parentMenu = parentMenu; - if(!this.el){ - this.render(); - } - if(this.enableScrolling){ - // set the position so we can figure out the constrain value. - this.el.setXY(xy); - //constrain the value, keep the y coordinate the same - xy[1] = this.constrainScroll(xy[1]); - xy = [this.el.adjustForConstraints(xy)[0], xy[1]]; - }else{ - //constrain to the viewport. - xy = this.el.adjustForConstraints(xy); - } - this.el.setXY(xy); - this.el.show(); - Ext.menu.Menu.superclass.onShow.call(this); - if(Ext.isIE){ - // internal event, used so we don't couple the layout to the menu - this.fireEvent('autosize', this); - if(!Ext.isIE8){ - this.el.repaint(); - } - } - this.hidden = false; - this.focus(); - this.fireEvent('show', this); - } - }, - - constrainScroll : function(y){ - var max, full = this.ul.setHeight('auto').getHeight(), - returnY = y, normalY, parentEl, scrollTop, viewHeight; - if(this.floating){ - parentEl = Ext.fly(this.el.dom.parentNode); - scrollTop = parentEl.getScroll().top; - viewHeight = parentEl.getViewSize().height; - //Normalize y by the scroll position for the parent element. Need to move it into the coordinate space - //of the view. - normalY = y - scrollTop; - max = this.maxHeight ? this.maxHeight : viewHeight - normalY; - if(full > viewHeight) { - max = viewHeight; - //Set returnY equal to (0,0) in view space by reducing y by the value of normalY - returnY = y - normalY; - } else if(max < full) { - returnY = y - (full - max); - max = full; - } - }else{ - max = this.getHeight(); - } - if(full > max && max > 0){ - this.activeMax = max - this.scrollerHeight * 2 - this.el.getFrameWidth('tb') - Ext.num(this.el.shadowOffset, 0); - this.ul.setHeight(this.activeMax); - this.createScrollers(); - this.el.select('.x-menu-scroller').setDisplayed(''); - }else{ - this.ul.setHeight(full); - this.el.select('.x-menu-scroller').setDisplayed('none'); - } - this.ul.dom.scrollTop = 0; - return returnY; - }, - - createScrollers : function(){ - if(!this.scroller){ - this.scroller = { - pos: 0, - top: this.el.insertFirst({ - tag: 'div', - cls: 'x-menu-scroller x-menu-scroller-top', - html: ' ' - }), - bottom: this.el.createChild({ - tag: 'div', - cls: 'x-menu-scroller x-menu-scroller-bottom', - html: ' ' - }) - }; - this.scroller.top.hover(this.onScrollerIn, this.onScrollerOut, this); - this.scroller.topRepeater = new Ext.util.ClickRepeater(this.scroller.top, { - listeners: { - click: this.onScroll.createDelegate(this, [null, this.scroller.top], false) - } - }); - this.scroller.bottom.hover(this.onScrollerIn, this.onScrollerOut, this); - this.scroller.bottomRepeater = new Ext.util.ClickRepeater(this.scroller.bottom, { - listeners: { - click: this.onScroll.createDelegate(this, [null, this.scroller.bottom], false) - } - }); - } - }, - - onLayout : function(){ - if(this.isVisible()){ - if(this.enableScrolling){ - this.constrainScroll(this.el.getTop()); - } - if(this.floating){ - this.el.sync(); - } - } - }, - - focus : function(){ - if(!this.hidden){ - this.doFocus.defer(50, this); + validate : function(){ + if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){ + this.clearInvalid(); + return true; } + return false; }, - doFocus : function(){ - if(!this.hidden){ - this.focusEl.focus(); - } + /** + * This method should only be overridden if necessary to prepare raw values + * for validation (see {@link #validate} and {@link #isValid}). This method + * is expected to return the processed value for the field which will + * be used for validation (see validateValue method). + * @param {Mixed} value + */ + processValue : function(value){ + return value; }, /** - * Hides this menu and optionally all parent menus - * @param {Boolean} deep (optional) True to hide all parent menus recursively, if any (defaults to false) + * Uses getErrors to build an array of validation errors. If any errors are found, markInvalid is called + * with the first and false is returned, otherwise true is returned. Previously, subclasses were invited + * to provide an implementation of this to process validations - from 3.2 onwards getErrors should be + * overridden instead. + * @param {Mixed} The current value of the field + * @return {Boolean} True if all validations passed, false if one or more failed */ - hide : function(deep){ - if (!this.isDestroyed) { - this.deepHide = deep; - Ext.menu.Menu.superclass.hide.call(this); - delete this.deepHide; - } - }, + validateValue : function(value) { + //currently, we only show 1 error at a time for a field, so just use the first one + var error = this.getErrors(value)[0]; - // private - onHide : function(){ - Ext.menu.Menu.superclass.onHide.call(this); - this.deactivateActive(); - if(this.el && this.floating){ - this.el.hide(); - } - var pm = this.parentMenu; - if(this.deepHide === true && pm){ - if(pm.floating){ - pm.hide(true); - }else{ - pm.deactivateActive(); - } - } + if (error == undefined) { + return true; + } else { + this.markInvalid(error); + return false; + } + }, + + /** + * Runs this field's validators and returns an array of error messages for any validation failures. + * This is called internally during validation and would not usually need to be used manually. + * Each subclass should override or augment the return value to provide their own errors + * @return {Array} All error messages for this field + */ + getErrors: function() { + return []; }, - // private - lookupComponent : function(c){ - if(Ext.isString(c)){ - c = (c == 'separator' || c == '-') ? new Ext.menu.Separator() : new Ext.menu.TextItem(c); - this.applyDefaults(c); - }else{ - if(Ext.isObject(c)){ - c = this.getMenuItem(c); - }else if(c.tagName || c.el){ // element. Wrap it. - c = new Ext.BoxComponent({ - el: c - }); - } - } - return c; + /** + * Gets the active error message for this field. + * @return {String} Returns the active error message on the field, if there is no error, an empty string is returned. + */ + getActiveError : function(){ + return this.activeError || ''; }, - applyDefaults : function(c){ - if(!Ext.isString(c)){ - c = Ext.menu.Menu.superclass.applyDefaults.call(this, c); - var d = this.internalDefaults; - if(d){ - if(c.events){ - Ext.applyIf(c.initialConfig, d); - Ext.apply(c, d); - }else{ - Ext.applyIf(c, d); + /** + * Display an error message associated with this field, using {@link #msgTarget} to determine how to + * display the message and applying {@link #invalidClass} to the field's UI element. + * Note: this method does not cause the Field's {@link #validate} method to return false + * if the value does pass validation. So simply marking a Field as invalid will not prevent + * submission of forms submitted with the {@link Ext.form.Action.Submit#clientValidation} option set. + * {@link #isValid invalid}. + * @param {String} msg (optional) The validation message (defaults to {@link #invalidText}) + */ + markInvalid : function(msg){ + //don't set the error icon if we're not rendered or marking is prevented + if (this.rendered && !this.preventMark) { + msg = msg || this.invalidText; + + var mt = this.getMessageHandler(); + if(mt){ + mt.mark(this, msg); + }else if(this.msgTarget){ + this.el.addClass(this.invalidClass); + var t = Ext.getDom(this.msgTarget); + if(t){ + t.innerHTML = msg; + t.style.display = this.msgDisplay; } } } - return c; + + this.setActiveError(msg); }, - - // private - getMenuItem : function(config){ - if(!config.isXType){ - if(!config.xtype && Ext.isBoolean(config.checked)){ - return new Ext.menu.CheckItem(config) + + /** + * Clear any invalid styles/messages for this field + */ + clearInvalid : function(){ + //don't remove the error icon if we're not rendered or marking is prevented + if (this.rendered && !this.preventMark) { + this.el.removeClass(this.invalidClass); + var mt = this.getMessageHandler(); + if(mt){ + mt.clear(this); + }else if(this.msgTarget){ + this.el.removeClass(this.invalidClass); + var t = Ext.getDom(this.msgTarget); + if(t){ + t.innerHTML = ''; + t.style.display = 'none'; + } } - return Ext.create(config, this.defaultType); } - return config; + + this.unsetActiveError(); }, /** - * Adds a separator bar to the menu - * @return {Ext.menu.Item} The menu item that was added + * Sets the current activeError to the given string. Fires the 'invalid' event. + * This does not set up the error icon, only sets the message and fires the event. To show the error icon, + * use markInvalid instead, which calls this method internally + * @param {String} msg The error message + * @param {Boolean} suppressEvent True to suppress the 'invalid' event from being fired */ - addSeparator : function(){ - return this.add(new Ext.menu.Separator()); + setActiveError: function(msg, suppressEvent) { + this.activeError = msg; + if (suppressEvent !== true) this.fireEvent('invalid', this, msg); }, - + /** - * Adds an {@link Ext.Element} object to the menu - * @param {Mixed} el The element or DOM node to add, or its id - * @return {Ext.menu.Item} The menu item that was added + * Clears the activeError and fires the 'valid' event. This is called internally by clearInvalid and would not + * usually need to be called manually + * @param {Boolean} suppressEvent True to suppress the 'invalid' event from being fired */ - addElement : function(el){ - return this.add(new Ext.menu.BaseItem({ - el: el - })); + unsetActiveError: function(suppressEvent) { + delete this.activeError; + if (suppressEvent !== true) this.fireEvent('valid', this); + }, + + // private + getMessageHandler : function(){ + return Ext.form.MessageTargets[this.msgTarget]; + }, + + // private + getErrorCt : function(){ + return this.el.findParent('.x-form-element', 5, true) || // use form element wrap if available + this.el.findParent('.x-form-field-wrap', 5, true); // else direct field wrap + }, + + // Alignment for 'under' target + alignErrorEl : function(){ + this.errorEl.setWidth(this.getErrorCt().getWidth(true) - 20); + }, + + // Alignment for 'side' target + alignErrorIcon : function(){ + this.errorIcon.alignTo(this.el, 'tl-tr', [2, 0]); }, /** - * Adds an existing object based on {@link Ext.menu.BaseItem} to the menu - * @param {Ext.menu.Item} item The menu item to add - * @return {Ext.menu.Item} The menu item that was added + * Returns the raw data value which may or may not be a valid, defined value. To return a normalized value see {@link #getValue}. + * @return {Mixed} value The field value */ - addItem : function(item){ - return this.add(item); + getRawValue : function(){ + var v = this.rendered ? this.el.getValue() : Ext.value(this.value, ''); + if(v === this.emptyText){ + v = ''; + } + return v; }, /** - * Creates a new {@link Ext.menu.Item} based an the supplied config object and adds it to the menu - * @param {Object} config A MenuItem config object - * @return {Ext.menu.Item} The menu item that was added + * Returns the normalized data value (undefined or emptyText will be returned as ''). To return the raw value see {@link #getRawValue}. + * @return {Mixed} value The field value */ - addMenuItem : function(config){ - return this.add(this.getMenuItem(config)); + getValue : function(){ + if(!this.rendered) { + return this.value; + } + var v = this.el.getValue(); + if(v === this.emptyText || v === undefined){ + v = ''; + } + return v; }, /** - * Creates a new {@link Ext.menu.TextItem} with the supplied text and adds it to the menu - * @param {String} text The text to display in the menu item - * @return {Ext.menu.Item} The menu item that was added + * Sets the underlying DOM field's value directly, bypassing validation. To set the value with validation see {@link #setValue}. + * @param {Mixed} value The value to set + * @return {Mixed} value The field value that is set */ - addText : function(text){ - return this.add(new Ext.menu.TextItem(text)); + setRawValue : function(v){ + return this.rendered ? (this.el.dom.value = (Ext.isEmpty(v) ? '' : v)) : ''; }, - //private - onDestroy : function(){ - Ext.EventManager.removeResizeListener(this.hide, this); - var pm = this.parentMenu; - if(pm && pm.activeChild == this){ - delete pm.activeChild; - } - delete this.parentMenu; - Ext.menu.Menu.superclass.onDestroy.call(this); - Ext.menu.MenuMgr.unregister(this); - if(this.keyNav) { - this.keyNav.disable(); - } - var s = this.scroller; - if(s){ - Ext.destroy(s.topRepeater, s.bottomRepeater, s.top, s.bottom); + /** + * Sets a data value into the field and validates it. To set the value directly without validation see {@link #setRawValue}. + * @param {Mixed} value The value to set + * @return {Ext.form.Field} this + */ + setValue : function(v){ + this.value = v; + if(this.rendered){ + this.el.dom.value = (Ext.isEmpty(v) ? '' : v); + this.validate(); } - Ext.destroy( - this.el, - this.focusEl, - this.ul - ); + return this; + }, + + // private, does not work for all fields + append : function(v){ + this.setValue([this.getValue(), v].join('')); } + + /** + * @cfg {Boolean} autoWidth @hide + */ + /** + * @cfg {Boolean} autoHeight @hide + */ + + /** + * @cfg {String} autoEl @hide + */ }); -Ext.reg('menu', Ext.menu.Menu); -// MenuNav is a private utility class used internally by the Menu -Ext.menu.MenuNav = Ext.extend(Ext.KeyNav, function(){ - function up(e, m){ - if(!m.tryActivate(m.items.indexOf(m.activeItem)-1, -1)){ - m.tryActivate(m.items.length-1, -1); +Ext.form.MessageTargets = { + 'qtip' : { + mark: function(field, msg){ + field.el.addClass(field.invalidClass); + field.el.dom.qtip = msg; + field.el.dom.qclass = 'x-form-invalid-tip'; + if(Ext.QuickTips){ // fix for floating editors interacting with DND + Ext.QuickTips.enable(); + } + }, + clear: function(field){ + field.el.removeClass(field.invalidClass); + field.el.dom.qtip = ''; } - } - function down(e, m){ - if(!m.tryActivate(m.items.indexOf(m.activeItem)+1, 1)){ - m.tryActivate(0, 1); + }, + 'title' : { + mark: function(field, msg){ + field.el.addClass(field.invalidClass); + field.el.dom.title = msg; + }, + clear: function(field){ + field.el.dom.title = ''; } - } - return { - constructor : function(menu){ - Ext.menu.MenuNav.superclass.constructor.call(this, menu.el); - this.scope = this.menu = menu; + }, + 'under' : { + mark: function(field, msg){ + field.el.addClass(field.invalidClass); + if(!field.errorEl){ + var elp = field.getErrorCt(); + if(!elp){ // field has no container el + field.el.dom.title = msg; + return; + } + field.errorEl = elp.createChild({cls:'x-form-invalid-msg'}); + field.on('resize', field.alignErrorEl, field); + field.on('destroy', function(){ + Ext.destroy(this.errorEl); + }, field); + } + field.alignErrorEl(); + field.errorEl.update(msg); + Ext.form.Field.msgFx[field.msgFx].show(field.errorEl, field); }, - - doRelay : function(e, h){ - var k = e.getKey(); -// Keystrokes within a form Field (e.g.: down in a Combo) do not navigate. Allow only TAB - if (this.menu.activeItem && this.menu.activeItem.isFormField && k != e.TAB) { - return false; + clear: function(field){ + field.el.removeClass(field.invalidClass); + if(field.errorEl){ + Ext.form.Field.msgFx[field.msgFx].hide(field.errorEl, field); + }else{ + field.el.dom.title = ''; } - if(!this.menu.activeItem && e.isNavKeyPress() && k != e.SPACE && k != e.RETURN){ - this.menu.tryActivate(0, 1); - return false; + } + }, + 'side' : { + mark: function(field, msg){ + field.el.addClass(field.invalidClass); + if(!field.errorIcon){ + var elp = field.getErrorCt(); + // field has no container el + if(!elp){ + field.el.dom.title = msg; + return; + } + field.errorIcon = elp.createChild({cls:'x-form-invalid-icon'}); + if (field.ownerCt) { + field.ownerCt.on('afterlayout', field.alignErrorIcon, field); + field.ownerCt.on('expand', field.alignErrorIcon, field); + } + field.on('resize', field.alignErrorIcon, field); + field.on('destroy', function(){ + Ext.destroy(this.errorIcon); + }, field); } - return h.call(this.scope || this, e, this.menu); + field.alignErrorIcon(); + field.errorIcon.dom.qtip = msg; + field.errorIcon.dom.qclass = 'x-form-invalid-tip'; + field.errorIcon.show(); }, - - tab: function(e, m) { - e.stopEvent(); - if (e.shiftKey) { - up(e, m); - } else { - down(e, m); + clear: function(field){ + field.el.removeClass(field.invalidClass); + if(field.errorIcon){ + field.errorIcon.dom.qtip = ''; + field.errorIcon.hide(); + }else{ + field.el.dom.title = ''; } + } + } +}; + +// anything other than normal should be considered experimental +Ext.form.Field.msgFx = { + normal : { + show: function(msgEl, f){ + msgEl.setDisplayed('block'); }, - up : up, + hide : function(msgEl, f){ + msgEl.setDisplayed(false).update(''); + } + }, - down : down, + slide : { + show: function(msgEl, f){ + msgEl.slideIn('t', {stopFx:true}); + }, - right : function(e, m){ - if(m.activeItem){ - m.activeItem.expandMenu(true); - } + hide : function(msgEl, f){ + msgEl.slideOut('t', {stopFx:true,useDisplay:true}); + } + }, + + slideRight : { + show: function(msgEl, f){ + msgEl.fixDisplay(); + msgEl.alignTo(f.el, 'tl-tr'); + msgEl.slideIn('l', {stopFx:true}); }, - left : function(e, m){ - m.hide(); - if(m.parentMenu && m.parentMenu.activeItem){ - m.parentMenu.activeItem.activate(); + hide : function(msgEl, f){ + msgEl.slideOut('l', {stopFx:true,useDisplay:true}); + } + } +}; +Ext.reg('field', Ext.form.Field); +/** + * @class Ext.form.TextField + * @extends Ext.form.Field + * Basic text field. Can be used as a direct replacement for traditional text inputs, + * or as the base class for more sophisticated input controls (like {@link Ext.form.TextArea} + * and {@link Ext.form.ComboBox}). + * Validation + * The validation procedure is described in the documentation for {@link #validateValue}. + * Alter Validation Behavior + * Validation behavior for each field can be configured: + * + * {@link Ext.form.TextField#invalidText invalidText} : the default validation message to + * show if any validation step above does not provide a message when invalid + * {@link Ext.form.TextField#maskRe maskRe} : filter out keystrokes before any validation occurs + * {@link Ext.form.TextField#stripCharsRe stripCharsRe} : filter characters after being typed in, + * but before being validated + * {@link Ext.form.Field#invalidClass invalidClass} : alternate style when invalid + * {@link Ext.form.Field#validateOnBlur validateOnBlur}, + * {@link Ext.form.Field#validationDelay validationDelay}, and + * {@link Ext.form.Field#validationEvent validationEvent} : modify how/when validation is triggered + * + * + * @constructor Creates a new TextField + * @param {Object} config Configuration options + * + * @xtype textfield + */ +Ext.form.TextField = Ext.extend(Ext.form.Field, { + /** + * @cfg {String} vtypeText A custom error message to display in place of the default message provided + * for the {@link #vtype} currently set for this field (defaults to ''). Note: + * only applies if {@link #vtype} is set, else ignored. + */ + /** + * @cfg {RegExp} stripCharsRe A JavaScript RegExp object used to strip unwanted content from the value + * before validation (defaults to null). + */ + /** + * @cfg {Boolean} grow true if this field should automatically grow and shrink to its content + * (defaults to false) + */ + grow : false, + /** + * @cfg {Number} growMin The minimum width to allow when {@link #grow} = true (defaults + * to 30) + */ + growMin : 30, + /** + * @cfg {Number} growMax The maximum width to allow when {@link #grow} = true (defaults + * to 800) + */ + growMax : 800, + /** + * @cfg {String} vtype A validation type name as defined in {@link Ext.form.VTypes} (defaults to null) + */ + vtype : null, + /** + * @cfg {RegExp} maskRe An input mask regular expression that will be used to filter keystrokes that do + * not match (defaults to null) + */ + maskRe : null, + /** + * @cfg {Boolean} disableKeyFilter Specify true to disable input keystroke filtering (defaults + * to false) + */ + disableKeyFilter : false, + /** + * @cfg {Boolean} allowBlank Specify false to validate that the value's length is > 0 (defaults to + * true) + */ + allowBlank : true, + /** + * @cfg {Number} minLength Minimum input field length required (defaults to 0) + */ + minLength : 0, + /** + * @cfg {Number} maxLength Maximum input field length allowed by validation (defaults to Number.MAX_VALUE). + * This behavior is intended to provide instant feedback to the user by improving usability to allow pasting + * and editing or overtyping and back tracking. To restrict the maximum number of characters that can be + * entered into the field use {@link Ext.form.Field#autoCreate autoCreate} to add + * any attributes you want to a field, for example: +var myField = new Ext.form.NumberField({ + id: 'mobile', + anchor:'90%', + fieldLabel: 'Mobile', + maxLength: 16, // for validation + autoCreate: {tag: 'input', type: 'text', size: '20', autocomplete: 'off', maxlength: '10'} +}); + + */ + maxLength : Number.MAX_VALUE, + /** + * @cfg {String} minLengthText Error text to display if the {@link #minLength minimum length} + * validation fails (defaults to 'The minimum length for this field is {minLength}') + */ + minLengthText : 'The minimum length for this field is {0}', + /** + * @cfg {String} maxLengthText Error text to display if the {@link #maxLength maximum length} + * validation fails (defaults to 'The maximum length for this field is {maxLength}') + */ + maxLengthText : 'The maximum length for this field is {0}', + /** + * @cfg {Boolean} selectOnFocus true to automatically select any existing field text when the field + * receives input focus (defaults to false) + */ + selectOnFocus : false, + /** + * @cfg {String} blankText The error text to display if the {@link #allowBlank} validation + * fails (defaults to 'This field is required') + */ + blankText : 'This field is required', + /** + * @cfg {Function} validator + * A custom validation function to be called during field validation ({@link #validateValue}) + * (defaults to null). If specified, this function will be called first, allowing the + * developer to override the default validation process. + * This function will be passed the following Parameters: + * + * value: Mixed + * The current field value + * + * This function is to Return: + * + * true: Boolean + * true if the value is valid + * msg: String + * An error message if the value is invalid + * + */ + validator : null, + /** + * @cfg {RegExp} regex A JavaScript RegExp object to be tested against the field value during validation + * (defaults to null). If the test fails, the field will be marked invalid using + * {@link #regexText}. + */ + regex : null, + /** + * @cfg {String} regexText The error text to display if {@link #regex} is used and the + * test fails during validation (defaults to '') + */ + regexText : '', + /** + * @cfg {String} emptyText The default text to place into an empty field (defaults to null). + * Note: that this value will be submitted to the server if this field is enabled and configured + * with a {@link #name}. + */ + emptyText : null, + /** + * @cfg {String} emptyClass The CSS class to apply to an empty field to style the {@link #emptyText} + * (defaults to 'x-form-empty-field'). This class is automatically added and removed as needed + * depending on the current field value. + */ + emptyClass : 'x-form-empty-field', + + /** + * @cfg {Boolean} enableKeyEvents true to enable the proxying of key events for the HTML input + * field (defaults to false) + */ + + initComponent : function(){ + Ext.form.TextField.superclass.initComponent.call(this); + this.addEvents( + /** + * @event autosize + * Fires when the {@link #autoSize} function is triggered. The field may or + * may not have actually changed size according to the default logic, but this event provides + * a hook for the developer to apply additional logic at runtime to resize the field if needed. + * @param {Ext.form.Field} this This text field + * @param {Number} width The new field width + */ + 'autosize', + + /** + * @event keydown + * Keydown input field event. This event only fires if {@link #enableKeyEvents} + * is set to true. + * @param {Ext.form.TextField} this This text field + * @param {Ext.EventObject} e + */ + 'keydown', + /** + * @event keyup + * Keyup input field event. This event only fires if {@link #enableKeyEvents} + * is set to true. + * @param {Ext.form.TextField} this This text field + * @param {Ext.EventObject} e + */ + 'keyup', + /** + * @event keypress + * Keypress input field event. This event only fires if {@link #enableKeyEvents} + * is set to true. + * @param {Ext.form.TextField} this This text field + * @param {Ext.EventObject} e + */ + 'keypress' + ); + }, + + // private + initEvents : function(){ + Ext.form.TextField.superclass.initEvents.call(this); + if(this.validationEvent == 'keyup'){ + this.validationTask = new Ext.util.DelayedTask(this.validate, this); + this.mon(this.el, 'keyup', this.filterValidation, this); + } + else if(this.validationEvent !== false && this.validationEvent != 'blur'){ + this.mon(this.el, this.validationEvent, this.validate, this, {buffer: this.validationDelay}); + } + if(this.selectOnFocus || this.emptyText){ + this.mon(this.el, 'mousedown', this.onMouseDown, this); + + if(this.emptyText){ + this.applyEmptyText(); } - }, + } + if(this.maskRe || (this.vtype && this.disableKeyFilter !== true && (this.maskRe = Ext.form.VTypes[this.vtype+'Mask']))){ + this.mon(this.el, 'keypress', this.filterKeys, this); + } + if(this.grow){ + this.mon(this.el, 'keyup', this.onKeyUpBuffered, this, {buffer: 50}); + this.mon(this.el, 'click', this.autoSize, this); + } + if(this.enableKeyEvents){ + this.mon(this.el, { + scope: this, + keyup: this.onKeyUp, + keydown: this.onKeyDown, + keypress: this.onKeyPress + }); + } + }, + + onMouseDown: function(e){ + if(!this.hasFocus){ + this.mon(this.el, 'mouseup', Ext.emptyFn, this, { single: true, preventDefault: true }); + } + }, - enter : function(e, m){ - if(m.activeItem){ - e.stopPropagation(); - m.activeItem.onClick(e); - m.fireEvent('click', this, m.activeItem); - return true; + processValue : function(value){ + if(this.stripCharsRe){ + var newValue = value.replace(this.stripCharsRe, ''); + if(newValue !== value){ + this.setRawValue(newValue); + return newValue; } } - }; -}()); -/** - * @class Ext.menu.MenuMgr - * Provides a common registry of all menu items on a page so that they can be easily accessed by id. - * @singleton - */ -Ext.menu.MenuMgr = function(){ - var menus, active, groups = {}, attached = false, lastShow = new Date(); - - // private - called when first menu is created - function init(){ - menus = {}; - active = new Ext.util.MixedCollection(); - Ext.getDoc().addKeyListener(27, function(){ - if(active.length > 0){ - hideAll(); - } - }); - } - - // private - function hideAll(){ - if(active && active.length > 0){ - var c = active.clone(); - c.each(function(m){ - m.hide(); - }); - return true; - } - return false; - } - - // private - function onHide(m){ - active.remove(m); - if(active.length < 1){ - Ext.getDoc().un("mousedown", onMouseDown); - attached = false; - } - } + return value; + }, - // private - function onShow(m){ - var last = active.last(); - lastShow = new Date(); - active.add(m); - if(!attached){ - Ext.getDoc().on("mousedown", onMouseDown); - attached = true; - } - if(m.parentMenu){ - m.getEl().setZIndex(parseInt(m.parentMenu.getEl().getStyle("z-index"), 10) + 3); - m.parentMenu.activeChild = m; - }else if(last && !last.isDestroyed && last.isVisible()){ - m.getEl().setZIndex(parseInt(last.getEl().getStyle("z-index"), 10) + 3); - } - } + filterValidation : function(e){ + if(!e.isNavKeyPress()){ + this.validationTask.delay(this.validationDelay); + } + }, + + //private + onDisable: function(){ + Ext.form.TextField.superclass.onDisable.call(this); + if(Ext.isIE){ + this.el.dom.unselectable = 'on'; + } + }, + + //private + onEnable: function(){ + Ext.form.TextField.superclass.onEnable.call(this); + if(Ext.isIE){ + this.el.dom.unselectable = ''; + } + }, - // private - function onBeforeHide(m){ - if(m.activeChild){ - m.activeChild.hide(); - } - if(m.autoHideTimer){ - clearTimeout(m.autoHideTimer); - delete m.autoHideTimer; - } - } + // private + onKeyUpBuffered : function(e){ + if(this.doAutoSize(e)){ + this.autoSize(); + } + }, + + // private + doAutoSize : function(e){ + return !e.isNavKeyPress(); + }, - // private - function onBeforeShow(m){ - var pm = m.parentMenu; - if(!pm && !m.allowOtherMenus){ - hideAll(); - }else if(pm && pm.activeChild){ - pm.activeChild.hide(); - } - } + // private + onKeyUp : function(e){ + this.fireEvent('keyup', this, e); + }, - // private - function onMouseDown(e){ - if(lastShow.getElapsed() > 50 && active.length > 0 && !e.getTarget(".x-menu")){ - hideAll(); - } - } + // private + onKeyDown : function(e){ + this.fireEvent('keydown', this, e); + }, - // private - function onBeforeCheck(mi, state){ - if(state){ - var g = groups[mi.group]; - for(var i = 0, l = g.length; i < l; i++){ - if(g[i] != mi){ - g[i].setChecked(false); - } - } - } - } + // private + onKeyPress : function(e){ + this.fireEvent('keypress', this, e); + }, - return { + /** + * Resets the current field value to the originally-loaded value and clears any validation messages. + * Also adds {@link #emptyText} and {@link #emptyClass} if the + * original value was blank. + */ + reset : function(){ + Ext.form.TextField.superclass.reset.call(this); + this.applyEmptyText(); + }, - /** - * Hides all menus that are currently visible - * @return {Boolean} success True if any active menus were hidden. - */ - hideAll : function(){ - return hideAll(); - }, + applyEmptyText : function(){ + if(this.rendered && this.emptyText && this.getRawValue().length < 1 && !this.hasFocus){ + this.setRawValue(this.emptyText); + this.el.addClass(this.emptyClass); + } + }, - // private - register : function(menu){ - if(!menus){ - init(); - } - menus[menu.id] = menu; - menu.on({ - beforehide: onBeforeHide, - hide: onHide, - beforeshow: onBeforeShow, - show: onShow - }); - }, + // private + preFocus : function(){ + var el = this.el; + if(this.emptyText){ + if(el.dom.value == this.emptyText){ + this.setRawValue(''); + } + el.removeClass(this.emptyClass); + } + if(this.selectOnFocus){ + el.dom.select(); + } + }, - /** - * Returns a {@link Ext.menu.Menu} object - * @param {String/Object} menu The string menu id, an existing menu object reference, or a Menu config that will - * be used to generate and return a new Menu instance. - * @return {Ext.menu.Menu} The specified menu, or null if none are found - */ - get : function(menu){ - if(typeof menu == "string"){ // menu id - if(!menus){ // not initialized, no menus to return - return null; - } - return menus[menu]; - }else if(menu.events){ // menu instance - return menu; - }else if(typeof menu.length == 'number'){ // array of menu items? - return new Ext.menu.Menu({items:menu}); - }else{ // otherwise, must be a config - return Ext.create(menu, 'menu'); - } - }, + // private + postBlur : function(){ + this.applyEmptyText(); + }, - // private - unregister : function(menu){ - delete menus[menu.id]; - menu.un("beforehide", onBeforeHide); - menu.un("hide", onHide); - menu.un("beforeshow", onBeforeShow); - menu.un("show", onShow); - }, + // private + filterKeys : function(e){ + if(e.ctrlKey){ + return; + } + var k = e.getKey(); + if(Ext.isGecko && (e.isNavKeyPress() || k == e.BACKSPACE || (k == e.DELETE && e.button == -1))){ + return; + } + var cc = String.fromCharCode(e.getCharCode()); + if(!Ext.isGecko && e.isSpecialKey() && !cc){ + return; + } + if(!this.maskRe.test(cc)){ + e.stopEvent(); + } + }, - // private - registerCheckable : function(menuItem){ - var g = menuItem.group; - if(g){ - if(!groups[g]){ - groups[g] = []; - } - groups[g].push(menuItem); - menuItem.on("beforecheckchange", onBeforeCheck); - } - }, + setValue : function(v){ + if(this.emptyText && this.el && !Ext.isEmpty(v)){ + this.el.removeClass(this.emptyClass); + } + Ext.form.TextField.superclass.setValue.apply(this, arguments); + this.applyEmptyText(); + this.autoSize(); + return this; + }, - // private - unregisterCheckable : function(menuItem){ - var g = menuItem.group; - if(g){ - groups[g].remove(menuItem); - menuItem.un("beforecheckchange", onBeforeCheck); - } - }, + /** + * Validates a value according to the field's validation rules and returns an array of errors + * for any failing validations. Validation rules are processed in the following order: + * + * + * 1. Field specific validator + * + * A validator offers a way to customize and reuse a validation specification. + * If a field is configured with a {@link #validator} + * function, it will be passed the current field value. The {@link #validator} + * function is expected to return either: + * + * Boolean true if the value is valid (validation continues). + * a String to represent the invalid message if invalid (validation halts). + * + * + * + * 2. Basic Validation + * + * If the {@link #validator} has not halted validation, + * basic validation proceeds as follows: + * + * + * + * {@link #allowBlank} : (Invalid message = + * {@link #emptyText}) + * Depending on the configuration of {@link #allowBlank}, a + * blank field will cause validation to halt at this step and return + * Boolean true or false accordingly. + * + * + * {@link #minLength} : (Invalid message = + * {@link #minLengthText}) + * If the passed value does not satisfy the {@link #minLength} + * specified, validation halts. + * + * + * {@link #maxLength} : (Invalid message = + * {@link #maxLengthText}) + * If the passed value does not satisfy the {@link #maxLength} + * specified, validation halts. + * + * + * + * + * + * 3. Preconfigured Validation Types (VTypes) + * + * If none of the prior validation steps halts validation, a field + * configured with a {@link #vtype} will utilize the + * corresponding {@link Ext.form.VTypes VTypes} validation function. + * If invalid, either the field's {@link #vtypeText} or + * the VTypes vtype Text property will be used for the invalid message. + * Keystrokes on the field will be filtered according to the VTypes + * vtype Mask property. + * + * + * 4. Field specific regex test + * + * If none of the prior validation steps halts validation, a field's + * configured {@link #regex} test will be processed. + * The invalid message for this test is configured with + * {@link #regexText}. + * + * + * @param {Mixed} value The value to validate. The processed raw value will be used if nothing is passed + * @return {Array} Array of any validation errors + */ + getErrors: function(value) { + var errors = Ext.form.TextField.superclass.getErrors.apply(this, arguments); + + value = value || this.processValue(this.getRawValue()); + + if(Ext.isFunction(this.validator)){ + var msg = this.validator(value); + if (msg !== true) { + errors.push(msg); + } + } + + if (!this.allowBlank && (value.length < 1 || value === this.emptyText)) { // if it's blank + errors.push(this.blankText); + } + + if (value.length < this.minLength) { + errors.push(String.format(this.minLengthText, this.minLength)); + } + + if (value.length > this.maxLength) { + errors.push(String.format(this.maxLengthText, this.maxLength)); + } + + if (this.vtype) { + var vt = Ext.form.VTypes; + if(!vt[this.vtype](value, this)){ + errors.push(this.vtypeText || vt[this.vtype +'Text']); + } + } + + if (this.regex && !this.regex.test(value)) { + errors.push(this.regexText); + } + + return errors; + }, - getCheckedItem : function(groupId){ - var g = groups[groupId]; - if(g){ - for(var i = 0, l = g.length; i < l; i++){ - if(g[i].checked){ - return g[i]; - } - } - } - return null; - }, + /** + * Selects text in this field + * @param {Number} start (optional) The index where the selection should start (defaults to 0) + * @param {Number} end (optional) The index where the selection should end (defaults to the text length) + */ + selectText : function(start, end){ + var v = this.getRawValue(); + var doFocus = false; + if(v.length > 0){ + start = start === undefined ? 0 : start; + end = end === undefined ? v.length : end; + var d = this.el.dom; + if(d.setSelectionRange){ + d.setSelectionRange(start, end); + }else if(d.createTextRange){ + var range = d.createTextRange(); + range.moveStart('character', start); + range.moveEnd('character', end-v.length); + range.select(); + } + doFocus = Ext.isGecko || Ext.isOpera; + }else{ + doFocus = true; + } + if(doFocus){ + this.focus(); + } + }, - setCheckedItem : function(groupId, itemId){ - var g = groups[groupId]; - if(g){ - for(var i = 0, l = g.length; i < l; i++){ - if(g[i].id == itemId){ - g[i].setChecked(true); - } - } - } - return null; - } - }; -}(); + /** + * Automatically grows the field to accomodate the width of the text up to the maximum field width allowed. + * This only takes effect if {@link #grow} = true, and fires the {@link #autosize} event. + */ + autoSize : function(){ + if(!this.grow || !this.rendered){ + return; + } + if(!this.metrics){ + this.metrics = Ext.util.TextMetrics.createInstance(this.el); + } + var el = this.el; + var v = el.dom.value; + var d = document.createElement('div'); + d.appendChild(document.createTextNode(v)); + v = d.innerHTML; + Ext.removeNode(d); + d = null; + v += ' '; + var w = Math.min(this.growMax, Math.max(this.metrics.getWidth(v) + /* add extra padding */ 10, this.growMin)); + this.el.setWidth(w); + this.fireEvent('autosize', this, w); + }, + + onDestroy: function(){ + if(this.validationTask){ + this.validationTask.cancel(); + this.validationTask = null; + } + Ext.form.TextField.superclass.onDestroy.call(this); + } +}); +Ext.reg('textfield', Ext.form.TextField); /** - * @class Ext.menu.BaseItem - * @extends Ext.Component - * The base class for all items that render into menus. BaseItem provides default rendering, activated state - * management and base configuration options shared by all menu components. + * @class Ext.form.TriggerField + * @extends Ext.form.TextField + * Provides a convenient wrapper for TextFields that adds a clickable trigger button (looks like a combobox by default). + * The trigger has no default action, so you must assign a function to implement the trigger click handler by + * overriding {@link #onTriggerClick}. You can create a TriggerField directly, as it renders exactly like a combobox + * for which you can provide a custom implementation. For example: + * +var trigger = new Ext.form.TriggerField(); +trigger.onTriggerClick = myTriggerFn; +trigger.applyToMarkup('my-field'); + + * + * However, in general you will most likely want to use TriggerField as the base class for a reusable component. + * {@link Ext.form.DateField} and {@link Ext.form.ComboBox} are perfect examples of this. + * * @constructor - * Creates a new BaseItem - * @param {Object} config Configuration options - * @xtype menubaseitem + * Create a new TriggerField. + * @param {Object} config Configuration options (valid {@Ext.form.TextField} config options will also be applied + * to the base TextField) + * @xtype trigger */ -Ext.menu.BaseItem = Ext.extend(Ext.Component, { +Ext.form.TriggerField = Ext.extend(Ext.form.TextField, { /** - * @property parentMenu - * @type Ext.menu.Menu - * The parent Menu of this Item. + * @cfg {String} triggerClass + * An additional CSS class used to style the trigger button. The trigger will always get the + * class 'x-form-trigger' by default and triggerClass will be appended if specified. */ /** - * @cfg {Function} handler - * A function that will handle the click event of this menu item (optional). - * The handler is passed the following parameters: - * b : ItemThis menu Item. - * e : EventObjectThe click event. - * + * @cfg {Mixed} triggerConfig + * A {@link Ext.DomHelper DomHelper} config object specifying the structure of the + * trigger element for this Field. (Optional). + * Specify this when you need a customized element to act as the trigger button for a TriggerField. + * Note that when using this option, it is the developer's responsibility to ensure correct sizing, positioning + * and appearance of the trigger. Defaults to: + * {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass} */ /** - * @cfg {Object} scope - * The scope (this reference) in which the handler function will be called. + * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default + * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. + * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: + * {tag: "input", type: "text", size: "16", autocomplete: "off"} */ + defaultAutoCreate : {tag: "input", type: "text", size: "16", autocomplete: "off"}, /** - * @cfg {Boolean} canActivate True if this item can be visually activated (defaults to false) + * @cfg {Boolean} hideTrigger true to hide the trigger element and display only the base + * text field (defaults to false) */ - canActivate : false, + hideTrigger:false, + /** + * @cfg {Boolean} editable false to prevent the user from typing text directly into the field, + * the field will only respond to a click on the trigger to set the value. (defaults to true). + */ + editable: true, /** - * @cfg {String} activeClass The CSS class to use when the item becomes activated (defaults to "x-menu-item-active") + * @cfg {Boolean} readOnly true to prevent the user from changing the field, and + * hides the trigger. Superceeds the editable and hideTrigger options if the value is true. + * (defaults to false) */ - activeClass : "x-menu-item-active", + readOnly: false, /** - * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to true) + * @cfg {String} wrapFocusClass The class added to the to the wrap of the trigger element. Defaults to + * x-trigger-wrap-focus. */ - hideOnClick : true, + wrapFocusClass: 'x-trigger-wrap-focus', /** - * @cfg {Number} clickHideDelay Length of time in milliseconds to wait before hiding after a click (defaults to 100) + * @hide + * @method autoSize */ - clickHideDelay : 1, + autoSize: Ext.emptyFn, + // private + monitorTab : true, + // private + deferHeight : true, + // private + mimicing : false, + + actionMode: 'wrap', + + defaultTriggerWidth: 17, // private - ctype : "Ext.menu.BaseItem", + onResize : function(w, h){ + Ext.form.TriggerField.superclass.onResize.call(this, w, h); + var tw = this.getTriggerWidth(); + if(Ext.isNumber(w)){ + this.el.setWidth(w - tw); + } + this.wrap.setWidth(this.el.getWidth() + tw); + }, + + getTriggerWidth: function(){ + var tw = this.trigger.getWidth(); + if(!this.hideTrigger && !this.readOnly && tw === 0){ + tw = this.defaultTriggerWidth; + } + return tw; + }, // private - actionMode : "container", - - initComponent : function(){ - Ext.menu.BaseItem.superclass.initComponent.call(this); - this.addEvents( - /** - * @event click - * Fires when this item is clicked - * @param {Ext.menu.BaseItem} this - * @param {Ext.EventObject} e - */ - 'click', - /** - * @event activate - * Fires when this item is activated - * @param {Ext.menu.BaseItem} this - */ - 'activate', - /** - * @event deactivate - * Fires when this item is deactivated - * @param {Ext.menu.BaseItem} this - */ - 'deactivate' - ); - if(this.handler){ - this.on("click", this.handler, this.scope); - } + alignErrorIcon : function(){ + if(this.wrap){ + this.errorIcon.alignTo(this.wrap, 'tl-tr', [2, 0]); + } }, // private - onRender : function(container, position){ - Ext.menu.BaseItem.superclass.onRender.apply(this, arguments); - if(this.ownerCt && this.ownerCt instanceof Ext.menu.Menu){ - this.parentMenu = this.ownerCt; - }else{ - this.container.addClass('x-menu-list-item'); - this.mon(this.el, { - scope: this, - click: this.onClick, - mouseenter: this.activate, - mouseleave: this.deactivate - }); + onRender : function(ct, position){ + this.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc(); + Ext.form.TriggerField.superclass.onRender.call(this, ct, position); + + this.wrap = this.el.wrap({cls: 'x-form-field-wrap x-form-field-trigger-wrap'}); + this.trigger = this.wrap.createChild(this.triggerConfig || + {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass}); + this.initTrigger(); + if(!this.width){ + this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth()); + } + this.resizeEl = this.positionEl = this.wrap; + }, + + getWidth: function() { + return(this.el.getWidth() + this.trigger.getWidth()); + }, + + updateEditState: function(){ + if(this.rendered){ + if (this.readOnly) { + this.el.dom.readOnly = true; + this.el.addClass('x-trigger-noedit'); + this.mun(this.el, 'click', this.onTriggerClick, this); + this.trigger.setDisplayed(false); + } else { + if (!this.editable) { + this.el.dom.readOnly = true; + this.el.addClass('x-trigger-noedit'); + this.mon(this.el, 'click', this.onTriggerClick, this); + } else { + this.el.dom.readOnly = false; + this.el.removeClass('x-trigger-noedit'); + this.mun(this.el, 'click', this.onTriggerClick, this); + } + this.trigger.setDisplayed(!this.hideTrigger); + } + this.onResize(this.width || this.wrap.getWidth()); + } + }, + + setHideTrigger: function(hideTrigger){ + if(hideTrigger != this.hideTrigger){ + this.hideTrigger = hideTrigger; + this.updateEditState(); } }, /** - * Sets the function that will handle click events for this item (equivalent to passing in the {@link #handler} - * config property). If an existing handler is already registered, it will be unregistered for you. - * @param {Function} handler The function that should be called on click - * @param {Object} scope The scope (this reference) in which the handler function is executed. Defaults to this menu item. + * @param {Boolean} value True to allow the user to directly edit the field text + * Allow or prevent the user from directly editing the field text. If false is passed, + * the user will only be able to modify the field using the trigger. Will also add + * a click event to the text field which will call the trigger. This method + * is the runtime equivalent of setting the 'editable' config option at config time. */ - setHandler : function(handler, scope){ - if(this.handler){ - this.un("click", this.handler, this.scope); + setEditable: function(editable){ + if(editable != this.editable){ + this.editable = editable; + this.updateEditState(); + } + }, + + /** + * @param {Boolean} value True to prevent the user changing the field and explicitly + * hide the trigger. + * Setting this to true will superceed settings editable and hideTrigger. + * Setting this to false will defer back to editable and hideTrigger. This method + * is the runtime equivalent of setting the 'readOnly' config option at config time. + */ + setReadOnly: function(readOnly){ + if(readOnly != this.readOnly){ + this.readOnly = readOnly; + this.updateEditState(); } - this.on("click", this.handler = handler, this.scope = scope); + }, + + afterRender : function(){ + Ext.form.TriggerField.superclass.afterRender.call(this); + this.updateEditState(); }, // private - onClick : function(e){ - if(!this.disabled && this.fireEvent("click", this, e) !== false - && (this.parentMenu && this.parentMenu.fireEvent("itemclick", this, e) !== false)){ - this.handleClick(e); - }else{ - e.stopEvent(); + initTrigger : function(){ + this.mon(this.trigger, 'click', this.onTriggerClick, this, {preventDefault:true}); + this.trigger.addClassOnOver('x-form-trigger-over'); + this.trigger.addClassOnClick('x-form-trigger-click'); + }, + + // private + onDestroy : function(){ + Ext.destroy(this.trigger, this.wrap); + if (this.mimicing){ + this.doc.un('mousedown', this.mimicBlur, this); } + delete this.doc; + Ext.form.TriggerField.superclass.onDestroy.call(this); }, // private - activate : function(){ - if(this.disabled){ - return false; + onFocus : function(){ + Ext.form.TriggerField.superclass.onFocus.call(this); + if(!this.mimicing){ + this.wrap.addClass(this.wrapFocusClass); + this.mimicing = true; + this.doc.on('mousedown', this.mimicBlur, this, {delay: 10}); + if(this.monitorTab){ + this.on('specialkey', this.checkTab, this); + } } - var li = this.container; - li.addClass(this.activeClass); - this.region = li.getRegion().adjust(2, 2, -2, -2); - this.fireEvent("activate", this); - return true; }, // private - deactivate : function(){ - this.container.removeClass(this.activeClass); - this.fireEvent("deactivate", this); + checkTab : function(me, e){ + if(e.getKey() == e.TAB){ + this.triggerBlur(); + } }, // private - shouldDeactivate : function(e){ - return !this.region || !this.region.contains(e.getPoint()); + onBlur : Ext.emptyFn, + + // private + mimicBlur : function(e){ + if(!this.isDestroyed && !this.wrap.contains(e.target) && this.validateBlur(e)){ + this.triggerBlur(); + } }, // private - handleClick : function(e){ - var pm = this.parentMenu; - if(this.hideOnClick){ - if(pm.floating){ - pm.hide.defer(this.clickHideDelay, pm, [true]); + triggerBlur : function(){ + this.mimicing = false; + this.doc.un('mousedown', this.mimicBlur, this); + if(this.monitorTab && this.el){ + this.un('specialkey', this.checkTab, this); + } + Ext.form.TriggerField.superclass.onBlur.call(this); + if(this.wrap){ + this.wrap.removeClass(this.wrapFocusClass); + } + }, + + beforeBlur : Ext.emptyFn, + + // private + // This should be overriden by any subclass that needs to check whether or not the field can be blurred. + validateBlur : function(e){ + return true; + }, + + /** + * The function that should handle the trigger's click event. This method does nothing by default + * until overridden by an implementing function. See Ext.form.ComboBox and Ext.form.DateField for + * sample implementations. + * @method + * @param {EventObject} e + */ + onTriggerClick : Ext.emptyFn + + /** + * @cfg {Boolean} grow @hide + */ + /** + * @cfg {Number} growMin @hide + */ + /** + * @cfg {Number} growMax @hide + */ +}); + +/** + * @class Ext.form.TwinTriggerField + * @extends Ext.form.TriggerField + * TwinTriggerField is not a public class to be used directly. It is meant as an abstract base class + * to be extended by an implementing class. For an example of implementing this class, see the custom + * SearchField implementation here: + * http://extjs.com/deploy/ext/examples/form/custom.html + */ +Ext.form.TwinTriggerField = Ext.extend(Ext.form.TriggerField, { + /** + * @cfg {Mixed} triggerConfig + * A {@link Ext.DomHelper DomHelper} config object specifying the structure of the trigger elements + * for this Field. (Optional). + * Specify this when you need a customized element to contain the two trigger elements for this Field. + * Each trigger element must be marked by the CSS class x-form-trigger (also see + * {@link #trigger1Class} and {@link #trigger2Class}). + * Note that when using this option, it is the developer's responsibility to ensure correct sizing, + * positioning and appearance of the triggers. + */ + /** + * @cfg {String} trigger1Class + * An additional CSS class used to style the trigger button. The trigger will always get the + * class 'x-form-trigger' by default and triggerClass will be appended if specified. + */ + /** + * @cfg {String} trigger2Class + * An additional CSS class used to style the trigger button. The trigger will always get the + * class 'x-form-trigger' by default and triggerClass will be appended if specified. + */ + + initComponent : function(){ + Ext.form.TwinTriggerField.superclass.initComponent.call(this); + + this.triggerConfig = { + tag:'span', cls:'x-form-twin-triggers', cn:[ + {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger1Class}, + {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger2Class} + ]}; + }, + + getTrigger : function(index){ + return this.triggers[index]; + }, + + initTrigger : function(){ + var ts = this.trigger.select('.x-form-trigger', true); + var triggerField = this; + ts.each(function(t, all, index){ + var triggerIndex = 'Trigger'+(index+1); + t.hide = function(){ + var w = triggerField.wrap.getWidth(); + this.dom.style.display = 'none'; + triggerField.el.setWidth(w-triggerField.trigger.getWidth()); + this['hidden' + triggerIndex] = true; + }; + t.show = function(){ + var w = triggerField.wrap.getWidth(); + this.dom.style.display = ''; + triggerField.el.setWidth(w-triggerField.trigger.getWidth()); + this['hidden' + triggerIndex] = false; + }; + + if(this['hide'+triggerIndex]){ + t.dom.style.display = 'none'; + this['hidden' + triggerIndex] = true; + } + this.mon(t, 'click', this['on'+triggerIndex+'Click'], this, {preventDefault:true}); + t.addClassOnOver('x-form-trigger-over'); + t.addClassOnClick('x-form-trigger-click'); + }, this); + this.triggers = ts.elements; + }, + + getTriggerWidth: function(){ + var tw = 0; + Ext.each(this.triggers, function(t, index){ + var triggerIndex = 'Trigger' + (index + 1), + w = t.getWidth(); + if(w === 0 && !this['hidden' + triggerIndex]){ + tw += this.defaultTriggerWidth; }else{ - pm.deactivateActive(); + tw += w; } - } + }, this); + return tw; }, - // private. Do nothing - expandMenu : Ext.emptyFn, + // private + onDestroy : function() { + Ext.destroy(this.triggers); + Ext.form.TwinTriggerField.superclass.onDestroy.call(this); + }, - // private. Do nothing - hideMenu : Ext.emptyFn + /** + * The function that should handle the trigger's click event. This method does nothing by default + * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick} + * for additional information. + * @method + * @param {EventObject} e + */ + onTrigger1Click : Ext.emptyFn, + /** + * The function that should handle the trigger's click event. This method does nothing by default + * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick} + * for additional information. + * @method + * @param {EventObject} e + */ + onTrigger2Click : Ext.emptyFn }); -Ext.reg('menubaseitem', Ext.menu.BaseItem);/** - * @class Ext.menu.TextItem - * @extends Ext.menu.BaseItem - * Adds a static text string to a menu, usually used as either a heading or group separator. +Ext.reg('trigger', Ext.form.TriggerField); +/** + * @class Ext.form.TextArea + * @extends Ext.form.TextField + * Multiline text field. Can be used as a direct replacement for traditional textarea fields, plus adds + * support for auto-sizing. * @constructor - * Creates a new TextItem - * @param {Object/String} config If config is a string, it is used as the text to display, otherwise it - * is applied as a config object (and should contain a text property). - * @xtype menutextitem + * Creates a new TextArea + * @param {Object} config Configuration options + * @xtype textarea */ -Ext.menu.TextItem = Ext.extend(Ext.menu.BaseItem, { +Ext.form.TextArea = Ext.extend(Ext.form.TextField, { /** - * @cfg {String} text The text to display for this item (defaults to '') + * @cfg {Number} growMin The minimum height to allow when {@link Ext.form.TextField#grow grow}=true + * (defaults to 60) */ + growMin : 60, /** - * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to false) + * @cfg {Number} growMax The maximum height to allow when {@link Ext.form.TextField#grow grow}=true + * (defaults to 1000) */ - hideOnClick : false, + growMax: 1000, + growAppend : ' \n ', + + enterIsSpecial : false, + /** - * @cfg {String} itemCls The default CSS class to use for text items (defaults to "x-menu-text") + * @cfg {Boolean} preventScrollbars true to prevent scrollbars from appearing regardless of how much text is + * in the field. This option is only relevant when {@link #grow} is true. Equivalent to setting overflow: hidden, defaults to + * false. */ - itemCls : "x-menu-text", - - constructor : function(config){ - if(typeof config == 'string'){ - config = {text: config} + preventScrollbars: false, + /** + * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default + * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. + * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: + * {tag: "textarea", style: "width:100px;height:60px;", autocomplete: "off"} + */ + + // private + onRender : function(ct, position){ + if(!this.el){ + this.defaultAutoCreate = { + tag: "textarea", + style:"width:100px;height:60px;", + autocomplete: "off" + }; + } + Ext.form.TextArea.superclass.onRender.call(this, ct, position); + if(this.grow){ + this.textSizeEl = Ext.DomHelper.append(document.body, { + tag: "pre", cls: "x-form-grow-sizer" + }); + if(this.preventScrollbars){ + this.el.setStyle("overflow", "hidden"); + } + this.el.setHeight(this.growMin); } - Ext.menu.TextItem.superclass.constructor.call(this, config); }, + onDestroy : function(){ + Ext.removeNode(this.textSizeEl); + Ext.form.TextArea.superclass.onDestroy.call(this); + }, + + fireKey : function(e){ + if(e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() != e.ENTER || e.hasModifier()))){ + this.fireEvent("specialkey", this, e); + } + }, + // private - onRender : function(){ - var s = document.createElement("span"); - s.className = this.itemCls; - s.innerHTML = this.text; - this.el = s; - Ext.menu.TextItem.superclass.onRender.apply(this, arguments); + doAutoSize : function(e){ + return !e.isNavKeyPress() || e.getKey() == e.ENTER; + }, + + /** + * Automatically grows the field to accomodate the height of the text up to the maximum field height allowed. + * This only takes effect if grow = true, and fires the {@link #autosize} event if the height changes. + */ + autoSize: function(){ + if(!this.grow || !this.textSizeEl){ + return; + } + var el = this.el, + v = Ext.util.Format.htmlEncode(el.dom.value), + ts = this.textSizeEl, + h; + + Ext.fly(ts).setWidth(this.el.getWidth()); + if(v.length < 1){ + v = "  "; + }else{ + v += this.growAppend; + if(Ext.isIE){ + v = v.replace(/\n/g, ' '); + } + } + ts.innerHTML = v; + h = Math.min(this.growMax, Math.max(ts.offsetHeight, this.growMin)); + if(h != this.lastHeight){ + this.lastHeight = h; + this.el.setHeight(h); + this.fireEvent("autosize", this, h); + } } }); -Ext.reg('menutextitem', Ext.menu.TextItem);/** - * @class Ext.menu.Separator - * @extends Ext.menu.BaseItem - * Adds a separator bar to a menu, used to divide logical groups of menu items. Generally you will - * add one of these by using "-" in you call to add() or in your items config rather than creating one directly. +Ext.reg('textarea', Ext.form.TextArea);/** + * @class Ext.form.NumberField + * @extends Ext.form.TextField + * Numeric text field that provides automatic keystroke filtering and numeric validation. * @constructor + * Creates a new NumberField * @param {Object} config Configuration options - * @xtype menuseparator + * @xtype numberfield */ -Ext.menu.Separator = Ext.extend(Ext.menu.BaseItem, { +Ext.form.NumberField = Ext.extend(Ext.form.TextField, { /** - * @cfg {String} itemCls The default CSS class to use for separators (defaults to "x-menu-sep") + * @cfg {RegExp} stripCharsRe @hide + */ + /** + * @cfg {RegExp} maskRe @hide + */ + /** + * @cfg {String} fieldClass The default CSS class for the field (defaults to "x-form-field x-form-num-field") + */ + fieldClass: "x-form-field x-form-num-field", + /** + * @cfg {Boolean} allowDecimals False to disallow decimal values (defaults to true) + */ + allowDecimals : true, + /** + * @cfg {String} decimalSeparator Character(s) to allow as the decimal separator (defaults to '.') + */ + decimalSeparator : ".", + /** + * @cfg {Number} decimalPrecision The maximum precision to display after the decimal separator (defaults to 2) + */ + decimalPrecision : 2, + /** + * @cfg {Boolean} allowNegative False to prevent entering a negative sign (defaults to true) */ - itemCls : "x-menu-sep", + allowNegative : true, /** - * @cfg {Boolean} hideOnClick True to hide the containing menu after this item is clicked (defaults to false) + * @cfg {Number} minValue The minimum allowed value (defaults to Number.NEGATIVE_INFINITY) */ - hideOnClick : false, - - /** - * @cfg {String} activeClass - * @hide + minValue : Number.NEGATIVE_INFINITY, + /** + * @cfg {Number} maxValue The maximum allowed value (defaults to Number.MAX_VALUE) */ - activeClass: '', - - // private - onRender : function(li){ - var s = document.createElement("span"); - s.className = this.itemCls; - s.innerHTML = " "; - this.el = s; - li.addClass("x-menu-sep-li"); - Ext.menu.Separator.superclass.onRender.apply(this, arguments); - } -}); -Ext.reg('menuseparator', Ext.menu.Separator);/** - * @class Ext.menu.Item - * @extends Ext.menu.BaseItem - * A base class for all menu items that require menu-related functionality (like sub-menus) and are not static - * display items. Item extends the base functionality of {@link Ext.menu.BaseItem} by adding menu-specific - * activation and click handling. - * @constructor - * Creates a new Item - * @param {Object} config Configuration options - * @xtype menuitem - */ -Ext.menu.Item = Ext.extend(Ext.menu.BaseItem, { - /** - * @property menu - * @type Ext.menu.Menu - * The submenu associated with this Item if one was configured. - */ - /** - * @cfg {Mixed} menu (optional) Either an instance of {@link Ext.menu.Menu} or the config object for an - * {@link Ext.menu.Menu} which acts as the submenu when this item is activated. - */ - /** - * @cfg {String} icon The path to an icon to display in this item (defaults to Ext.BLANK_IMAGE_URL). If - * icon is specified {@link #iconCls} should not be. - */ - /** - * @cfg {String} iconCls A CSS class that specifies a background image that will be used as the icon for - * this item (defaults to ''). If iconCls is specified {@link #icon} should not be. - */ - /** - * @cfg {String} text The text to display in this item (defaults to ''). - */ - /** - * @cfg {String} href The href attribute to use for the underlying anchor link (defaults to '#'). - */ - /** - * @cfg {String} hrefTarget The target attribute to use for the underlying anchor link (defaults to ''). - */ - /** - * @cfg {String} itemCls The default CSS class to use for menu items (defaults to 'x-menu-item') - */ - itemCls : 'x-menu-item', - /** - * @cfg {Boolean} canActivate True if this item can be visually activated (defaults to true) - */ - canActivate : true, - /** - * @cfg {Number} showDelay Length of time in milliseconds to wait before showing this item (defaults to 200) - */ - showDelay: 200, - // doc'd in BaseItem - hideDelay: 200, - - // private - ctype: 'Ext.menu.Item', - - initComponent : function(){ - Ext.menu.Item.superclass.initComponent.call(this); - if(this.menu){ - this.menu = Ext.menu.MenuMgr.get(this.menu); - this.menu.ownerCt = this; - } - }, - - // private - onRender : function(container, position){ - if (!this.itemTpl) { - this.itemTpl = Ext.menu.Item.prototype.itemTpl = new Ext.XTemplate( - '', - ' target="{hrefTarget}"', - '', - '>', - '', - '{text}', - '' - ); - } - var a = this.getTemplateArgs(); - this.el = position ? this.itemTpl.insertBefore(position, a, true) : this.itemTpl.append(container, a, true); - this.iconEl = this.el.child('img.x-menu-item-icon'); - this.textEl = this.el.child('.x-menu-item-text'); - if(!this.href) { // if no link defined, prevent the default anchor event - this.mon(this.el, 'click', Ext.emptyFn, null, { preventDefault: true }); - } - Ext.menu.Item.superclass.onRender.call(this, container, position); - }, - - getTemplateArgs: function() { - return { - id: this.id, - cls: this.itemCls + (this.menu ? ' x-menu-item-arrow' : '') + (this.cls ? ' ' + this.cls : ''), - href: this.href || '#', - hrefTarget: this.hrefTarget, - icon: this.icon || Ext.BLANK_IMAGE_URL, - iconCls: this.iconCls || '', - text: this.itemText||this.text||' ' - }; - }, - - /** - * Sets the text to display in this menu item - * @param {String} text The text to display - */ - setText : function(text){ - this.text = text||' '; - if(this.rendered){ - this.textEl.update(this.text); - this.parentMenu.layout.doAutoSize(); - } - }, - - /** - * Sets the CSS class to apply to the item's icon element - * @param {String} cls The CSS class to apply - */ - setIconClass : function(cls){ - var oldCls = this.iconCls; - this.iconCls = cls; - if(this.rendered){ - this.iconEl.replaceClass(oldCls, this.iconCls); - } - }, - - //private - beforeDestroy: function(){ - if (this.menu){ - delete this.menu.ownerCt; - this.menu.destroy(); - } - Ext.menu.Item.superclass.beforeDestroy.call(this); - }, - - // private - handleClick : function(e){ - if(!this.href){ // if no link defined, stop the event automatically - e.stopEvent(); - } - Ext.menu.Item.superclass.handleClick.apply(this, arguments); - }, - - // private - activate : function(autoExpand){ - if(Ext.menu.Item.superclass.activate.apply(this, arguments)){ - this.focus(); - if(autoExpand){ - this.expandMenu(); - } - } - return true; - }, - - // private - shouldDeactivate : function(e){ - if(Ext.menu.Item.superclass.shouldDeactivate.call(this, e)){ - if(this.menu && this.menu.isVisible()){ - return !this.menu.getEl().getRegion().contains(e.getPoint()); - } - return true; - } - return false; - }, - - // private - deactivate : function(){ - Ext.menu.Item.superclass.deactivate.apply(this, arguments); - this.hideMenu(); - }, - - // private - expandMenu : function(autoActivate){ - if(!this.disabled && this.menu){ - clearTimeout(this.hideTimer); - delete this.hideTimer; - if(!this.menu.isVisible() && !this.showTimer){ - this.showTimer = this.deferExpand.defer(this.showDelay, this, [autoActivate]); - }else if (this.menu.isVisible() && autoActivate){ - this.menu.tryActivate(0, 1); - } - } - }, - - // private - deferExpand : function(autoActivate){ - delete this.showTimer; - this.menu.show(this.container, this.parentMenu.subMenuAlign || 'tl-tr?', this.parentMenu); - if(autoActivate){ - this.menu.tryActivate(0, 1); - } - }, - - // private - hideMenu : function(){ - clearTimeout(this.showTimer); - delete this.showTimer; - if(!this.hideTimer && this.menu && this.menu.isVisible()){ - this.hideTimer = this.deferHide.defer(this.hideDelay, this); - } - }, - - // private - deferHide : function(){ - delete this.hideTimer; - if(this.menu.over){ - this.parentMenu.setActiveItem(this, false); - }else{ - this.menu.hide(); - } - } -}); -Ext.reg('menuitem', Ext.menu.Item);/** - * @class Ext.menu.CheckItem - * @extends Ext.menu.Item - * Adds a menu item that contains a checkbox by default, but can also be part of a radio group. - * @constructor - * Creates a new CheckItem - * @param {Object} config Configuration options - * @xtype menucheckitem - */ -Ext.menu.CheckItem = Ext.extend(Ext.menu.Item, { + maxValue : Number.MAX_VALUE, /** - * @cfg {String} group - * All check items with the same group name will automatically be grouped into a single-select - * radio button group (defaults to '') + * @cfg {String} minText Error text to display if the minimum value validation fails (defaults to "The minimum value for this field is {minValue}") */ + minText : "The minimum value for this field is {0}", /** - * @cfg {String} itemCls The default CSS class to use for check items (defaults to "x-menu-item x-menu-check-item") + * @cfg {String} maxText Error text to display if the maximum value validation fails (defaults to "The maximum value for this field is {maxValue}") */ - itemCls : "x-menu-item x-menu-check-item", + maxText : "The maximum value for this field is {0}", /** - * @cfg {String} groupClass The default CSS class to use for radio group check items (defaults to "x-menu-group-item") + * @cfg {String} nanText Error text to display if the value is not a valid number. For example, this can happen + * if a valid character like '.' or '-' is left in the field with no number (defaults to "{value} is not a valid number") */ - groupClass : "x-menu-group-item", - + nanText : "{0} is not a valid number", /** - * @cfg {Boolean} checked True to initialize this checkbox as checked (defaults to false). Note that - * if this checkbox is part of a radio group (group = true) only the last item in the group that is - * initialized with checked = true will be rendered as checked. + * @cfg {String} baseChars The base set of characters to evaluate as valid numbers (defaults to '0123456789'). */ - checked: false, + baseChars : "0123456789", // private - ctype: "Ext.menu.CheckItem", - - initComponent : function(){ - Ext.menu.CheckItem.superclass.initComponent.call(this); - this.addEvents( - /** - * @event beforecheckchange - * Fires before the checked value is set, providing an opportunity to cancel if needed - * @param {Ext.menu.CheckItem} this - * @param {Boolean} checked The new checked value that will be set - */ - "beforecheckchange" , - /** - * @event checkchange - * Fires after the checked value has been set - * @param {Ext.menu.CheckItem} this - * @param {Boolean} checked The checked value that was set - */ - "checkchange" - ); - /** - * A function that handles the checkchange event. The function is undefined by default, but if an implementation - * is provided, it will be called automatically when the checkchange event fires. - * @param {Ext.menu.CheckItem} this - * @param {Boolean} checked The checked value that was set - * @method checkHandler - */ - if(this.checkHandler){ - this.on('checkchange', this.checkHandler, this.scope); - } - Ext.menu.MenuMgr.registerCheckable(this); + initEvents : function(){ + var allowed = this.baseChars + ''; + if (this.allowDecimals) { + allowed += this.decimalSeparator; + } + if (this.allowNegative) { + allowed += '-'; + } + this.maskRe = new RegExp('[' + Ext.escapeRe(allowed) + ']'); + Ext.form.NumberField.superclass.initEvents.call(this); }, - - // private - onRender : function(c){ - Ext.menu.CheckItem.superclass.onRender.apply(this, arguments); - if(this.group){ - this.el.addClass(this.groupClass); + + /** + * Runs all of NumberFields validations and returns an array of any errors. Note that this first + * runs TextField's validations, so the returned array is an amalgamation of all field errors. + * The additional validations run test that the value is a number, and that it is within the + * configured min and max values. + * @param {Mixed} value The value to get errors for (defaults to the current field value) + * @return {Array} All validation errors for this field + */ + getErrors: function(value) { + var errors = Ext.form.NumberField.superclass.getErrors.apply(this, arguments); + + value = value || this.processValue(this.getRawValue()); + + if (value.length < 1) { // if it's blank and textfield didn't flag it then it's valid + return errors; } - if(this.checked){ - this.checked = false; - this.setChecked(true, true); + + value = String(value).replace(this.decimalSeparator, "."); + + if(isNaN(value)){ + errors.push(String.format(this.nanText, value)); + } + + var num = this.parseValue(value); + + if(num < this.minValue){ + errors.push(String.format(this.minText, this.minValue)); } + + if(num > this.maxValue){ + errors.push(String.format(this.maxText, this.maxValue)); + } + + return errors; }, - // private - destroy : function(){ - Ext.menu.MenuMgr.unregisterCheckable(this); - Ext.menu.CheckItem.superclass.destroy.apply(this, arguments); + getValue : function(){ + return this.fixPrecision(this.parseValue(Ext.form.NumberField.superclass.getValue.call(this))); }, + setValue : function(v){ + v = Ext.isNumber(v) ? v : parseFloat(String(v).replace(this.decimalSeparator, ".")); + v = isNaN(v) ? '' : String(v).replace(".", this.decimalSeparator); + return Ext.form.NumberField.superclass.setValue.call(this, v); + }, + /** - * Set the checked state of this item - * @param {Boolean} checked The new checked value - * @param {Boolean} suppressEvent (optional) True to prevent the checkchange event from firing (defaults to false) + * Replaces any existing {@link #minValue} with the new value. + * @param {Number} value The minimum value */ - setChecked : function(state, suppressEvent){ - var suppress = suppressEvent === true; - if(this.checked != state && (suppress || this.fireEvent("beforecheckchange", this, state) !== false)){ - if(this.container){ - this.container[state ? "addClass" : "removeClass"]("x-menu-item-checked"); - } - this.checked = state; - if(!suppress){ - this.fireEvent("checkchange", this, state); - } - } + setMinValue : function(value){ + this.minValue = Ext.num(value, Number.NEGATIVE_INFINITY); + }, + + /** + * Replaces any existing {@link #maxValue} with the new value. + * @param {Number} value The maximum value + */ + setMaxValue : function(value){ + this.maxValue = Ext.num(value, Number.MAX_VALUE); }, // private - handleClick : function(e){ - if(!this.disabled && !(this.checked && this.group)){// disable unselect on radio item - this.setChecked(!this.checked); - } - Ext.menu.CheckItem.superclass.handleClick.apply(this, arguments); + parseValue : function(value){ + value = parseFloat(String(value).replace(this.decimalSeparator, ".")); + return isNaN(value) ? '' : value; + }, + + // private + fixPrecision : function(value){ + var nan = isNaN(value); + if(!this.allowDecimals || this.decimalPrecision == -1 || nan || !value){ + return nan ? '' : value; + } + return parseFloat(parseFloat(value).toFixed(this.decimalPrecision)); + }, + + beforeBlur : function(){ + var v = this.parseValue(this.getRawValue()); + if(!Ext.isEmpty(v)){ + this.setValue(this.fixPrecision(v)); + } } }); -Ext.reg('menucheckitem', Ext.menu.CheckItem);/** - * @class Ext.menu.DateMenu - * @extends Ext.menu.Menu - * A menu containing an {@link Ext.DatePicker} Component. - * Notes: - * Although not listed here, the constructor for this class - * accepts all of the configuration options of {@link Ext.DatePicker}. - * If subclassing DateMenu, any configuration options for the DatePicker must be - * applied to the initialConfig property of the DateMenu. - * Applying {@link Ext.DatePicker DatePicker} configuration settings to - * this will not affect the DatePicker's configuration. - * - * @xtype datemenu - */ - Ext.menu.DateMenu = Ext.extend(Ext.menu.Menu, { - /** - * @cfg {Boolean} enableScrolling - * @hide - */ - enableScrolling : false, - /** - * @cfg {Function} handler - * Optional. A function that will handle the select event of this menu. - * The handler is passed the following parameters: - * picker : DatePickerThe Ext.DatePicker. - * date : DateThe selected date. - * - */ - /** - * @cfg {Object} scope - * The scope (this reference) in which the {@link #handler} - * function will be called. Defaults to this DateMenu instance. - */ - /** - * @cfg {Boolean} hideOnClick - * False to continue showing the menu after a date is selected, defaults to true. - */ - hideOnClick : true, - - /** - * @cfg {String} pickerId - * An id to assign to the underlying date picker. Defaults to null. - */ - pickerId : null, - - /** - * @cfg {Number} maxHeight - * @hide - */ - /** - * @cfg {Number} scrollIncrement - * @hide - */ - /** - * The {@link Ext.DatePicker} instance for this DateMenu - * @property picker - * @type DatePicker - */ - cls : 'x-date-menu', - - /** - * @event click - * @hide - */ - - /** - * @event itemclick - * @hide - */ - - initComponent : function(){ - this.on('beforeshow', this.onBeforeShow, this); - if(this.strict = (Ext.isIE7 && Ext.isStrict)){ - this.on('show', this.onShow, this, {single: true, delay: 20}); - } - Ext.apply(this, { - plain: true, - showSeparator: false, - items: this.picker = new Ext.DatePicker(Ext.applyIf({ - internalRender: this.strict || !Ext.isIE, - ctCls: 'x-menu-date-item', - id: this.pickerId - }, this.initialConfig)) - }); - this.picker.purgeListeners(); - Ext.menu.DateMenu.superclass.initComponent.call(this); - /** - * @event select - * Fires when a date is selected from the {@link #picker Ext.DatePicker} - * @param {DatePicker} picker The {@link #picker Ext.DatePicker} - * @param {Date} date The selected date - */ - this.relayEvents(this.picker, ['select']); - this.on('show', this.picker.focus, this.picker); - this.on('select', this.menuHide, this); - if(this.handler){ - this.on('select', this.handler, this.scope || this); - } - }, - - menuHide : function() { - if(this.hideOnClick){ - this.hide(true); - } - }, - - onBeforeShow : function(){ - if(this.picker){ - this.picker.hideMonthPicker(true); - } - }, - - onShow : function(){ - var el = this.picker.getEl(); - el.setWidth(el.getWidth()); //nasty hack for IE7 strict mode - } - }); - Ext.reg('datemenu', Ext.menu.DateMenu); - /** - * @class Ext.menu.ColorMenu - * @extends Ext.menu.Menu - * A menu containing a {@link Ext.ColorPalette} Component. - * Notes: - * Although not listed here, the constructor for this class - * accepts all of the configuration options of {@link Ext.ColorPalette}. - * If subclassing ColorMenu, any configuration options for the ColorPalette must be - * applied to the initialConfig property of the ColorMenu. - * Applying {@link Ext.ColorPalette ColorPalette} configuration settings to - * this will not affect the ColorPalette's configuration. - * * - * @xtype colormenu - */ - Ext.menu.ColorMenu = Ext.extend(Ext.menu.Menu, { - /** - * @cfg {Boolean} enableScrolling - * @hide - */ - enableScrolling : false, - /** - * @cfg {Function} handler - * Optional. A function that will handle the select event of this menu. - * The handler is passed the following parameters: - * palette : ColorPaletteThe {@link #palette Ext.ColorPalette}. - * color : StringThe 6-digit color hex code (without the # symbol). - * - */ - /** - * @cfg {Object} scope - * The scope (this reference) in which the {@link #handler} - * function will be called. Defaults to this ColorMenu instance. - */ - - /** - * @cfg {Boolean} hideOnClick - * False to continue showing the menu after a color is selected, defaults to true. - */ - hideOnClick : true, - - cls : 'x-color-menu', - - /** - * @cfg {String} paletteId - * An id to assign to the underlying color palette. Defaults to null. - */ - paletteId : null, - - /** - * @cfg {Number} maxHeight - * @hide - */ - /** - * @cfg {Number} scrollIncrement - * @hide - */ - /** - * @property palette - * @type ColorPalette - * The {@link Ext.ColorPalette} instance for this ColorMenu - */ - - - /** - * @event click - * @hide - */ - - /** - * @event itemclick - * @hide - */ - - initComponent : function(){ - Ext.apply(this, { - plain: true, - showSeparator: false, - items: this.palette = new Ext.ColorPalette(Ext.applyIf({ - id: this.paletteId - }, this.initialConfig)) - }); - this.palette.purgeListeners(); - Ext.menu.ColorMenu.superclass.initComponent.call(this); - /** - * @event select - * Fires when a color is selected from the {@link #palette Ext.ColorPalette} - * @param {Ext.ColorPalette} palette The {@link #palette Ext.ColorPalette} - * @param {String} color The 6-digit color hex code (without the # symbol) - */ - this.relayEvents(this.palette, ['select']); - this.on('select', this.menuHide, this); - if(this.handler){ - this.on('select', this.handler, this.scope || this); - } - }, - - menuHide : function(){ - if(this.hideOnClick){ - this.hide(true); - } - } -}); -Ext.reg('colormenu', Ext.menu.ColorMenu); -/** - * @class Ext.form.Field - * @extends Ext.BoxComponent - * Base class for form fields that provides default event handling, sizing, value handling and other functionality. +Ext.reg('numberfield', Ext.form.NumberField);/** + * @class Ext.form.DateField + * @extends Ext.form.TriggerField + * Provides a date input field with a {@link Ext.DatePicker} dropdown and automatic date validation. * @constructor - * Creates a new Field - * @param {Object} config Configuration options - * @xtype field + * Create a new DateField + * @param {Object} config + * @xtype datefield */ -Ext.form.Field = Ext.extend(Ext.BoxComponent, { - /** - * The label Element associated with this Field. Only available after this Field has been rendered by a - * {@link form Ext.layout.FormLayout} layout manager. - * @type Ext.Element - * @property label - */ - /** - * @cfg {String} inputType The type attribute for input fields -- e.g. radio, text, password, file (defaults - * to 'text'). The types 'file' and 'password' must be used to render those field types currently -- there are - * no separate Ext components for those. Note that if you use inputType:'file', {@link #emptyText} - * is not supported and should be avoided. - */ - /** - * @cfg {Number} tabIndex The tabIndex for this field. Note this only applies to fields that are rendered, - * not those which are built via applyTo (defaults to undefined). - */ - /** - * @cfg {Mixed} value A value to initialize this field with (defaults to undefined). - */ - /** - * @cfg {String} name The field's HTML name attribute (defaults to ''). - * Note: this property must be set if this field is to be automatically included with - * {@link Ext.form.BasicForm#submit form submit()}. - */ - /** - * @cfg {String} cls A custom CSS class to apply to the field's underlying element (defaults to ''). - */ - +Ext.form.DateField = Ext.extend(Ext.form.TriggerField, { /** - * @cfg {String} invalidClass The CSS class to use when marking a field invalid (defaults to 'x-form-invalid') + * @cfg {String} format + * The default date format string which can be overriden for localization support. The format must be + * valid according to {@link Date#parseDate} (defaults to 'm/d/Y'). */ - invalidClass : 'x-form-invalid', + format : "m/d/Y", /** - * @cfg {String} invalidText The error text to use when marking a field invalid and no message is provided - * (defaults to 'The value in this field is invalid') + * @cfg {String} altFormats + * Multiple date formats separated by "|" to try when parsing a user input value and it + * does not match the defined format (defaults to + * 'm/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d'). */ - invalidText : 'The value in this field is invalid', + altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d", /** - * @cfg {String} focusClass The CSS class to use when the field receives focus (defaults to 'x-form-focus') + * @cfg {String} disabledDaysText + * The tooltip to display when the date falls on a disabled day (defaults to 'Disabled') */ - focusClass : 'x-form-focus', + disabledDaysText : "Disabled", /** - * @cfg {Boolean} preventMark - * true to disable {@link #markInvalid marking the field invalid}. - * Defaults to false. + * @cfg {String} disabledDatesText + * The tooltip text to display when the date falls on a disabled date (defaults to 'Disabled') */ + disabledDatesText : "Disabled", /** - * @cfg {String/Boolean} validationEvent The event that should initiate field validation. Set to false to disable - automatic validation (defaults to 'keyup'). + * @cfg {String} minText + * The error text to display when the date in the cell is before {@link #minValue} (defaults to + * 'The date in this field must be after {minValue}'). */ - validationEvent : 'keyup', + minText : "The date in this field must be equal to or after {0}", /** - * @cfg {Boolean} validateOnBlur Whether the field should validate when it loses focus (defaults to true). + * @cfg {String} maxText + * The error text to display when the date in the cell is after {@link #maxValue} (defaults to + * 'The date in this field must be before {maxValue}'). */ - validateOnBlur : true, + maxText : "The date in this field must be equal to or before {0}", /** - * @cfg {Number} validationDelay The length of time in milliseconds after user input begins until validation - * is initiated (defaults to 250) + * @cfg {String} invalidText + * The error text to display when the date in the field is invalid (defaults to + * '{value} is not a valid date - it must be in the format {format}'). */ - validationDelay : 250, + invalidText : "{0} is not a valid date - it must be in the format {1}", /** - * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default - * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. - * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: - * {tag: 'input', type: 'text', size: '20', autocomplete: 'off'} + * @cfg {String} triggerClass + * An additional CSS class used to style the trigger button. The trigger will always get the + * class 'x-form-trigger' and triggerClass will be appended if specified + * (defaults to 'x-form-date-trigger' which displays a calendar icon). */ - defaultAutoCreate : {tag: 'input', type: 'text', size: '20', autocomplete: 'off'}, + triggerClass : 'x-form-date-trigger', /** - * @cfg {String} fieldClass The default CSS class for the field (defaults to 'x-form-field') + * @cfg {Boolean} showToday + * false to hide the footer area of the DatePicker containing the Today button and disable + * the keyboard handler for spacebar that selects the current date (defaults to true). */ - fieldClass : 'x-form-field', + showToday : true, /** - * @cfg {String} msgTargetThe location where the message text set through {@link #markInvalid} should display. - * Must be one of the following values: - * - * qtip Display a quick tip containing the message when the user hovers over the field. This is the default. - * {@link Ext.QuickTips#init Ext.QuickTips.init} must have been called for this setting to work. - * title Display the message in a default browser title attribute popup. - * under Add a block div beneath the field containing the error message. - * side Add an error icon to the right of the field, displaying the message in a popup on hover. - * [element id] Add the error message directly to the innerHTML of the specified element. - * + * @cfg {Date/String} minValue + * The minimum allowed date. Can be either a Javascript date object or a string date in a + * valid format (defaults to null). */ - msgTarget : 'qtip', /** - * @cfg {String} msgFx Experimental The effect used when displaying a validation message under the field - * (defaults to 'normal'). + * @cfg {Date/String} maxValue + * The maximum allowed date. Can be either a Javascript date object or a string date in a + * valid format (defaults to null). */ - msgFx : 'normal', /** - * @cfg {Boolean} readOnly true to mark the field as readOnly in HTML - * (defaults to false). - * Note: this only sets the element's readOnly DOM attribute. - * Setting readOnly=true, for example, will not disable triggering a - * ComboBox or DateField; it gives you the option of forcing the user to choose - * via the trigger without typing in the text box. To hide the trigger use - * {@link Ext.form.TriggerField#hideTrigger hideTrigger}. + * @cfg {Array} disabledDays + * An array of days to disable, 0 based (defaults to null). Some examples: +// disable Sunday and Saturday: +disabledDays: [0, 6] +// disable weekdays: +disabledDays: [1,2,3,4,5] + * */ - readOnly : false, /** - * @cfg {Boolean} disabled True to disable the field (defaults to false). - * Be aware that conformant with the HTML specification, - * disabled Fields will not be {@link Ext.form.BasicForm#submit submitted}. + * @cfg {Array} disabledDates + * An array of "dates" to disable, as strings. These strings will be used to build a dynamic regular + * expression so they are very powerful. Some examples: +// disable these exact dates: +disabledDates: ["03/08/2003", "09/16/2003"] +// disable these days for every year: +disabledDates: ["03/08", "09/16"] +// only match the beginning (useful if you are using short years): +disabledDates: ["^03/08"] +// disable every day in March 2006: +disabledDates: ["03/../2006"] +// disable every day in every March: +disabledDates: ["^03"] + * + * Note that the format of the dates included in the array should exactly match the {@link #format} config. + * In order to support regular expressions, if you are using a {@link #format date format} that has "." in + * it, you will have to escape the dot when restricting dates. For example: ["03\\.08\\.03"]. */ - disabled : false, /** - * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post. - * Defaults to true. + * @cfg {String/Object} autoCreate + * A {@link Ext.DomHelper DomHelper element specification object}, or true for the default element + * specification object: + * autoCreate: {tag: "input", type: "text", size: "10", autocomplete: "off"} + * */ - submitValue: true, // private - isFormField : true, + defaultAutoCreate : {tag: "input", type: "text", size: "10", autocomplete: "off"}, - // private - msgDisplay: '', + // in the absence of a time value, a default value of 12 noon will be used + // (note: 12 noon was chosen because it steers well clear of all DST timezone changes) + initTime: '12', // 24 hour format - // private - hasFocus : false, + initTimeFormat: 'H', + + // PUBLIC -- to be documented + safeParse : function(value, format) { + if (/[gGhH]/.test(format.replace(/(\\.)/g, ''))) { + // if parse format contains hour information, no DST adjustment is necessary + return Date.parseDate(value, format); + } else { + // set time to 12 noon, then clear the time + var parsedDate = Date.parseDate(value + ' ' + this.initTime, format + ' ' + this.initTimeFormat); + + if (parsedDate) return parsedDate.clearTime(); + } + }, - // private initComponent : function(){ - Ext.form.Field.superclass.initComponent.call(this); + Ext.form.DateField.superclass.initComponent.call(this); + this.addEvents( /** - * @event focus - * Fires when this field receives input focus. - * @param {Ext.form.Field} this - */ - 'focus', - /** - * @event blur - * Fires when this field loses input focus. - * @param {Ext.form.Field} this - */ - 'blur', - /** - * @event specialkey - * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. - * To handle other keys see {@link Ext.Panel#keys} or {@link Ext.KeyMap}. - * You can check {@link Ext.EventObject#getKey} to determine which key was pressed. - * For example: -var form = new Ext.form.FormPanel({ - ... - items: [{ - fieldLabel: 'Field 1', - name: 'field1', - allowBlank: false - },{ - fieldLabel: 'Field 2', - name: 'field2', - listeners: { - specialkey: function(field, e){ - // e.HOME, e.END, e.PAGE_UP, e.PAGE_DOWN, - // e.TAB, e.ESC, arrow keys: e.LEFT, e.RIGHT, e.UP, e.DOWN - if (e.{@link Ext.EventObject#getKey getKey()} == e.ENTER) { - var form = field.ownerCt.getForm(); - form.submit(); - } - } - } - } - ], - ... -}); - * - * @param {Ext.form.Field} this - * @param {Ext.EventObject} e The event object - */ - 'specialkey', - /** - * @event change - * Fires just before the field blurs if the field value has changed. - * @param {Ext.form.Field} this - * @param {Mixed} newValue The new value - * @param {Mixed} oldValue The original value - */ - 'change', - /** - * @event invalid - * Fires after the field has been marked as invalid. - * @param {Ext.form.Field} this - * @param {String} msg The validation message - */ - 'invalid', - /** - * @event valid - * Fires after the field has been validated with no errors. - * @param {Ext.form.Field} this + * @event select + * Fires when a date is selected via the date picker. + * @param {Ext.form.DateField} this + * @param {Date} date The date that was selected */ - 'valid' + 'select' ); + + if(Ext.isString(this.minValue)){ + this.minValue = this.parseDate(this.minValue); + } + if(Ext.isString(this.maxValue)){ + this.maxValue = this.parseDate(this.maxValue); + } + this.disabledDatesRE = null; + this.initDisabledDays(); }, - /** - * Returns the {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName} - * attribute of the field if available. - * @return {String} name The field {@link Ext.form.Field#name name} or {@link Ext.form.ComboBox#hiddenName hiddenName} - */ - getName : function(){ - return this.rendered && this.el.dom.name ? this.el.dom.name : this.name || this.id || ''; + initEvents: function() { + Ext.form.DateField.superclass.initEvents.call(this); + this.keyNav = new Ext.KeyNav(this.el, { + "down": function(e) { + this.onTriggerClick(); + }, + scope: this, + forceKeyDown: true + }); }, + // private - onRender : function(ct, position){ - if(!this.el){ - var cfg = this.getAutoCreate(); + initDisabledDays : function(){ + if(this.disabledDates){ + var dd = this.disabledDates, + len = dd.length - 1, + re = "(?:"; - if(!cfg.name){ - cfg.name = this.name || this.id; - } - if(this.inputType){ - cfg.type = this.inputType; - } - this.autoEl = cfg; - } - Ext.form.Field.superclass.onRender.call(this, ct, position); - if(this.submitValue === false){ - this.el.dom.removeAttribute('name'); - } - var type = this.el.dom.type; - if(type){ - if(type == 'password'){ - type = 'text'; - } - this.el.addClass('x-form-'+type); - } - if(this.readOnly){ - this.setReadOnly(true); + Ext.each(dd, function(d, i){ + re += Ext.isDate(d) ? '^' + Ext.escapeRe(d.dateFormat(this.format)) + '$' : dd[i]; + if(i != len){ + re += '|'; + } + }, this); + this.disabledDatesRE = new RegExp(re + ')'); } - if(this.tabIndex !== undefined){ - this.el.dom.setAttribute('tabIndex', this.tabIndex); + }, + + /** + * Replaces any existing disabled dates with new values and refreshes the DatePicker. + * @param {Array} disabledDates An array of date strings (see the {@link #disabledDates} config + * for details on supported values) used to disable a pattern of dates. + */ + setDisabledDates : function(dd){ + this.disabledDates = dd; + this.initDisabledDays(); + if(this.menu){ + this.menu.picker.setDisabledDates(this.disabledDatesRE); } - - this.el.addClass([this.fieldClass, this.cls]); }, - // private - getItemCt : function(){ - return this.itemCt; + /** + * Replaces any existing disabled days (by index, 0-6) with new values and refreshes the DatePicker. + * @param {Array} disabledDays An array of disabled day indexes. See the {@link #disabledDays} + * config for details on supported values. + */ + setDisabledDays : function(dd){ + this.disabledDays = dd; + if(this.menu){ + this.menu.picker.setDisabledDays(dd); + } }, - // private - initValue : function(){ - if(this.value !== undefined){ - this.setValue(this.value); - }else if(!Ext.isEmpty(this.el.dom.value) && this.el.dom.value != this.emptyText){ - this.setValue(this.el.dom.value); + /** + * Replaces any existing {@link #minValue} with the new value and refreshes the DatePicker. + * @param {Date} value The minimum date that can be selected + */ + setMinValue : function(dt){ + this.minValue = (Ext.isString(dt) ? this.parseDate(dt) : dt); + if(this.menu){ + this.menu.picker.setMinDate(this.minValue); } - /** - * The original value of the field as configured in the {@link #value} configuration, or - * as loaded by the last form load operation if the form's {@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} - * setting is true. - * @type mixed - * @property originalValue - */ - this.originalValue = this.getValue(); }, /** - * Returns true if the value of this Field has been changed from its original value. - * Will return false if the field is disabled or has not been rendered yet. - * Note that if the owning {@link Ext.form.BasicForm form} was configured with - * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} - * then the original value is updated when the values are loaded by - * {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#setValues setValues}. - * @return {Boolean} True if this field has been changed from its original value (and - * is not disabled), false otherwise. + * Replaces any existing {@link #maxValue} with the new value and refreshes the DatePicker. + * @param {Date} value The maximum date that can be selected */ - isDirty : function() { - if(this.disabled || !this.rendered) { - return false; + setMaxValue : function(dt){ + this.maxValue = (Ext.isString(dt) ? this.parseDate(dt) : dt); + if(this.menu){ + this.menu.picker.setMaxDate(this.maxValue); } - return String(this.getValue()) !== String(this.originalValue); }, - + /** - * Sets the read only state of this field. - * @param {Boolean} readOnly Whether the field should be read only. + * Runs all of NumberFields validations and returns an array of any errors. Note that this first + * runs TextField's validations, so the returned array is an amalgamation of all field errors. + * The additional validation checks are testing that the date format is valid, that the chosen + * date is within the min and max date constraints set, that the date chosen is not in the disabledDates + * regex and that the day chosed is not one of the disabledDays. + * @param {Mixed} value The value to get errors for (defaults to the current field value) + * @return {Array} All validation errors for this field */ - setReadOnly : function(readOnly){ - if(this.rendered){ - this.el.dom.readOnly = readOnly; + getErrors: function(value) { + var errors = Ext.form.DateField.superclass.getErrors.apply(this, arguments); + + value = this.formatDate(value || this.processValue(this.getRawValue())); + + if (value.length < 1) { // if it's blank and textfield didn't flag it then it's valid + return errors; } - this.readOnly = readOnly; + + var svalue = value; + value = this.parseDate(value); + if (!value) { + errors.push(String.format(this.invalidText, svalue, this.format)); + return errors; + } + + var time = value.getTime(); + if (this.minValue && time < this.minValue.getTime()) { + errors.push(String.format(this.minText, this.formatDate(this.minValue))); + } + + if (this.maxValue && time > this.maxValue.getTime()) { + errors.push(String.format(this.maxText, this.formatDate(this.maxValue))); + } + + if (this.disabledDays) { + var day = value.getDay(); + + for(var i = 0; i < this.disabledDays.length; i++) { + if (day === this.disabledDays[i]) { + errors.push(this.disabledDaysText); + break; + } + } + } + + var fvalue = this.formatDate(value); + if (this.disabledDatesRE && this.disabledDatesRE.test(fvalue)) { + errors.push(String.format(this.disabledDatesText, fvalue)); + } + + return errors; }, // private - afterRender : function(){ - Ext.form.Field.superclass.afterRender.call(this); - this.initEvents(); - this.initValue(); + // Provides logic to override the default TriggerField.validateBlur which just returns true + validateBlur : function(){ + return !this.menu || !this.menu.isVisible(); }, - // private - fireKey : function(e){ - if(e.isSpecialKey()){ - this.fireEvent('specialkey', this, e); - } + /** + * Returns the current date value of the date field. + * @return {Date} The date value + */ + getValue : function(){ + return this.parseDate(Ext.form.DateField.superclass.getValue.call(this)) || ""; }, /** - * Resets the current field value to the originally loaded value and clears any validation messages. - * See {@link Ext.form.BasicForm}.{@link Ext.form.BasicForm#trackResetOnLoad trackResetOnLoad} + * Sets the value of the date field. You can pass a date object or any string that can be + * parsed into a valid date, using {@link #format} as the date format, according + * to the same rules as {@link Date#parseDate} (the default format used is "m/d/Y"). + * Usage: + * +//All of these calls set the same date value (May 4, 2006) + +//Pass a date object: +var dt = new Date('5/4/2006'); +dateField.setValue(dt); + +//Pass a date string (default format): +dateField.setValue('05/04/2006'); + +//Pass a date string (custom format): +dateField.format = 'Y-m-d'; +dateField.setValue('2006-05-04'); + + * @param {String/Date} date The date or valid date string + * @return {Ext.form.Field} this */ - reset : function(){ - this.setValue(this.originalValue); - this.clearInvalid(); + setValue : function(date){ + return Ext.form.DateField.superclass.setValue.call(this, this.formatDate(this.parseDate(date))); }, // private - initEvents : function(){ - this.mon(this.el, Ext.EventManager.useKeydown ? 'keydown' : 'keypress', this.fireKey, this); - this.mon(this.el, 'focus', this.onFocus, this); + parseDate : function(value) { + if(!value || Ext.isDate(value)){ + return value; + } - // standardise buffer across all browsers + OS-es for consistent event order. - // (the 10ms buffer for Editors fixes a weird FF/Win editor issue when changing OS window focus) - this.mon(this.el, 'blur', this.onBlur, this, this.inEditor ? {buffer:10} : null); - }, + var v = this.safeParse(value, this.format), + af = this.altFormats, + afa = this.altFormatsArray; - // private - preFocus: Ext.emptyFn, + if (!v && af) { + afa = afa || af.split("|"); - // private - onFocus : function(){ - this.preFocus(); - if(this.focusClass){ - this.el.addClass(this.focusClass); - } - if(!this.hasFocus){ - this.hasFocus = true; - /** - * The value that the Field had at the time it was last focused. This is the value that is passed - * to the {@link #change} event which is fired if the value has been changed when the Field is blurred. - * This will be undefined until the Field has been visited. Compare {@link #originalValue}. - * @type mixed - * @property startValue - */ - this.startValue = this.getValue(); - this.fireEvent('focus', this); + for (var i = 0, len = afa.length; i < len && !v; i++) { + v = this.safeParse(value, afa[i]); + } } + return v; }, // private - beforeBlur : Ext.emptyFn, - - // private - onBlur : function(){ - this.beforeBlur(); - if(this.focusClass){ - this.el.removeClass(this.focusClass); - } - this.hasFocus = false; - if(this.validationEvent !== false && (this.validateOnBlur || this.validationEvent == 'blur')){ - this.validate(); - } - var v = this.getValue(); - if(String(v) !== String(this.startValue)){ - this.fireEvent('change', this, v, this.startValue); - } - this.fireEvent('blur', this); - this.postBlur(); + onDestroy : function(){ + Ext.destroy(this.menu, this.keyNav); + Ext.form.DateField.superclass.onDestroy.call(this); }, // private - postBlur : Ext.emptyFn, + formatDate : function(date){ + return Ext.isDate(date) ? date.dateFormat(this.format) : date; + }, /** - * Returns whether or not the field value is currently valid by - * {@link #validateValue validating} the {@link #processValue processed value} - * of the field. Note: {@link #disabled} fields are ignored. - * @param {Boolean} preventMark True to disable marking the field invalid - * @return {Boolean} True if the value is valid, else false + * @method onTriggerClick + * @hide */ - isValid : function(preventMark){ + // private + // Implements the default empty TriggerField.onTriggerClick function to display the DatePicker + onTriggerClick : function(){ if(this.disabled){ - return true; + return; } - var restore = this.preventMark; - this.preventMark = preventMark === true; - var v = this.validateValue(this.processValue(this.getRawValue())); - this.preventMark = restore; - return v; + if(this.menu == null){ + this.menu = new Ext.menu.DateMenu({ + hideOnClick: false, + focusOnSelect: false + }); + } + this.onFocus(); + Ext.apply(this.menu.picker, { + minDate : this.minValue, + maxDate : this.maxValue, + disabledDatesRE : this.disabledDatesRE, + disabledDatesText : this.disabledDatesText, + disabledDays : this.disabledDays, + disabledDaysText : this.disabledDaysText, + format : this.format, + showToday : this.showToday, + minText : String.format(this.minText, this.formatDate(this.minValue)), + maxText : String.format(this.maxText, this.formatDate(this.maxValue)) + }); + this.menu.picker.setValue(this.getValue() || new Date()); + this.menu.show(this.el, "tl-bl?"); + this.menuEvents('on'); }, - /** - * Validates the field value - * @return {Boolean} True if the value is valid, else false - */ - validate : function(){ - if(this.disabled || this.validateValue(this.processValue(this.getRawValue()))){ - this.clearInvalid(); - return true; - } - return false; + //private + menuEvents: function(method){ + this.menu[method]('select', this.onSelect, this); + this.menu[method]('hide', this.onMenuHide, this); + this.menu[method]('show', this.onFocus, this); }, - /** - * This method should only be overridden if necessary to prepare raw values - * for validation (see {@link #validate} and {@link #isValid}). This method - * is expected to return the processed value for the field which will - * be used for validation (see validateValue method). - * @param {Mixed} value - */ - processValue : function(value){ - return value; + onSelect: function(m, d){ + this.setValue(d); + this.fireEvent('select', this, d); + this.menu.hide(); }, - /** - * @private - * Subclasses should provide the validation implementation by overriding this - * @param {Mixed} value - */ - validateValue : function(value){ - return true; + onMenuHide: function(){ + this.focus(false, 60); + this.menuEvents('un'); }, + // private + beforeBlur : function(){ + var v = this.parseDate(this.getRawValue()); + if(v){ + this.setValue(v); + } + } + /** - * Gets the active error message for this field. - * @return {String} Returns the active error message on the field, if there is no error, an empty string is returned. + * @cfg {Boolean} grow @hide */ - getActiveError : function(){ - return this.activeError || ''; - }, - /** - * Display an error message associated with this field, using {@link #msgTarget} to determine how to - * display the message and applying {@link #invalidClass} to the field's UI element. - * Note: this method does not cause the Field's {@link #validate} method to return false - * if the value does pass validation. So simply marking a Field as invalid will not prevent - * submission of forms submitted with the {@link Ext.form.Action.Submit#clientValidation} option set. - * {@link #isValid invalid}. - * @param {String} msg (optional) The validation message (defaults to {@link #invalidText}) + * @cfg {Number} growMin @hide */ - markInvalid : function(msg){ - if(!this.rendered || this.preventMark){ // not rendered - return; - } - msg = msg || this.invalidText; + /** + * @cfg {Number} growMax @hide + */ + /** + * @hide + * @method autoSize + */ +}); +Ext.reg('datefield', Ext.form.DateField);/** + * @class Ext.form.DisplayField + * @extends Ext.form.Field + * A display-only text field which is not validated and not submitted. + * @constructor + * Creates a new DisplayField. + * @param {Object} config Configuration options + * @xtype displayfield + */ +Ext.form.DisplayField = Ext.extend(Ext.form.Field, { + validationEvent : false, + validateOnBlur : false, + defaultAutoCreate : {tag: "div"}, + /** + * @cfg {String} fieldClass The default CSS class for the field (defaults to "x-form-display-field") + */ + fieldClass : "x-form-display-field", + /** + * @cfg {Boolean} htmlEncode false to skip HTML-encoding the text when rendering it (defaults to + * false). This might be useful if you want to include tags in the field's innerHTML rather than + * rendering them as string literals per the default logic. + */ + htmlEncode: false, - var mt = this.getMessageHandler(); - if(mt){ - mt.mark(this, msg); - }else if(this.msgTarget){ - this.el.addClass(this.invalidClass); - var t = Ext.getDom(this.msgTarget); - if(t){ - t.innerHTML = msg; - t.style.display = this.msgDisplay; - } - } - this.activeError = msg; - this.fireEvent('invalid', this, msg); + // private + initEvents : Ext.emptyFn, + + isValid : function(){ + return true; }, - /** - * Clear any invalid styles/messages for this field - */ - clearInvalid : function(){ - if(!this.rendered || this.preventMark){ // not rendered - return; + validate : function(){ + return true; + }, + + getRawValue : function(){ + var v = this.rendered ? this.el.dom.innerHTML : Ext.value(this.value, ''); + if(v === this.emptyText){ + v = ''; } - this.el.removeClass(this.invalidClass); - var mt = this.getMessageHandler(); - if(mt){ - mt.clear(this); - }else if(this.msgTarget){ - this.el.removeClass(this.invalidClass); - var t = Ext.getDom(this.msgTarget); - if(t){ - t.innerHTML = ''; - t.style.display = 'none'; - } + if(this.htmlEncode){ + v = Ext.util.Format.htmlDecode(v); } - delete this.activeError; - this.fireEvent('valid', this); + return v; }, - // private - getMessageHandler : function(){ - return Ext.form.MessageTargets[this.msgTarget]; + getValue : function(){ + return this.getRawValue(); }, - - // private - getErrorCt : function(){ - return this.el.findParent('.x-form-element', 5, true) || // use form element wrap if available - this.el.findParent('.x-form-field-wrap', 5, true); // else direct field wrap + + getName: function() { + return this.name; }, - // Alignment for 'under' target - alignErrorEl : function(){ - this.errorEl.setWidth(this.getErrorCt().getWidth(true) - 20); + setRawValue : function(v){ + if(this.htmlEncode){ + v = Ext.util.Format.htmlEncode(v); + } + return this.rendered ? (this.el.dom.innerHTML = (Ext.isEmpty(v) ? '' : v)) : (this.value = v); }, - // Alignment for 'side' target - alignErrorIcon : function(){ - this.errorIcon.alignTo(this.el, 'tl-tr', [2, 0]); + setValue : function(v){ + this.setRawValue(v); + return this; + } + /** + * @cfg {String} inputType + * @hide + */ + /** + * @cfg {Boolean} disabled + * @hide + */ + /** + * @cfg {Boolean} readOnly + * @hide + */ + /** + * @cfg {Boolean} validateOnBlur + * @hide + */ + /** + * @cfg {Number} validationDelay + * @hide + */ + /** + * @cfg {String/Boolean} validationEvent + * @hide + */ +}); + +Ext.reg('displayfield', Ext.form.DisplayField); +/** + * @class Ext.form.ComboBox + * @extends Ext.form.TriggerField + * A combobox control with support for autocomplete, remote-loading, paging and many other features. + * A ComboBox works in a similar manner to a traditional HTML <select> field. The difference is + * that to submit the {@link #valueField}, you must specify a {@link #hiddenName} to create a hidden input + * field to hold the value of the valueField. The {@link #displayField} is shown in the text field + * which is named according to the {@link #name}. + * Events + * To do something when something in ComboBox is selected, configure the select event: +var cb = new Ext.form.ComboBox({ + // all of your config options + listeners:{ + scope: yourScope, + 'select': yourFunction + } +}); + +// Alternatively, you can assign events after the object is created: +var cb = new Ext.form.ComboBox(yourOptions); +cb.on('select', yourFunction, yourScope); + * + * + * ComboBox in Grid + * If using a ComboBox in an {@link Ext.grid.EditorGridPanel Editor Grid} a {@link Ext.grid.Column#renderer renderer} + * will be needed to show the displayField when the editor is not active. Set up the renderer manually, or implement + * a reusable render, for example: +// create reusable renderer +Ext.util.Format.comboRenderer = function(combo){ + return function(value){ + var record = combo.findRecord(combo.{@link #valueField}, value); + return record ? record.get(combo.{@link #displayField}) : combo.{@link #valueNotFoundText}; + } +} + +// create the combo instance +var combo = new Ext.form.ComboBox({ + {@link #typeAhead}: true, + {@link #triggerAction}: 'all', + {@link #lazyRender}:true, + {@link #mode}: 'local', + {@link #store}: new Ext.data.ArrayStore({ + id: 0, + fields: [ + 'myId', + 'displayText' + ], + data: [[1, 'item1'], [2, 'item2']] + }), + {@link #valueField}: 'myId', + {@link #displayField}: 'displayText' +}); + +// snippet of column model used within grid +var cm = new Ext.grid.ColumnModel([{ + ... + },{ + header: "Some Header", + dataIndex: 'whatever', + width: 130, + editor: combo, // specify reference to combo instance + renderer: Ext.util.Format.comboRenderer(combo) // pass combo instance to reusable renderer }, + ... +]); + * + * + * Filtering + * A ComboBox {@link #doQuery uses filtering itself}, for information about filtering the ComboBox + * store manually see {@link #lastQuery}. + * @constructor + * Create a new ComboBox. + * @param {Object} config Configuration options + * @xtype combo + */ +Ext.form.ComboBox = Ext.extend(Ext.form.TriggerField, { + /** + * @cfg {Mixed} transform The id, DOM node or element of an existing HTML SELECT to convert to a ComboBox. + * Note that if you specify this and the combo is going to be in an {@link Ext.form.BasicForm} or + * {@link Ext.form.FormPanel}, you must also set {@link #lazyRender} = true. + */ + /** + * @cfg {Boolean} lazyRender true to prevent the ComboBox from rendering until requested + * (should always be used when rendering into an {@link Ext.Editor} (e.g. {@link Ext.grid.EditorGridPanel Grids}), + * defaults to false). + */ + /** + * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default + * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. + * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: + * {tag: "input", type: "text", size: "24", autocomplete: "off"} + */ + /** + * @cfg {Ext.data.Store/Array} store The data source to which this combo is bound (defaults to undefined). + * Acceptable values for this property are: + * + * any {@link Ext.data.Store Store} subclass + * an Array : Arrays will be converted to a {@link Ext.data.ArrayStore} internally, + * automatically generating {@link Ext.data.Field#name field names} to work with all data components. + * + * 1-dimensional array : (e.g., ['Foo','Bar']) + * A 1-dimensional array will automatically be expanded (each array item will be used for both the combo + * {@link #valueField} and {@link #displayField}) + * 2-dimensional array : (e.g., [['f','Foo'],['b','Bar']]) + * For a multi-dimensional array, the value in index 0 of each item will be assumed to be the combo + * {@link #valueField}, while the value at index 1 is assumed to be the combo {@link #displayField}. + * + * See also {@link #mode}. + */ + /** + * @cfg {String} title If supplied, a header element is created containing this text and added into the top of + * the dropdown list (defaults to undefined, with no header element) + */ + // private + defaultAutoCreate : {tag: "input", type: "text", size: "24", autocomplete: "off"}, /** - * Returns the raw data value which may or may not be a valid, defined value. To return a normalized value see {@link #getValue}. - * @return {Mixed} value The field value + * @cfg {Number} listWidth The width (used as a parameter to {@link Ext.Element#setWidth}) of the dropdown + * list (defaults to the width of the ComboBox field). See also {@link #minListWidth} + */ + /** + * @cfg {String} displayField The underlying {@link Ext.data.Field#name data field name} to bind to this + * ComboBox (defaults to undefined if {@link #mode} = 'remote' or 'field1' if + * {@link #transform transforming a select} or if the {@link #store field name is autogenerated based on + * the store configuration}). + * See also {@link #valueField}. + * Note: if using a ComboBox in an {@link Ext.grid.EditorGridPanel Editor Grid} a + * {@link Ext.grid.Column#renderer renderer} will be needed to show the displayField when the editor is not + * active. + */ + /** + * @cfg {String} valueField The underlying {@link Ext.data.Field#name data value name} to bind to this + * ComboBox (defaults to undefined if {@link #mode} = 'remote' or 'field2' if + * {@link #transform transforming a select} or if the {@link #store field name is autogenerated based on + * the store configuration}). + * Note: use of a valueField requires the user to make a selection in order for a value to be + * mapped. See also {@link #hiddenName}, {@link #hiddenValue}, and {@link #displayField}. + */ + /** + * @cfg {String} hiddenName If specified, a hidden form field with this name is dynamically generated to store the + * field's data value (defaults to the underlying DOM element's name). Required for the combo's value to automatically + * post during a form submission. See also {@link #valueField}. + * Note: the hidden field's id will also default to this name if {@link #hiddenId} is not specified. + * The ComboBox {@link Ext.Component#id id} and the {@link #hiddenId} should be different, since + * no two DOM nodes should share the same id. So, if the ComboBox {@link Ext.form.Field#name name} and + * hiddenName are the same, you should specify a unique {@link #hiddenId}. */ - getRawValue : function(){ - var v = this.rendered ? this.el.getValue() : Ext.value(this.value, ''); - if(v === this.emptyText){ - v = ''; - } - return v; - }, - /** - * Returns the normalized data value (undefined or emptyText will be returned as ''). To return the raw value see {@link #getRawValue}. - * @return {Mixed} value The field value + * @cfg {String} hiddenId If {@link #hiddenName} is specified, hiddenId can also be provided + * to give the hidden field a unique id (defaults to the {@link #hiddenName}). The hiddenId + * and combo {@link Ext.Component#id id} should be different, since no two DOM + * nodes should share the same id. */ - getValue : function(){ - if(!this.rendered) { - return this.value; - } - var v = this.el.getValue(); - if(v === this.emptyText || v === undefined){ - v = ''; - } - return v; - }, - /** - * Sets the underlying DOM field's value directly, bypassing validation. To set the value with validation see {@link #setValue}. - * @param {Mixed} value The value to set - * @return {Mixed} value The field value that is set + * @cfg {String} hiddenValue Sets the initial value of the hidden field if {@link #hiddenName} is + * specified to contain the selected {@link #valueField}, from the Store. Defaults to the configured + * {@link Ext.form.Field#value value}. */ - setRawValue : function(v){ - return this.rendered ? (this.el.dom.value = (Ext.isEmpty(v) ? '' : v)) : ''; - }, - /** - * Sets a data value into the field and validates it. To set the value directly without validation see {@link #setRawValue}. - * @param {Mixed} value The value to set - * @return {Ext.form.Field} this + * @cfg {String} listClass The CSS class to add to the predefined 'x-combo-list' class + * applied the dropdown list element (defaults to ''). */ - setValue : function(v){ - this.value = v; - if(this.rendered){ - this.el.dom.value = (Ext.isEmpty(v) ? '' : v); - this.validate(); - } - return this; - }, - - // private, does not work for all fields - append : function(v){ - this.setValue([this.getValue(), v].join('')); - } - + listClass : '', /** - * @cfg {Boolean} autoWidth @hide + * @cfg {String} selectedClass CSS class to apply to the selected item in the dropdown list + * (defaults to 'x-combo-selected') */ + selectedClass : 'x-combo-selected', /** - * @cfg {Boolean} autoHeight @hide + * @cfg {String} listEmptyText The empty text to display in the data view if no items are found. + * (defaults to '') */ - + listEmptyText: '', /** - * @cfg {String} autoEl @hide + * @cfg {String} triggerClass An additional CSS class used to style the trigger button. The trigger will always + * get the class 'x-form-trigger' and triggerClass will be appended if specified + * (defaults to 'x-form-arrow-trigger' which displays a downward arrow icon). */ -}); - - -Ext.form.MessageTargets = { - 'qtip' : { - mark: function(field, msg){ - field.el.addClass(field.invalidClass); - field.el.dom.qtip = msg; - field.el.dom.qclass = 'x-form-invalid-tip'; - if(Ext.QuickTips){ // fix for floating editors interacting with DND - Ext.QuickTips.enable(); - } - }, - clear: function(field){ - field.el.removeClass(field.invalidClass); - field.el.dom.qtip = ''; - } - }, - 'title' : { - mark: function(field, msg){ - field.el.addClass(field.invalidClass); - field.el.dom.title = msg; - }, - clear: function(field){ - field.el.dom.title = ''; - } - }, - 'under' : { - mark: function(field, msg){ - field.el.addClass(field.invalidClass); - if(!field.errorEl){ - var elp = field.getErrorCt(); - if(!elp){ // field has no container el - field.el.dom.title = msg; - return; - } - field.errorEl = elp.createChild({cls:'x-form-invalid-msg'}); - field.on('resize', field.alignErrorEl, field); - field.on('destroy', function(){ - Ext.destroy(this.errorEl); - }, field); - } - field.alignErrorEl(); - field.errorEl.update(msg); - Ext.form.Field.msgFx[field.msgFx].show(field.errorEl, field); - }, - clear: function(field){ - field.el.removeClass(field.invalidClass); - if(field.errorEl){ - Ext.form.Field.msgFx[field.msgFx].hide(field.errorEl, field); - }else{ - field.el.dom.title = ''; - } - } - }, - 'side' : { - mark: function(field, msg){ - field.el.addClass(field.invalidClass); - if(!field.errorIcon){ - var elp = field.getErrorCt(); - if(!elp){ // field has no container el - field.el.dom.title = msg; - return; - } - field.errorIcon = elp.createChild({cls:'x-form-invalid-icon'}); - field.on('resize', field.alignErrorIcon, field); - field.on('destroy', function(){ - Ext.destroy(this.errorIcon); - }, field); - } - field.alignErrorIcon(); - field.errorIcon.dom.qtip = msg; - field.errorIcon.dom.qclass = 'x-form-invalid-tip'; - field.errorIcon.show(); - }, - clear: function(field){ - field.el.removeClass(field.invalidClass); - if(field.errorIcon){ - field.errorIcon.dom.qtip = ''; - field.errorIcon.hide(); - }else{ - field.el.dom.title = ''; - } - } - } -}; - -// anything other than normal should be considered experimental -Ext.form.Field.msgFx = { - normal : { - show: function(msgEl, f){ - msgEl.setDisplayed('block'); - }, - - hide : function(msgEl, f){ - msgEl.setDisplayed(false).update(''); - } - }, - - slide : { - show: function(msgEl, f){ - msgEl.slideIn('t', {stopFx:true}); - }, - - hide : function(msgEl, f){ - msgEl.slideOut('t', {stopFx:true,useDisplay:true}); - } - }, - - slideRight : { - show: function(msgEl, f){ - msgEl.fixDisplay(); - msgEl.alignTo(f.el, 'tl-tr'); - msgEl.slideIn('l', {stopFx:true}); - }, - - hide : function(msgEl, f){ - msgEl.slideOut('l', {stopFx:true,useDisplay:true}); - } - } -}; -Ext.reg('field', Ext.form.Field); -/** - * @class Ext.form.TextField - * @extends Ext.form.Field - * Basic text field. Can be used as a direct replacement for traditional text inputs, - * or as the base class for more sophisticated input controls (like {@link Ext.form.TextArea} - * and {@link Ext.form.ComboBox}). - * Validation - * The validation procedure is described in the documentation for {@link #validateValue}. - * Alter Validation Behavior - * Validation behavior for each field can be configured: - * - * {@link Ext.form.TextField#invalidText invalidText} : the default validation message to - * show if any validation step above does not provide a message when invalid - * {@link Ext.form.TextField#maskRe maskRe} : filter out keystrokes before any validation occurs - * {@link Ext.form.TextField#stripCharsRe stripCharsRe} : filter characters after being typed in, - * but before being validated - * {@link Ext.form.Field#invalidClass invalidClass} : alternate style when invalid - * {@link Ext.form.Field#validateOnBlur validateOnBlur}, - * {@link Ext.form.Field#validationDelay validationDelay}, and - * {@link Ext.form.Field#validationEvent validationEvent} : modify how/when validation is triggered - * - * - * @constructor Creates a new TextField - * @param {Object} config Configuration options - * - * @xtype textfield - */ -Ext.form.TextField = Ext.extend(Ext.form.Field, { + triggerClass : 'x-form-arrow-trigger', /** - * @cfg {String} vtypeText A custom error message to display in place of the default message provided - * for the {@link #vtype} currently set for this field (defaults to ''). Note: - * only applies if {@link #vtype} is set, else ignored. + * @cfg {Boolean/String} shadow true or "sides" for the default effect, "frame" for + * 4-way shadow, and "drop" for bottom-right */ + shadow : 'sides', /** - * @cfg {RegExp} stripCharsRe A JavaScript RegExp object used to strip unwanted content from the value - * before validation (defaults to null). + * @cfg {String/Array} listAlign A valid anchor position value. See {@link Ext.Element#alignTo} for details + * on supported anchor positions and offsets. To specify x/y offsets as well, this value + * may be specified as an Array of {@link Ext.Element#alignTo} method arguments. + * [ 'tl-bl?', [6,0] ] (defaults to 'tl-bl?') */ + listAlign : 'tl-bl?', /** - * @cfg {Boolean} grow true if this field should automatically grow and shrink to its content - * (defaults to false) + * @cfg {Number} maxHeight The maximum height in pixels of the dropdown list before scrollbars are shown + * (defaults to 300) */ - grow : false, + maxHeight : 300, /** - * @cfg {Number} growMin The minimum width to allow when {@link #grow} = true (defaults - * to 30) + * @cfg {Number} minHeight The minimum height in pixels of the dropdown list when the list is constrained by its + * distance to the viewport edges (defaults to 90) */ - growMin : 30, + minHeight : 90, /** - * @cfg {Number} growMax The maximum width to allow when {@link #grow} = true (defaults - * to 800) + * @cfg {String} triggerAction The action to execute when the trigger is clicked. + * + * 'query' : Default + * {@link #doQuery run the query} using the {@link Ext.form.Field#getRawValue raw value}. + * 'all' : + * {@link #doQuery run the query} specified by the {@link #allQuery} config option + * + * See also {@link #queryParam}. */ - growMax : 800, + triggerAction : 'query', /** - * @cfg {String} vtype A validation type name as defined in {@link Ext.form.VTypes} (defaults to null) + * @cfg {Number} minChars The minimum number of characters the user must type before autocomplete and + * {@link #typeAhead} activate (defaults to 4 if {@link #mode} = 'remote' or 0 if + * {@link #mode} = 'local', does not apply if + * {@link Ext.form.TriggerField#editable editable} = false). */ - vtype : null, + minChars : 4, /** - * @cfg {RegExp} maskRe An input mask regular expression that will be used to filter keystrokes that do - * not match (defaults to null) + * @cfg {Boolean} autoSelect true to select the first result gathered by the data store (defaults + * to true). A false value would require a manual selection from the dropdown list to set the components value + * unless the value of ({@link #typeAheadDelay}) were true. */ - maskRe : null, + autoSelect : true, /** - * @cfg {Boolean} disableKeyFilter Specify true to disable input keystroke filtering (defaults + * @cfg {Boolean} typeAhead true to populate and autoselect the remainder of the text being + * typed after a configurable delay ({@link #typeAheadDelay}) if it matches a known value (defaults * to false) */ - disableKeyFilter : false, + typeAhead : false, /** - * @cfg {Boolean} allowBlank Specify false to validate that the value's length is > 0 (defaults to - * true) + * @cfg {Number} queryDelay The length of time in milliseconds to delay between the start of typing and + * sending the query to filter the dropdown list (defaults to 500 if {@link #mode} = 'remote' + * or 10 if {@link #mode} = 'local') */ - allowBlank : true, + queryDelay : 500, /** - * @cfg {Number} minLength Minimum input field length required (defaults to 0) + * @cfg {Number} pageSize If greater than 0, a {@link Ext.PagingToolbar} is displayed in the + * footer of the dropdown list and the {@link #doQuery filter queries} will execute with page start and + * {@link Ext.PagingToolbar#pageSize limit} parameters. Only applies when {@link #mode} = 'remote' + * (defaults to 0). */ - minLength : 0, + pageSize : 0, /** - * @cfg {Number} maxLength Maximum input field length allowed by validation (defaults to Number.MAX_VALUE). - * This behavior is intended to provide instant feedback to the user by improving usability to allow pasting - * and editing or overtyping and back tracking. To restrict the maximum number of characters that can be - * entered into the field use {@link Ext.form.Field#autoCreate autoCreate} to add - * any attributes you want to a field, for example: -var myField = new Ext.form.NumberField({ - id: 'mobile', - anchor:'90%', - fieldLabel: 'Mobile', - maxLength: 16, // for validation - autoCreate: {tag: 'input', type: 'text', size: '20', autocomplete: 'off', maxlength: '10'} -}); - + * @cfg {Boolean} selectOnFocus true to select any existing text in the field immediately on focus. + * Only applies when {@link Ext.form.TriggerField#editable editable} = true (defaults to + * false). */ - maxLength : Number.MAX_VALUE, + selectOnFocus : false, /** - * @cfg {String} minLengthText Error text to display if the {@link #minLength minimum length} - * validation fails (defaults to 'The minimum length for this field is {minLength}') + * @cfg {String} queryParam Name of the query ({@link Ext.data.Store#baseParam baseParam} name for the store) + * as it will be passed on the querystring (defaults to 'query') */ - minLengthText : 'The minimum length for this field is {0}', + queryParam : 'query', /** - * @cfg {String} maxLengthText Error text to display if the {@link #maxLength maximum length} - * validation fails (defaults to 'The maximum length for this field is {maxLength}') + * @cfg {String} loadingText The text to display in the dropdown list while data is loading. Only applies + * when {@link #mode} = 'remote' (defaults to 'Loading...') */ - maxLengthText : 'The maximum length for this field is {0}', + loadingText : 'Loading...', /** - * @cfg {Boolean} selectOnFocus true to automatically select any existing field text when the field - * receives input focus (defaults to false) + * @cfg {Boolean} resizable true to add a resize handle to the bottom of the dropdown list + * (creates an {@link Ext.Resizable} with 'se' {@link Ext.Resizable#pinned pinned} handles). + * Defaults to false. */ - selectOnFocus : false, + resizable : false, /** - * @cfg {String} blankText The error text to display if the {@link #allowBlank} validation - * fails (defaults to 'This field is required') + * @cfg {Number} handleHeight The height in pixels of the dropdown list resize handle if + * {@link #resizable} = true (defaults to 8) */ - blankText : 'This field is required', + handleHeight : 8, /** - * @cfg {Function} validator - * A custom validation function to be called during field validation ({@link #validateValue}) - * (defaults to null). If specified, this function will be called first, allowing the - * developer to override the default validation process. - * This function will be passed the following Parameters: - * - * value: Mixed - * The current field value - * - * This function is to Return: + * @cfg {String} allQuery The text query to send to the server to return all records for the list + * with no filtering (defaults to '') + */ + allQuery: '', + /** + * @cfg {String} mode Acceptable values are: * - * true: Boolean - * true if the value is valid - * msg: String - * An error message if the value is invalid + * 'remote' : Default + * Automatically loads the {@link #store} the first time the trigger + * is clicked. If you do not want the store to be automatically loaded the first time the trigger is + * clicked, set to 'local' and manually load the store. To force a requery of the store + * every time the trigger is clicked see {@link #lastQuery}. + * 'local' : + * ComboBox loads local data + * +var combo = new Ext.form.ComboBox({ + renderTo: document.body, + mode: 'local', + store: new Ext.data.ArrayStore({ + id: 0, + fields: [ + 'myId', // numeric value is the key + 'displayText' + ], + data: [[1, 'item1'], [2, 'item2']] // data is local + }), + valueField: 'myId', + displayField: 'displayText', + triggerAction: 'all' +}); + * * */ - validator : null, + mode: 'remote', /** - * @cfg {RegExp} regex A JavaScript RegExp object to be tested against the field value during validation - * (defaults to null). If the test fails, the field will be marked invalid using - * {@link #regexText}. + * @cfg {Number} minListWidth The minimum width of the dropdown list in pixels (defaults to 70, will + * be ignored if {@link #listWidth} has a higher value) */ - regex : null, + minListWidth : 70, /** - * @cfg {String} regexText The error text to display if {@link #regex} is used and the - * test fails during validation (defaults to '') + * @cfg {Boolean} forceSelection true to restrict the selected value to one of the values in the list, + * false to allow the user to set arbitrary text into the field (defaults to false) */ - regexText : '', + forceSelection : false, /** - * @cfg {String} emptyText The default text to place into an empty field (defaults to null). - * Note: that this value will be submitted to the server if this field is enabled and configured - * with a {@link #name}. + * @cfg {Number} typeAheadDelay The length of time in milliseconds to wait until the typeahead text is displayed + * if {@link #typeAhead} = true (defaults to 250) */ - emptyText : null, + typeAheadDelay : 250, /** - * @cfg {String} emptyClass The CSS class to apply to an empty field to style the {@link #emptyText} - * (defaults to 'x-form-empty-field'). This class is automatically added and removed as needed - * depending on the current field value. + * @cfg {String} valueNotFoundText When using a name/value combo, if the value passed to setValue is not found in + * the store, valueNotFoundText will be displayed as the field text if defined (defaults to undefined). If this + * default text is used, it means there is no value set and no validation will occur on this field. */ - emptyClass : 'x-form-empty-field', /** - * @cfg {Boolean} enableKeyEvents true to enable the proxying of key events for the HTML input - * field (defaults to false) + * @cfg {Boolean} lazyInit true to not initialize the list for this combo until the field is focused + * (defaults to true) + */ + lazyInit : true, + + /** + * @cfg {Boolean} clearFilterOnReset true to clear any filters on the store (when in local mode) when reset is called + * (defaults to true) + */ + clearFilterOnReset : true, + + /** + * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post. + * If a hiddenName is specified, setting this to true will cause both the hidden field and the element to be submitted. + * Defaults to undefined. + */ + submitValue: undefined, + + /** + * The value of the match string used to filter the store. Delete this property to force a requery. + * Example use: + * +var combo = new Ext.form.ComboBox({ + ... + mode: 'remote', + ... + listeners: { + // delete the previous query in the beforequery event or set + // combo.lastQuery = null (this will reload the store the next time it expands) + beforequery: function(qe){ + delete qe.combo.lastQuery; + } + } +}); + * + * To make sure the filter in the store is not cleared the first time the ComboBox trigger is used + * configure the combo with lastQuery=''. Example use: + * +var combo = new Ext.form.ComboBox({ + ... + mode: 'local', + triggerAction: 'all', + lastQuery: '' +}); + * + * @property lastQuery + * @type String */ + // private initComponent : function(){ - Ext.form.TextField.superclass.initComponent.call(this); + Ext.form.ComboBox.superclass.initComponent.call(this); this.addEvents( /** - * @event autosize - * Fires when the {@link #autoSize} function is triggered. The field may or - * may not have actually changed size according to the default logic, but this event provides - * a hook for the developer to apply additional logic at runtime to resize the field if needed. - * @param {Ext.form.Field} this This text field - * @param {Number} width The new field width + * @event expand + * Fires when the dropdown list is expanded + * @param {Ext.form.ComboBox} combo This combo box */ - 'autosize', - + 'expand', /** - * @event keydown - * Keydown input field event. This event only fires if {@link #enableKeyEvents} - * is set to true. - * @param {Ext.form.TextField} this This text field - * @param {Ext.EventObject} e + * @event collapse + * Fires when the dropdown list is collapsed + * @param {Ext.form.ComboBox} combo This combo box */ - 'keydown', + 'collapse', + /** - * @event keyup - * Keyup input field event. This event only fires if {@link #enableKeyEvents} - * is set to true. - * @param {Ext.form.TextField} this This text field - * @param {Ext.EventObject} e + * @event beforeselect + * Fires before a list item is selected. Return false to cancel the selection. + * @param {Ext.form.ComboBox} combo This combo box + * @param {Ext.data.Record} record The data record returned from the underlying store + * @param {Number} index The index of the selected item in the dropdown list */ - 'keyup', + 'beforeselect', /** - * @event keypress - * Keypress input field event. This event only fires if {@link #enableKeyEvents} - * is set to true. - * @param {Ext.form.TextField} this This text field - * @param {Ext.EventObject} e + * @event select + * Fires when a list item is selected + * @param {Ext.form.ComboBox} combo This combo box + * @param {Ext.data.Record} record The data record returned from the underlying store + * @param {Number} index The index of the selected item in the dropdown list + */ + 'select', + /** + * @event beforequery + * Fires before all queries are processed. Return false to cancel the query or set the queryEvent's + * cancel property to true. + * @param {Object} queryEvent An object that has these properties: + * combo : Ext.form.ComboBox This combo box + * query : String The query + * forceAll : Boolean True to force "all" query + * cancel : Boolean Set to true to cancel the query + * */ - 'keypress' + 'beforequery' ); - }, - - // private - initEvents : function(){ - Ext.form.TextField.superclass.initEvents.call(this); - if(this.validationEvent == 'keyup'){ - this.validationTask = new Ext.util.DelayedTask(this.validate, this); - this.mon(this.el, 'keyup', this.filterValidation, this); - } - else if(this.validationEvent !== false && this.validationEvent != 'blur'){ - this.mon(this.el, this.validationEvent, this.validate, this, {buffer: this.validationDelay}); - } - if(this.selectOnFocus || this.emptyText){ - this.mon(this.el, 'mousedown', this.onMouseDown, this); - - if(this.emptyText){ - this.applyEmptyText(); + if(this.transform){ + var s = Ext.getDom(this.transform); + if(!this.hiddenName){ + this.hiddenName = s.name; } + if(!this.store){ + this.mode = 'local'; + var d = [], opts = s.options; + for(var i = 0, len = opts.length;i < len; i++){ + var o = opts[i], + value = (o.hasAttribute ? o.hasAttribute('value') : o.getAttributeNode('value').specified) ? o.value : o.text; + if(o.selected && Ext.isEmpty(this.value, true)) { + this.value = value; + } + d.push([value, o.text]); + } + this.store = new Ext.data.ArrayStore({ + 'id': 0, + fields: ['value', 'text'], + data : d, + autoDestroy: true + }); + this.valueField = 'value'; + this.displayField = 'text'; + } + s.name = Ext.id(); // wipe out the name in case somewhere else they have a reference + if(!this.lazyRender){ + this.target = true; + this.el = Ext.DomHelper.insertBefore(s, this.autoCreate || this.defaultAutoCreate); + this.render(this.el.parentNode, s); + } + Ext.removeNode(s); } - if(this.maskRe || (this.vtype && this.disableKeyFilter !== true && (this.maskRe = Ext.form.VTypes[this.vtype+'Mask']))){ - this.mon(this.el, 'keypress', this.filterKeys, this); - } - if(this.grow){ - this.mon(this.el, 'keyup', this.onKeyUpBuffered, this, {buffer: 50}); - this.mon(this.el, 'click', this.autoSize, this); - } - if(this.enableKeyEvents){ - this.mon(this.el, { - scope: this, - keyup: this.onKeyUp, - keydown: this.onKeyDown, - keypress: this.onKeyPress - }); - } - }, - - onMouseDown: function(e){ - if(!this.hasFocus){ - this.mon(this.el, 'mouseup', Ext.emptyFn, this, { single: true, preventDefault: true }); + //auto-configure store from local array data + else if(this.store){ + this.store = Ext.StoreMgr.lookup(this.store); + if(this.store.autoCreated){ + this.displayField = this.valueField = 'field1'; + if(!this.store.expandData){ + this.displayField = 'field2'; + } + this.mode = 'local'; + } } - }, - processValue : function(value){ - if(this.stripCharsRe){ - var newValue = value.replace(this.stripCharsRe, ''); - if(newValue !== value){ - this.setRawValue(newValue); - return newValue; + this.selectedIndex = -1; + if(this.mode == 'local'){ + if(!Ext.isDefined(this.initialConfig.queryDelay)){ + this.queryDelay = 10; + } + if(!Ext.isDefined(this.initialConfig.minChars)){ + this.minChars = 0; } } - return value; }, - filterValidation : function(e){ - if(!e.isNavKeyPress()){ - this.validationTask.delay(this.validationDelay); + // private + onRender : function(ct, position){ + if(this.hiddenName && !Ext.isDefined(this.submitValue)){ + this.submitValue = false; } - }, - - //private - onDisable: function(){ - Ext.form.TextField.superclass.onDisable.call(this); - if(Ext.isIE){ - this.el.dom.unselectable = 'on'; + Ext.form.ComboBox.superclass.onRender.call(this, ct, position); + if(this.hiddenName){ + this.hiddenField = this.el.insertSibling({tag:'input', type:'hidden', name: this.hiddenName, + id: (this.hiddenId||this.hiddenName)}, 'before', true); + } - }, - - //private - onEnable: function(){ - Ext.form.TextField.superclass.onEnable.call(this); - if(Ext.isIE){ - this.el.dom.unselectable = ''; + if(Ext.isGecko){ + this.el.dom.setAttribute('autocomplete', 'off'); } - }, - // private - onKeyUpBuffered : function(e){ - if(this.doAutoSize(e)){ - this.autoSize(); + if(!this.lazyInit){ + this.initList(); + }else{ + this.on('focus', this.initList, this, {single: true}); } }, - - // private - doAutoSize : function(e){ - return !e.isNavKeyPress(); - }, // private - onKeyUp : function(e){ - this.fireEvent('keyup', this, e); + initValue : function(){ + Ext.form.ComboBox.superclass.initValue.call(this); + if(this.hiddenField){ + this.hiddenField.value = + Ext.value(Ext.isDefined(this.hiddenValue) ? this.hiddenValue : this.value, ''); + } }, - // private - onKeyDown : function(e){ - this.fireEvent('keydown', this, e); + getParentZIndex : function(){ + var zindex; + if (this.ownerCt){ + this.findParentBy(function(ct){ + zindex = parseInt(ct.getPositionEl().getStyle('z-index'), 10); + return !!zindex; + }); + } + return zindex; }, // private - onKeyPress : function(e){ - this.fireEvent('keypress', this, e); + initList : function(){ + if(!this.list){ + var cls = 'x-combo-list', + listParent = Ext.getDom(this.getListParent() || Ext.getBody()), + zindex = parseInt(Ext.fly(listParent).getStyle('z-index'), 10); + + if (!zindex) { + zindex = this.getParentZIndex(); + } + + this.list = new Ext.Layer({ + parentEl: listParent, + shadow: this.shadow, + cls: [cls, this.listClass].join(' '), + constrain:false, + zindex: (zindex || 12000) + 5 + }); + + var lw = this.listWidth || Math.max(this.wrap.getWidth(), this.minListWidth); + this.list.setSize(lw, 0); + this.list.swallowEvent('mousewheel'); + this.assetHeight = 0; + if(this.syncFont !== false){ + this.list.setStyle('font-size', this.el.getStyle('font-size')); + } + if(this.title){ + this.header = this.list.createChild({cls:cls+'-hd', html: this.title}); + this.assetHeight += this.header.getHeight(); + } + + this.innerList = this.list.createChild({cls:cls+'-inner'}); + this.mon(this.innerList, 'mouseover', this.onViewOver, this); + this.mon(this.innerList, 'mousemove', this.onViewMove, this); + this.innerList.setWidth(lw - this.list.getFrameWidth('lr')); + + if(this.pageSize){ + this.footer = this.list.createChild({cls:cls+'-ft'}); + this.pageTb = new Ext.PagingToolbar({ + store: this.store, + pageSize: this.pageSize, + renderTo:this.footer + }); + this.assetHeight += this.footer.getHeight(); + } + + if(!this.tpl){ + /** + * @cfg {String/Ext.XTemplate} tpl The template string, or {@link Ext.XTemplate} instance to + * use to display each item in the dropdown list. The dropdown list is displayed in a + * DataView. See {@link #view}. + * The default template string is: + '<tpl for="."><div class="x-combo-list-item">{' + this.displayField + '}</div></tpl>' + * + * Override the default value to create custom UI layouts for items in the list. + * For example: + '<tpl for="."><div ext:qtip="{state}. {nick}" class="x-combo-list-item">{state}</div></tpl>' + * + * The template must contain one or more substitution parameters using field + * names from the Combo's {@link #store Store}. In the example above an + * ext:qtip attribute is added to display other fields from the Store. + * To preserve the default visual look of list items, add the CSS class name + * x-combo-list-item to the template's container element. + * Also see {@link #itemSelector} for additional details. + */ + this.tpl = '{' + this.displayField + '}'; + /** + * @cfg {String} itemSelector + * A simple CSS selector (e.g. div.some-class or span:first-child) that will be + * used to determine what nodes the {@link #view Ext.DataView} which handles the dropdown + * display will be working with. + * Note: this setting is required if a custom XTemplate has been + * specified in {@link #tpl} which assigns a class other than 'x-combo-list-item' + * to dropdown list items + */ + } + + /** + * The {@link Ext.DataView DataView} used to display the ComboBox's options. + * @type Ext.DataView + */ + this.view = new Ext.DataView({ + applyTo: this.innerList, + tpl: this.tpl, + singleSelect: true, + selectedClass: this.selectedClass, + itemSelector: this.itemSelector || '.' + cls + '-item', + emptyText: this.listEmptyText, + deferEmptyText: false + }); + + this.mon(this.view, { + containerclick : this.onViewClick, + click : this.onViewClick, + scope :this + }); + + this.bindStore(this.store, true); + + if(this.resizable){ + this.resizer = new Ext.Resizable(this.list, { + pinned:true, handles:'se' + }); + this.mon(this.resizer, 'resize', function(r, w, h){ + this.maxHeight = h-this.handleHeight-this.list.getFrameWidth('tb')-this.assetHeight; + this.listWidth = w; + this.innerList.setWidth(w - this.list.getFrameWidth('lr')); + this.restrictHeight(); + }, this); + + this[this.pageSize?'footer':'innerList'].setStyle('margin-bottom', this.handleHeight+'px'); + } + } }, /** - * Resets the current field value to the originally-loaded value and clears any validation messages. - * Also adds {@link #emptyText} and {@link #emptyClass} if the - * original value was blank. + * Returns the element used to house this ComboBox's pop-up list. Defaults to the document body. + * A custom implementation may be provided as a configuration option if the floating list needs to be rendered + * to a different Element. An example might be rendering the list inside a Menu so that clicking + * the list does not hide the Menu: +var store = new Ext.data.ArrayStore({ + autoDestroy: true, + fields: ['initials', 'fullname'], + data : [ + ['FF', 'Fred Flintstone'], + ['BR', 'Barney Rubble'] + ] +}); + +var combo = new Ext.form.ComboBox({ + store: store, + displayField: 'fullname', + emptyText: 'Select a name...', + forceSelection: true, + getListParent: function() { + return this.el.up('.x-menu'); + }, + iconCls: 'no-icon', //use iconCls if placing within menu to shift to right side of menu + mode: 'local', + selectOnFocus: true, + triggerAction: 'all', + typeAhead: true, + width: 135 +}); + +var menu = new Ext.menu.Menu({ + id: 'mainMenu', + items: [ + combo // A Field in a Menu + ] +}); + */ - reset : function(){ - Ext.form.TextField.superclass.reset.call(this); - this.applyEmptyText(); + getListParent : function() { + return document.body; }, - applyEmptyText : function(){ - if(this.rendered && this.emptyText && this.getRawValue().length < 1 && !this.hasFocus){ - this.setRawValue(this.emptyText); - this.el.addClass(this.emptyClass); - } + /** + * Returns the store associated with this combo. + * @return {Ext.data.Store} The store + */ + getStore : function(){ + return this.store; }, // private - preFocus : function(){ - var el = this.el; - if(this.emptyText){ - if(el.dom.value == this.emptyText){ - this.setRawValue(''); + bindStore : function(store, initial){ + if(this.store && !initial){ + if(this.store !== store && this.store.autoDestroy){ + this.store.destroy(); + }else{ + this.store.un('beforeload', this.onBeforeLoad, this); + this.store.un('load', this.onLoad, this); + this.store.un('exception', this.collapse, this); + } + if(!store){ + this.store = null; + if(this.view){ + this.view.bindStore(null); + } + if(this.pageTb){ + this.pageTb.bindStore(null); + } } - el.removeClass(this.emptyClass); - } - if(this.selectOnFocus){ - el.dom.select(); } - }, + if(store){ + if(!initial) { + this.lastQuery = null; + if(this.pageTb) { + this.pageTb.bindStore(store); + } + } - // private - postBlur : function(){ - this.applyEmptyText(); - }, + this.store = Ext.StoreMgr.lookup(store); + this.store.on({ + scope: this, + beforeload: this.onBeforeLoad, + load: this.onLoad, + exception: this.collapse + }); - // private - filterKeys : function(e){ - if(e.ctrlKey){ - return; - } - var k = e.getKey(); - if(Ext.isGecko && (e.isNavKeyPress() || k == e.BACKSPACE || (k == e.DELETE && e.button == -1))){ - return; - } - var cc = String.fromCharCode(e.getCharCode()); - if(!Ext.isGecko && e.isSpecialKey() && !cc){ - return; - } - if(!this.maskRe.test(cc)){ - e.stopEvent(); + if(this.view){ + this.view.bindStore(store); + } } }, - setValue : function(v){ - if(this.emptyText && this.el && !Ext.isEmpty(v)){ - this.el.removeClass(this.emptyClass); + reset : function(){ + Ext.form.ComboBox.superclass.reset.call(this); + if(this.clearFilterOnReset && this.mode == 'local'){ + this.store.clearFilter(); } - Ext.form.TextField.superclass.setValue.apply(this, arguments); - this.applyEmptyText(); - this.autoSize(); - return this; }, - /** - * Validates a value according to the field's validation rules and marks the field as invalid - * if the validation fails. Validation rules are processed in the following order: - * - * - * 1. Field specific validator - * - * A validator offers a way to customize and reuse a validation specification. - * If a field is configured with a {@link #validator} - * function, it will be passed the current field value. The {@link #validator} - * function is expected to return either: - * - * Boolean true if the value is valid (validation continues). - * a String to represent the invalid message if invalid (validation halts). - * - * - * - * 2. Basic Validation - * - * If the {@link #validator} has not halted validation, - * basic validation proceeds as follows: - * - * - * - * {@link #allowBlank} : (Invalid message = - * {@link #emptyText}) - * Depending on the configuration of {@link #allowBlank}, a - * blank field will cause validation to halt at this step and return - * Boolean true or false accordingly. - * - * - * {@link #minLength} : (Invalid message = - * {@link #minLengthText}) - * If the passed value does not satisfy the {@link #minLength} - * specified, validation halts. - * - * - * {@link #maxLength} : (Invalid message = - * {@link #maxLengthText}) - * If the passed value does not satisfy the {@link #maxLength} - * specified, validation halts. - * - * - * - * - * - * 3. Preconfigured Validation Types (VTypes) - * - * If none of the prior validation steps halts validation, a field - * configured with a {@link #vtype} will utilize the - * corresponding {@link Ext.form.VTypes VTypes} validation function. - * If invalid, either the field's {@link #vtypeText} or - * the VTypes vtype Text property will be used for the invalid message. - * Keystrokes on the field will be filtered according to the VTypes - * vtype Mask property. - * - * - * 4. Field specific regex test - * - * If none of the prior validation steps halts validation, a field's - * configured {@link #regex} test will be processed. - * The invalid message for this test is configured with - * {@link #regexText}. - * - * - * @param {Mixed} value The value to validate - * @return {Boolean} True if the value is valid, else false - */ - validateValue : function(value){ - if(Ext.isFunction(this.validator)){ - var msg = this.validator(value); - if(msg !== true){ - this.markInvalid(msg); - return false; - } - } - if(value.length < 1 || value === this.emptyText){ // if it's blank - if(this.allowBlank){ - this.clearInvalid(); - return true; - }else{ - this.markInvalid(this.blankText); - return false; - } - } - if(value.length < this.minLength){ - this.markInvalid(String.format(this.minLengthText, this.minLength)); - return false; - } - if(value.length > this.maxLength){ - this.markInvalid(String.format(this.maxLengthText, this.maxLength)); - return false; - } - if(this.vtype){ - var vt = Ext.form.VTypes; - if(!vt[this.vtype](value, this)){ - this.markInvalid(this.vtypeText || vt[this.vtype +'Text']); - return false; - } + // private + initEvents : function(){ + Ext.form.ComboBox.superclass.initEvents.call(this); + + + this.keyNav = new Ext.KeyNav(this.el, { + "up" : function(e){ + this.inKeyMode = true; + this.selectPrev(); + }, + + "down" : function(e){ + if(!this.isExpanded()){ + this.onTriggerClick(); + }else{ + this.inKeyMode = true; + this.selectNext(); + } + }, + + "enter" : function(e){ + this.onViewClick(); + }, + + "esc" : function(e){ + this.collapse(); + }, + + "tab" : function(e){ + if (this.forceSelection === true) { + this.collapse(); + } else { + this.onViewClick(false); + } + return true; + }, + + scope : this, + + doRelay : function(e, h, hname){ + if(hname == 'down' || this.scope.isExpanded()){ + // this MUST be called before ComboBox#fireKey() + var relay = Ext.KeyNav.prototype.doRelay.apply(this, arguments); + if(!Ext.isIE && Ext.EventManager.useKeydown){ + // call Combo#fireKey() for browsers which use keydown event (except IE) + this.scope.fireKey(e); + } + return relay; + } + return true; + }, + + forceKeyDown : true, + defaultEventAction: 'stopEvent' + }); + this.queryDelay = Math.max(this.queryDelay || 10, + this.mode == 'local' ? 10 : 250); + this.dqTask = new Ext.util.DelayedTask(this.initQuery, this); + if(this.typeAhead){ + this.taTask = new Ext.util.DelayedTask(this.onTypeAhead, this); } - if(this.regex && !this.regex.test(value)){ - this.markInvalid(this.regexText); - return false; + if(!this.enableKeyEvents){ + this.mon(this.el, 'keyup', this.onKeyUp, this); } - return true; }, - /** - * Selects text in this field - * @param {Number} start (optional) The index where the selection should start (defaults to 0) - * @param {Number} end (optional) The index where the selection should end (defaults to the text length) - */ - selectText : function(start, end){ - var v = this.getRawValue(); - var doFocus = false; - if(v.length > 0){ - start = start === undefined ? 0 : start; - end = end === undefined ? v.length : end; - var d = this.el.dom; - if(d.setSelectionRange){ - d.setSelectionRange(start, end); - }else if(d.createTextRange){ - var range = d.createTextRange(); - range.moveStart('character', start); - range.moveEnd('character', end-v.length); - range.select(); - } - doFocus = Ext.isGecko || Ext.isOpera; - }else{ - doFocus = true; - } - if(doFocus){ - this.focus(); + + // private + onDestroy : function(){ + if (this.dqTask){ + this.dqTask.cancel(); + this.dqTask = null; } + this.bindStore(null); + Ext.destroy( + this.resizer, + this.view, + this.pageTb, + this.list + ); + Ext.destroyMembers(this, 'hiddenField'); + Ext.form.ComboBox.superclass.onDestroy.call(this); }, - /** - * Automatically grows the field to accomodate the width of the text up to the maximum field width allowed. - * This only takes effect if {@link #grow} = true, and fires the {@link #autosize} event. - */ - autoSize : function(){ - if(!this.grow || !this.rendered){ - return; - } - if(!this.metrics){ - this.metrics = Ext.util.TextMetrics.createInstance(this.el); + // private + fireKey : function(e){ + if (!this.isExpanded()) { + Ext.form.ComboBox.superclass.fireKey.call(this, e); } - var el = this.el; - var v = el.dom.value; - var d = document.createElement('div'); - d.appendChild(document.createTextNode(v)); - v = d.innerHTML; - Ext.removeNode(d); - d = null; - v += ' '; - var w = Math.min(this.growMax, Math.max(this.metrics.getWidth(v) + /* add extra padding */ 10, this.growMin)); - this.el.setWidth(w); - this.fireEvent('autosize', this, w); }, - - onDestroy: function(){ - if(this.validationTask){ - this.validationTask.cancel(); - this.validationTask = null; - } - Ext.form.TextField.superclass.onDestroy.call(this); - } -}); -Ext.reg('textfield', Ext.form.TextField); -/** - * @class Ext.form.TriggerField - * @extends Ext.form.TextField - * Provides a convenient wrapper for TextFields that adds a clickable trigger button (looks like a combobox by default). - * The trigger has no default action, so you must assign a function to implement the trigger click handler by - * overriding {@link #onTriggerClick}. You can create a TriggerField directly, as it renders exactly like a combobox - * for which you can provide a custom implementation. For example: - * -var trigger = new Ext.form.TriggerField(); -trigger.onTriggerClick = myTriggerFn; -trigger.applyToMarkup('my-field'); - - * - * However, in general you will most likely want to use TriggerField as the base class for a reusable component. - * {@link Ext.form.DateField} and {@link Ext.form.ComboBox} are perfect examples of this. - * - * @constructor - * Create a new TriggerField. - * @param {Object} config Configuration options (valid {@Ext.form.TextField} config options will also be applied - * to the base TextField) - * @xtype trigger - */ -Ext.form.TriggerField = Ext.extend(Ext.form.TextField, { - /** - * @cfg {String} triggerClass - * An additional CSS class used to style the trigger button. The trigger will always get the - * class 'x-form-trigger' by default and triggerClass will be appended if specified. - */ - /** - * @cfg {Mixed} triggerConfig - * A {@link Ext.DomHelper DomHelper} config object specifying the structure of the - * trigger element for this Field. (Optional). - * Specify this when you need a customized element to act as the trigger button for a TriggerField. - * Note that when using this option, it is the developer's responsibility to ensure correct sizing, positioning - * and appearance of the trigger. Defaults to: - * {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass} - */ - /** - * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default - * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. - * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: - * {tag: "input", type: "text", size: "16", autocomplete: "off"} - */ - defaultAutoCreate : {tag: "input", type: "text", size: "16", autocomplete: "off"}, - /** - * @cfg {Boolean} hideTrigger true to hide the trigger element and display only the base - * text field (defaults to false) - */ - hideTrigger:false, - /** - * @cfg {Boolean} editable false to prevent the user from typing text directly into the field, - * the field will only respond to a click on the trigger to set the value. (defaults to true). - */ - editable: true, - /** - * @cfg {Boolean} readOnly true to prevent the user from changing the field, and - * hides the trigger. Superceeds the editable and hideTrigger options if the value is true. - * (defaults to false) - */ - readOnly: false, - /** - * @cfg {String} wrapFocusClass The class added to the to the wrap of the trigger element. Defaults to - * x-trigger-wrap-focus. - */ - wrapFocusClass: 'x-trigger-wrap-focus', - /** - * @hide - * @method autoSize - */ - autoSize: Ext.emptyFn, - // private - monitorTab : true, - // private - deferHeight : true, - // private - mimicing : false, - - actionMode: 'wrap', - - defaultTriggerWidth: 17, // private onResize : function(w, h){ - Ext.form.TriggerField.superclass.onResize.call(this, w, h); - var tw = this.getTriggerWidth(); - if(Ext.isNumber(w)){ - this.el.setWidth(w - tw); + Ext.form.ComboBox.superclass.onResize.apply(this, arguments); + if(!isNaN(w) && this.isVisible() && this.list){ + this.doResize(w); + }else{ + this.bufferSize = w; } - this.wrap.setWidth(this.el.getWidth() + tw); }, - getTriggerWidth: function(){ - var tw = this.trigger.getWidth(); - if(!this.hideTrigger && tw === 0){ - tw = this.defaultTriggerWidth; + doResize: function(w){ + if(!Ext.isDefined(this.listWidth)){ + var lw = Math.max(w, this.minListWidth); + this.list.setWidth(lw); + this.innerList.setWidth(lw - this.list.getFrameWidth('lr')); } - return tw; }, // private - alignErrorIcon : function(){ - if(this.wrap){ - this.errorIcon.alignTo(this.wrap, 'tl-tr', [2, 0]); + onEnable : function(){ + Ext.form.ComboBox.superclass.onEnable.apply(this, arguments); + if(this.hiddenField){ + this.hiddenField.disabled = false; } }, // private - onRender : function(ct, position){ - this.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc(); - Ext.form.TriggerField.superclass.onRender.call(this, ct, position); + onDisable : function(){ + Ext.form.ComboBox.superclass.onDisable.apply(this, arguments); + if(this.hiddenField){ + this.hiddenField.disabled = true; + } + }, - this.wrap = this.el.wrap({cls: 'x-form-field-wrap x-form-field-trigger-wrap'}); - this.trigger = this.wrap.createChild(this.triggerConfig || - {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.triggerClass}); - this.initTrigger(); - if(!this.width){ - this.wrap.setWidth(this.el.getWidth()+this.trigger.getWidth()); + // private + onBeforeLoad : function(){ + if(!this.hasFocus){ + return; } - this.resizeEl = this.positionEl = this.wrap; + this.innerList.update(this.loadingText ? + ''+this.loadingText+'' : ''); + this.restrictHeight(); + this.selectedIndex = -1; }, - updateEditState: function(){ - if(this.rendered){ - if (this.readOnly) { - this.el.dom.readOnly = true; - this.el.addClass('x-trigger-noedit'); - this.mun(this.el, 'click', this.onTriggerClick, this); - this.trigger.setDisplayed(false); - } else { - if (!this.editable) { - this.el.dom.readOnly = true; - this.el.addClass('x-trigger-noedit'); - this.mon(this.el, 'click', this.onTriggerClick, this); - } else { - this.el.dom.readOnly = false; - this.el.removeClass('x-trigger-noedit'); - this.mun(this.el, 'click', this.onTriggerClick, this); + // private + onLoad : function(){ + if(!this.hasFocus){ + return; + } + if(this.store.getCount() > 0 || this.listEmptyText){ + this.expand(); + this.restrictHeight(); + if(this.lastQuery == this.allQuery){ + if(this.editable){ + this.el.dom.select(); + } + + if(this.autoSelect !== false && !this.selectByValue(this.value, true)){ + this.select(0, true); + } + }else{ + if(this.autoSelect !== false){ + this.selectNext(); + } + if(this.typeAhead && this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE){ + this.taTask.delay(this.typeAheadDelay); } - this.trigger.setDisplayed(!this.hideTrigger); } - this.onResize(this.width || this.wrap.getWidth()); + }else{ + this.collapse(); } + }, - setHideTrigger: function(hideTrigger){ - if(hideTrigger != this.hideTrigger){ - this.hideTrigger = hideTrigger; - this.updateEditState(); + // private + onTypeAhead : function(){ + if(this.store.getCount() > 0){ + var r = this.store.getAt(0); + var newValue = r.data[this.displayField]; + var len = newValue.length; + var selStart = this.getRawValue().length; + if(selStart != len){ + this.setRawValue(newValue); + this.selectText(selStart, newValue.length); + } } }, - /** - * @param {Boolean} value True to allow the user to directly edit the field text - * Allow or prevent the user from directly editing the field text. If false is passed, - * the user will only be able to modify the field using the trigger. Will also add - * a click event to the text field which will call the trigger. This method - * is the runtime equivalent of setting the 'editable' config option at config time. - */ - setEditable: function(editable){ - if(editable != this.editable){ - this.editable = editable; - this.updateEditState(); + // private + assertValue : function(){ + var val = this.getRawValue(), + rec = this.findRecord(this.displayField, val); + + if(!rec && this.forceSelection){ + if(val.length > 0 && val != this.emptyText){ + this.el.dom.value = Ext.value(this.lastSelectionText, ''); + this.applyEmptyText(); + }else{ + this.clearValue(); + } + }else{ + if(rec){ + // onSelect may have already set the value and by doing so + // set the display field properly. Let's not wipe out the + // valueField here by just sending the displayField. + if (val == rec.get(this.displayField) && this.value == rec.get(this.valueField)){ + return; + } + val = rec.get(this.valueField || this.displayField); + } + this.setValue(val); } }, - /** - * @param {Boolean} value True to prevent the user changing the field and explicitly - * hide the trigger. - * Setting this to true will superceed settings editable and hideTrigger. - * Setting this to false will defer back to editable and hideTrigger. This method - * is the runtime equivalent of setting the 'readOnly' config option at config time. - */ - setReadOnly: function(readOnly){ - if(readOnly != this.readOnly){ - this.readOnly = readOnly; - this.updateEditState(); + // private + onSelect : function(record, index){ + if(this.fireEvent('beforeselect', this, record, index) !== false){ + this.setValue(record.data[this.valueField || this.displayField]); + this.collapse(); + this.fireEvent('select', this, record, index); } }, - afterRender : function(){ - Ext.form.TriggerField.superclass.afterRender.call(this); - this.updateEditState(); + // inherit docs + getName: function(){ + var hf = this.hiddenField; + return hf && hf.name ? hf.name : this.hiddenName || Ext.form.ComboBox.superclass.getName.call(this); }, - // private - initTrigger : function(){ - this.mon(this.trigger, 'click', this.onTriggerClick, this, {preventDefault:true}); - this.trigger.addClassOnOver('x-form-trigger-over'); - this.trigger.addClassOnClick('x-form-trigger-click'); + /** + * Returns the currently selected field value or empty string if no value is set. + * @return {String} value The selected value + */ + getValue : function(){ + if(this.valueField){ + return Ext.isDefined(this.value) ? this.value : ''; + }else{ + return Ext.form.ComboBox.superclass.getValue.call(this); + } }, - // private - onDestroy : function(){ - Ext.destroy(this.trigger, this.wrap); - if (this.mimicing){ - this.doc.un('mousedown', this.mimicBlur, this); + /** + * Clears any text/value currently set in the field + */ + clearValue : function(){ + if(this.hiddenField){ + this.hiddenField.value = ''; } - delete this.doc; - Ext.form.TriggerField.superclass.onDestroy.call(this); + this.setRawValue(''); + this.lastSelectionText = ''; + this.applyEmptyText(); + this.value = ''; }, - // private - onFocus : function(){ - Ext.form.TriggerField.superclass.onFocus.call(this); - if(!this.mimicing){ - this.wrap.addClass(this.wrapFocusClass); - this.mimicing = true; - this.doc.on('mousedown', this.mimicBlur, this, {delay: 10}); - if(this.monitorTab){ - this.on('specialkey', this.checkTab, this); + /** + * Sets the specified value into the field. If the value finds a match, the corresponding record text + * will be displayed in the field. If the value does not match the data value of an existing item, + * and the valueNotFoundText config option is defined, it will be displayed as the default field text. + * Otherwise the field will be blank (although the value will still be set). + * @param {String} value The value to match + * @return {Ext.form.Field} this + */ + setValue : function(v){ + var text = v; + if(this.valueField){ + var r = this.findRecord(this.valueField, v); + if(r){ + text = r.data[this.displayField]; + }else if(Ext.isDefined(this.valueNotFoundText)){ + text = this.valueNotFoundText; } } + this.lastSelectionText = text; + if(this.hiddenField){ + this.hiddenField.value = Ext.value(v, ''); + } + Ext.form.ComboBox.superclass.setValue.call(this, text); + this.value = v; + return this; }, // private - checkTab : function(me, e){ - if(e.getKey() == e.TAB){ - this.triggerBlur(); + findRecord : function(prop, value){ + var record; + if(this.store.getCount() > 0){ + this.store.each(function(r){ + if(r.data[prop] == value){ + record = r; + return false; + } + }); } + return record; }, // private - onBlur : Ext.emptyFn, + onViewMove : function(e, t){ + this.inKeyMode = false; + }, // private - mimicBlur : function(e){ - if(!this.isDestroyed && !this.wrap.contains(e.target) && this.validateBlur(e)){ - this.triggerBlur(); + onViewOver : function(e, t){ + if(this.inKeyMode){ // prevent key nav and mouse over conflicts + return; + } + var item = this.view.findItemFromChild(t); + if(item){ + var index = this.view.indexOf(item); + this.select(index, false); } }, // private - triggerBlur : function(){ - this.mimicing = false; - this.doc.un('mousedown', this.mimicBlur, this); - if(this.monitorTab && this.el){ - this.un('specialkey', this.checkTab, this); + onViewClick : function(doFocus){ + var index = this.view.getSelectedIndexes()[0], + s = this.store, + r = s.getAt(index); + if(r){ + this.onSelect(r, index); + }else { + this.collapse(); } - Ext.form.TriggerField.superclass.onBlur.call(this); - if(this.wrap){ - this.wrap.removeClass(this.wrapFocusClass); + if(doFocus !== false){ + this.el.focus(); } }, - beforeBlur : Ext.emptyFn, // private - // This should be overriden by any subclass that needs to check whether or not the field can be blurred. - validateBlur : function(e){ - return true; - }, - - /** - * The function that should handle the trigger's click event. This method does nothing by default - * until overridden by an implementing function. See Ext.form.ComboBox and Ext.form.DateField for - * sample implementations. - * @method - * @param {EventObject} e - */ - onTriggerClick : Ext.emptyFn + restrictHeight : function(){ + this.innerList.dom.style.height = ''; + var inner = this.innerList.dom, + pad = this.list.getFrameWidth('tb') + (this.resizable ? this.handleHeight : 0) + this.assetHeight, + h = Math.max(inner.clientHeight, inner.offsetHeight, inner.scrollHeight), + ha = this.getPosition()[1]-Ext.getBody().getScroll().top, + hb = Ext.lib.Dom.getViewHeight()-ha-this.getSize().height, + space = Math.max(ha, hb, this.minHeight || 0)-this.list.shadowOffset-pad-5; - /** - * @cfg {Boolean} grow @hide - */ - /** - * @cfg {Number} growMin @hide - */ - /** - * @cfg {Number} growMax @hide - */ -}); + h = Math.min(h, space, this.maxHeight); -/** - * @class Ext.form.TwinTriggerField - * @extends Ext.form.TriggerField - * TwinTriggerField is not a public class to be used directly. It is meant as an abstract base class - * to be extended by an implementing class. For an example of implementing this class, see the custom - * SearchField implementation here: - * http://extjs.com/deploy/ext/examples/form/custom.html - */ -Ext.form.TwinTriggerField = Ext.extend(Ext.form.TriggerField, { - /** - * @cfg {Mixed} triggerConfig - * A {@link Ext.DomHelper DomHelper} config object specifying the structure of the trigger elements - * for this Field. (Optional). - * Specify this when you need a customized element to contain the two trigger elements for this Field. - * Each trigger element must be marked by the CSS class x-form-trigger (also see - * {@link #trigger1Class} and {@link #trigger2Class}). - * Note that when using this option, it is the developer's responsibility to ensure correct sizing, - * positioning and appearance of the triggers. + this.innerList.setHeight(h); + this.list.beginUpdate(); + this.list.setHeight(h+pad); + this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign)); + this.list.endUpdate(); + }, + + /** + * Returns true if the dropdown list is expanded, else false. */ + isExpanded : function(){ + return this.list && this.list.isVisible(); + }, + /** - * @cfg {String} trigger1Class - * An additional CSS class used to style the trigger button. The trigger will always get the - * class 'x-form-trigger' by default and triggerClass will be appended if specified. + * Select an item in the dropdown list by its data value. This function does NOT cause the select event to fire. + * The store must be loaded and the list expanded for this function to work, otherwise use setValue. + * @param {String} value The data value of the item to select + * @param {Boolean} scrollIntoView False to prevent the dropdown list from autoscrolling to display the + * selected item if it is not currently in view (defaults to true) + * @return {Boolean} True if the value matched an item in the list, else false */ + selectByValue : function(v, scrollIntoView){ + if(!Ext.isEmpty(v, true)){ + var r = this.findRecord(this.valueField || this.displayField, v); + if(r){ + this.select(this.store.indexOf(r), scrollIntoView); + return true; + } + } + return false; + }, + /** - * @cfg {String} trigger2Class - * An additional CSS class used to style the trigger button. The trigger will always get the - * class 'x-form-trigger' by default and triggerClass will be appended if specified. + * Select an item in the dropdown list by its numeric index in the list. This function does NOT cause the select event to fire. + * The store must be loaded and the list expanded for this function to work, otherwise use setValue. + * @param {Number} index The zero-based index of the list item to select + * @param {Boolean} scrollIntoView False to prevent the dropdown list from autoscrolling to display the + * selected item if it is not currently in view (defaults to true) */ + select : function(index, scrollIntoView){ + this.selectedIndex = index; + this.view.select(index); + if(scrollIntoView !== false){ + var el = this.view.getNode(index); + if(el){ + this.innerList.scrollChildIntoView(el, false); + } + } - initComponent : function(){ - Ext.form.TwinTriggerField.superclass.initComponent.call(this); + }, - this.triggerConfig = { - tag:'span', cls:'x-form-twin-triggers', cn:[ - {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger1Class}, - {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger2Class} - ]}; + // private + selectNext : function(){ + var ct = this.store.getCount(); + if(ct > 0){ + if(this.selectedIndex == -1){ + this.select(0); + }else if(this.selectedIndex < ct-1){ + this.select(this.selectedIndex+1); + } + } }, - getTrigger : function(index){ - return this.triggers[index]; + // private + selectPrev : function(){ + var ct = this.store.getCount(); + if(ct > 0){ + if(this.selectedIndex == -1){ + this.select(0); + }else if(this.selectedIndex !== 0){ + this.select(this.selectedIndex-1); + } + } }, - initTrigger : function(){ - var ts = this.trigger.select('.x-form-trigger', true); - var triggerField = this; - ts.each(function(t, all, index){ - var triggerIndex = 'Trigger'+(index+1); - t.hide = function(){ - var w = triggerField.wrap.getWidth(); - this.dom.style.display = 'none'; - triggerField.el.setWidth(w-triggerField.trigger.getWidth()); - this['hidden' + triggerIndex] = true; - }; - t.show = function(){ - var w = triggerField.wrap.getWidth(); - this.dom.style.display = ''; - triggerField.el.setWidth(w-triggerField.trigger.getWidth()); - this['hidden' + triggerIndex] = false; - }; + // private + onKeyUp : function(e){ + var k = e.getKey(); + if(this.editable !== false && this.readOnly !== true && (k == e.BACKSPACE || !e.isSpecialKey())){ - if(this['hide'+triggerIndex]){ - t.dom.style.display = 'none'; - this['hidden' + triggerIndex] = true; - } - this.mon(t, 'click', this['on'+triggerIndex+'Click'], this, {preventDefault:true}); - t.addClassOnOver('x-form-trigger-over'); - t.addClassOnClick('x-form-trigger-click'); - }, this); - this.triggers = ts.elements; + this.lastKey = k; + this.dqTask.delay(this.queryDelay); + } + Ext.form.ComboBox.superclass.onKeyUp.call(this, e); }, - getTriggerWidth: function(){ - var tw = 0; - Ext.each(this.triggers, function(t, index){ - var triggerIndex = 'Trigger' + (index + 1), - w = t.getWidth(); - if(w === 0 && !this['hidden' + triggerIndex]){ - tw += this.defaultTriggerWidth; - }else{ - tw += w; - } - }, this); - return tw; + // private + validateBlur : function(){ + return !this.list || !this.list.isVisible(); }, // private - onDestroy : function() { - Ext.destroy(this.triggers); - Ext.form.TwinTriggerField.superclass.onDestroy.call(this); + initQuery : function(){ + this.doQuery(this.getRawValue()); }, - /** - * The function that should handle the trigger's click event. This method does nothing by default - * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick} - * for additional information. - * @method - * @param {EventObject} e - */ - onTrigger1Click : Ext.emptyFn, - /** - * The function that should handle the trigger's click event. This method does nothing by default - * until overridden by an implementing function. See {@link Ext.form.TriggerField#onTriggerClick} - * for additional information. - * @method - * @param {EventObject} e - */ - onTrigger2Click : Ext.emptyFn -}); -Ext.reg('trigger', Ext.form.TriggerField); -/** - * @class Ext.form.TextArea - * @extends Ext.form.TextField - * Multiline text field. Can be used as a direct replacement for traditional textarea fields, plus adds - * support for auto-sizing. - * @constructor - * Creates a new TextArea - * @param {Object} config Configuration options - * @xtype textarea - */ -Ext.form.TextArea = Ext.extend(Ext.form.TextField, { - /** - * @cfg {Number} growMin The minimum height to allow when {@link Ext.form.TextField#grow grow}=true - * (defaults to 60) - */ - growMin : 60, - /** - * @cfg {Number} growMax The maximum height to allow when {@link Ext.form.TextField#grow grow}=true - * (defaults to 1000) - */ - growMax: 1000, - growAppend : ' \n ', + // private + beforeBlur : function(){ + this.assertValue(); + }, - enterIsSpecial : false, + // private + postBlur : function(){ + Ext.form.ComboBox.superclass.postBlur.call(this); + this.collapse(); + this.inKeyMode = false; + }, /** - * @cfg {Boolean} preventScrollbars true to prevent scrollbars from appearing regardless of how much text is - * in the field. This option is only relevant when {@link #grow} is true. Equivalent to setting overflow: hidden, defaults to - * false. - */ - preventScrollbars: false, - /** - * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default - * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. - * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: - * {tag: "textarea", style: "width:100px;height:60px;", autocomplete: "off"} + * Execute a query to filter the dropdown list. Fires the {@link #beforequery} event prior to performing the + * query allowing the query action to be canceled if needed. + * @param {String} query The SQL query to execute + * @param {Boolean} forceAll true to force the query to execute even if there are currently fewer + * characters in the field than the minimum specified by the {@link #minChars} config option. It + * also clears any filter previously saved in the current store (defaults to false) */ - - // private - onRender : function(ct, position){ - if(!this.el){ - this.defaultAutoCreate = { - tag: "textarea", - style:"width:100px;height:60px;", - autocomplete: "off" - }; + doQuery : function(q, forceAll){ + q = Ext.isEmpty(q) ? '' : q; + var qe = { + query: q, + forceAll: forceAll, + combo: this, + cancel:false + }; + if(this.fireEvent('beforequery', qe)===false || qe.cancel){ + return false; } - Ext.form.TextArea.superclass.onRender.call(this, ct, position); - if(this.grow){ - this.textSizeEl = Ext.DomHelper.append(document.body, { - tag: "pre", cls: "x-form-grow-sizer" - }); - if(this.preventScrollbars){ - this.el.setStyle("overflow", "hidden"); + q = qe.query; + forceAll = qe.forceAll; + if(forceAll === true || (q.length >= this.minChars)){ + if(this.lastQuery !== q){ + this.lastQuery = q; + if(this.mode == 'local'){ + this.selectedIndex = -1; + if(forceAll){ + this.store.clearFilter(); + }else{ + this.store.filter(this.displayField, q); + } + this.onLoad(); + }else{ + this.store.baseParams[this.queryParam] = q; + this.store.load({ + params: this.getParams(q) + }); + this.expand(); + } + }else{ + this.selectedIndex = -1; + this.onLoad(); } - this.el.setHeight(this.growMin); } }, - onDestroy : function(){ - Ext.removeNode(this.textSizeEl); - Ext.form.TextArea.superclass.onDestroy.call(this); + // private + getParams : function(q){ + var p = {}; + //p[this.queryParam] = q; + if(this.pageSize){ + p.start = 0; + p.limit = this.pageSize; + } + return p; }, - fireKey : function(e){ - if(e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() != e.ENTER || e.hasModifier()))){ - this.fireEvent("specialkey", this, e); + /** + * Hides the dropdown list if it is currently expanded. Fires the {@link #collapse} event on completion. + */ + collapse : function(){ + if(!this.isExpanded()){ + return; } + this.list.hide(); + Ext.getDoc().un('mousewheel', this.collapseIf, this); + Ext.getDoc().un('mousedown', this.collapseIf, this); + this.fireEvent('collapse', this); }, - + // private - doAutoSize : function(e){ - return !e.isNavKeyPress() || e.getKey() == e.ENTER; + collapseIf : function(e){ + if(!this.isDestroyed && !e.within(this.wrap) && !e.within(this.list)){ + this.collapse(); + } }, /** - * Automatically grows the field to accomodate the height of the text up to the maximum field height allowed. - * This only takes effect if grow = true, and fires the {@link #autosize} event if the height changes. + * Expands the dropdown list if it is currently hidden. Fires the {@link #expand} event on completion. */ - autoSize: function(){ - if(!this.grow || !this.textSizeEl){ + expand : function(){ + if(this.isExpanded() || !this.hasFocus){ return; } - var el = this.el, - v = Ext.util.Format.htmlEncode(el.dom.value), - ts = this.textSizeEl, - h; - - Ext.fly(ts).setWidth(this.el.getWidth()); - if(v.length < 1){ - v = "  "; - }else{ - v += this.growAppend; - if(Ext.isIE){ - v = v.replace(/\n/g, ' '); + + if(this.title || this.pageSize){ + this.assetHeight = 0; + if(this.title){ + this.assetHeight += this.header.getHeight(); + } + if(this.pageSize){ + this.assetHeight += this.footer.getHeight(); } } - ts.innerHTML = v; - h = Math.min(this.growMax, Math.max(ts.offsetHeight, this.growMin)); - if(h != this.lastHeight){ - this.lastHeight = h; - this.el.setHeight(h); - this.fireEvent("autosize", this, h); - } - } -}); -Ext.reg('textarea', Ext.form.TextArea);/** - * @class Ext.form.NumberField - * @extends Ext.form.TextField - * Numeric text field that provides automatic keystroke filtering and numeric validation. - * @constructor - * Creates a new NumberField - * @param {Object} config Configuration options - * @xtype numberfield - */ -Ext.form.NumberField = Ext.extend(Ext.form.TextField, { - /** - * @cfg {RegExp} stripCharsRe @hide - */ - /** - * @cfg {RegExp} maskRe @hide - */ - /** - * @cfg {String} fieldClass The default CSS class for the field (defaults to "x-form-field x-form-num-field") - */ - fieldClass: "x-form-field x-form-num-field", - /** - * @cfg {Boolean} allowDecimals False to disallow decimal values (defaults to true) - */ - allowDecimals : true, - /** - * @cfg {String} decimalSeparator Character(s) to allow as the decimal separator (defaults to '.') - */ - decimalSeparator : ".", - /** - * @cfg {Number} decimalPrecision The maximum precision to display after the decimal separator (defaults to 2) - */ - decimalPrecision : 2, - /** - * @cfg {Boolean} allowNegative False to prevent entering a negative sign (defaults to true) - */ - allowNegative : true, - /** - * @cfg {Number} minValue The minimum allowed value (defaults to Number.NEGATIVE_INFINITY) - */ - minValue : Number.NEGATIVE_INFINITY, - /** - * @cfg {Number} maxValue The maximum allowed value (defaults to Number.MAX_VALUE) - */ - maxValue : Number.MAX_VALUE, - /** - * @cfg {String} minText Error text to display if the minimum value validation fails (defaults to "The minimum value for this field is {minValue}") - */ - minText : "The minimum value for this field is {0}", - /** - * @cfg {String} maxText Error text to display if the maximum value validation fails (defaults to "The maximum value for this field is {maxValue}") - */ - maxText : "The maximum value for this field is {0}", - /** - * @cfg {String} nanText Error text to display if the value is not a valid number. For example, this can happen - * if a valid character like '.' or '-' is left in the field with no number (defaults to "{value} is not a valid number") - */ - nanText : "{0} is not a valid number", - /** - * @cfg {String} baseChars The base set of characters to evaluate as valid numbers (defaults to '0123456789'). - */ - baseChars : "0123456789", - // private - initEvents : function(){ - var allowed = this.baseChars + ''; - if (this.allowDecimals) { - allowed += this.decimalSeparator; - } - if (this.allowNegative) { - allowed += '-'; + if(this.bufferSize){ + this.doResize(this.bufferSize); + delete this.bufferSize; } - this.maskRe = new RegExp('[' + Ext.escapeRe(allowed) + ']'); - Ext.form.NumberField.superclass.initEvents.call(this); - }, + this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign)); - // private - validateValue : function(value){ - if(!Ext.form.NumberField.superclass.validateValue.call(this, value)){ - return false; - } - if(value.length < 1){ // if it's blank and textfield didn't flag it then it's valid - return true; + // zindex can change, re-check it and set it if necessary + var listParent = Ext.getDom(this.getListParent() || Ext.getBody()), + zindex = parseInt(Ext.fly(listParent).getStyle('z-index') ,10); + if (!zindex){ + zindex = this.getParentZIndex(); } - value = String(value).replace(this.decimalSeparator, "."); - if(isNaN(value)){ - this.markInvalid(String.format(this.nanText, value)); - return false; - } - var num = this.parseValue(value); - if(num < this.minValue){ - this.markInvalid(String.format(this.minText, this.minValue)); - return false; + if (zindex) { + this.list.setZIndex(zindex + 5); } - if(num > this.maxValue){ - this.markInvalid(String.format(this.maxText, this.maxValue)); - return false; + this.list.show(); + if(Ext.isGecko2){ + this.innerList.setOverflow('auto'); // necessary for FF 2.0/Mac } - return true; - }, - - getValue : function(){ - return this.fixPrecision(this.parseValue(Ext.form.NumberField.superclass.getValue.call(this))); + this.mon(Ext.getDoc(), { + scope: this, + mousewheel: this.collapseIf, + mousedown: this.collapseIf + }); + this.fireEvent('expand', this); }, - setValue : function(v){ - v = Ext.isNumber(v) ? v : parseFloat(String(v).replace(this.decimalSeparator, ".")); - v = isNaN(v) ? '' : String(v).replace(".", this.decimalSeparator); - return Ext.form.NumberField.superclass.setValue.call(this, v); - }, - - /** - * Replaces any existing {@link #minValue} with the new value. - * @param {Number} value The minimum value - */ - setMinValue : function(value){ - this.minValue = Ext.num(value, Number.NEGATIVE_INFINITY); - }, - /** - * Replaces any existing {@link #maxValue} with the new value. - * @param {Number} value The maximum value + * @method onTriggerClick + * @hide */ - setMaxValue : function(value){ - this.maxValue = Ext.num(value, Number.MAX_VALUE); - }, - - // private - parseValue : function(value){ - value = parseFloat(String(value).replace(this.decimalSeparator, ".")); - return isNaN(value) ? '' : value; - }, - // private - fixPrecision : function(value){ - var nan = isNaN(value); - if(!this.allowDecimals || this.decimalPrecision == -1 || nan || !value){ - return nan ? '' : value; + // Implements the default empty TriggerField.onTriggerClick function + onTriggerClick : function(){ + if(this.readOnly || this.disabled){ + return; } - return parseFloat(parseFloat(value).toFixed(this.decimalPrecision)); - }, - - beforeBlur : function(){ - var v = this.parseValue(this.getRawValue()); - if(!Ext.isEmpty(v)){ - this.setValue(this.fixPrecision(v)); + if(this.isExpanded()){ + this.collapse(); + this.el.focus(); + }else { + this.onFocus({}); + if(this.triggerAction == 'all') { + this.doQuery(this.allQuery, true); + } else { + this.doQuery(this.getRawValue()); + } + this.el.focus(); } } -}); -Ext.reg('numberfield', Ext.form.NumberField);/** - * @class Ext.form.DateField - * @extends Ext.form.TriggerField - * Provides a date input field with a {@link Ext.DatePicker} dropdown and automatic date validation. - * @constructor - * Create a new DateField - * @param {Object} config - * @xtype datefield - */ -Ext.form.DateField = Ext.extend(Ext.form.TriggerField, { - /** - * @cfg {String} format - * The default date format string which can be overriden for localization support. The format must be - * valid according to {@link Date#parseDate} (defaults to 'm/d/Y'). - */ - format : "m/d/Y", + /** - * @cfg {String} altFormats - * Multiple date formats separated by "|" to try when parsing a user input value and it - * does not match the defined format (defaults to - * 'm/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d'). + * @hide + * @method autoSize */ - altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d", /** - * @cfg {String} disabledDaysText - * The tooltip to display when the date falls on a disabled day (defaults to 'Disabled') + * @cfg {Boolean} grow @hide */ - disabledDaysText : "Disabled", /** - * @cfg {String} disabledDatesText - * The tooltip text to display when the date falls on a disabled date (defaults to 'Disabled') + * @cfg {Number} growMin @hide */ - disabledDatesText : "Disabled", /** - * @cfg {String} minText - * The error text to display when the date in the cell is before {@link #minValue} (defaults to - * 'The date in this field must be after {minValue}'). + * @cfg {Number} growMax @hide */ - minText : "The date in this field must be equal to or after {0}", + +}); +Ext.reg('combo', Ext.form.ComboBox); +/** + * @class Ext.form.Checkbox + * @extends Ext.form.Field + * Single checkbox field. Can be used as a direct replacement for traditional checkbox fields. + * @constructor + * Creates a new Checkbox + * @param {Object} config Configuration options + * @xtype checkbox + */ +Ext.form.Checkbox = Ext.extend(Ext.form.Field, { /** - * @cfg {String} maxText - * The error text to display when the date in the cell is after {@link #maxValue} (defaults to - * 'The date in this field must be before {maxValue}'). + * @cfg {String} focusClass The CSS class to use when the checkbox receives focus (defaults to undefined) */ - maxText : "The date in this field must be equal to or before {0}", + focusClass : undefined, /** - * @cfg {String} invalidText - * The error text to display when the date in the field is invalid (defaults to - * '{value} is not a valid date - it must be in the format {format}'). + * @cfg {String} fieldClass The default CSS class for the checkbox (defaults to 'x-form-field') */ - invalidText : "{0} is not a valid date - it must be in the format {1}", + fieldClass : 'x-form-field', /** - * @cfg {String} triggerClass - * An additional CSS class used to style the trigger button. The trigger will always get the - * class 'x-form-trigger' and triggerClass will be appended if specified - * (defaults to 'x-form-date-trigger' which displays a calendar icon). + * @cfg {Boolean} checked true if the checkbox should render initially checked (defaults to false) */ - triggerClass : 'x-form-date-trigger', + checked : false, /** - * @cfg {Boolean} showToday - * false to hide the footer area of the DatePicker containing the Today button and disable - * the keyboard handler for spacebar that selects the current date (defaults to true). + * @cfg {String} boxLabel The text that appears beside the checkbox */ - showToday : true, + boxLabel: ' ', /** - * @cfg {Date/String} minValue - * The minimum allowed date. Can be either a Javascript date object or a string date in a - * valid format (defaults to null). + * @cfg {String/Object} autoCreate A DomHelper element spec, or true for a default element spec (defaults to + * {tag: 'input', type: 'checkbox', autocomplete: 'off'}) */ + defaultAutoCreate : { tag: 'input', type: 'checkbox', autocomplete: 'off'}, /** - * @cfg {Date/String} maxValue - * The maximum allowed date. Can be either a Javascript date object or a string date in a - * valid format (defaults to null). + * @cfg {String} boxLabel The text that appears beside the checkbox */ /** - * @cfg {Array} disabledDays - * An array of days to disable, 0 based (defaults to null). Some examples: -// disable Sunday and Saturday: -disabledDays: [0, 6] -// disable weekdays: -disabledDays: [1,2,3,4,5] - * + * @cfg {String} inputValue The value that should go into the generated input element's value attribute */ /** - * @cfg {Array} disabledDates - * An array of "dates" to disable, as strings. These strings will be used to build a dynamic regular - * expression so they are very powerful. Some examples: -// disable these exact dates: -disabledDates: ["03/08/2003", "09/16/2003"] -// disable these days for every year: -disabledDates: ["03/08", "09/16"] -// only match the beginning (useful if you are using short years): -disabledDates: ["^03/08"] -// disable every day in March 2006: -disabledDates: ["03/../2006"] -// disable every day in every March: -disabledDates: ["^03"] - * - * Note that the format of the dates included in the array should exactly match the {@link #format} config. - * In order to support regular expressions, if you are using a {@link #format date format} that has "." in - * it, you will have to escape the dot when restricting dates. For example: ["03\\.08\\.03"]. + * @cfg {Function} handler A function called when the {@link #checked} value changes (can be used instead of + * handling the check event). The handler is passed the following parameters: + * + * checkbox : Ext.form.CheckboxThe Checkbox being toggled. + * checked : BooleanThe new checked state of the checkbox. + * */ /** - * @cfg {String/Object} autoCreate - * A {@link Ext.DomHelper DomHelper element specification object}, or true for the default element - * specification object: - * autoCreate: {tag: "input", type: "text", size: "10", autocomplete: "off"} - * + * @cfg {Object} scope An object to use as the scope ('this' reference) of the {@link #handler} function + * (defaults to this Checkbox). */ // private - defaultAutoCreate : {tag: "input", type: "text", size: "10", autocomplete: "off"}, + actionMode : 'wrap', + // private initComponent : function(){ - Ext.form.DateField.superclass.initComponent.call(this); - + Ext.form.Checkbox.superclass.initComponent.call(this); this.addEvents( /** - * @event select - * Fires when a date is selected via the date picker. - * @param {Ext.form.DateField} this - * @param {Date} date The date that was selected + * @event check + * Fires when the checkbox is checked or unchecked. + * @param {Ext.form.Checkbox} this This checkbox + * @param {Boolean} checked The new checked value */ - 'select' + 'check' ); + }, - if(Ext.isString(this.minValue)){ - this.minValue = this.parseDate(this.minValue); - } - if(Ext.isString(this.maxValue)){ - this.maxValue = this.parseDate(this.maxValue); + // private + onResize : function(){ + Ext.form.Checkbox.superclass.onResize.apply(this, arguments); + if(!this.boxLabel && !this.fieldLabel){ + this.el.alignTo(this.wrap, 'c-c'); } - this.disabledDatesRE = null; - this.initDisabledDays(); }, - - initEvents: function() { - Ext.form.DateField.superclass.initEvents.call(this); - this.keyNav = new Ext.KeyNav(this.el, { - "down": function(e) { - this.onTriggerClick(); - }, + + // private + initEvents : function(){ + Ext.form.Checkbox.superclass.initEvents.call(this); + this.mon(this.el, { scope: this, - forceKeyDown: true + click: this.onClick, + change: this.onClick }); }, + /** + * @hide + * Overridden and disabled. The editor element does not support standard valid/invalid marking. + * @method + */ + markInvalid : Ext.emptyFn, + /** + * @hide + * Overridden and disabled. The editor element does not support standard valid/invalid marking. + * @method + */ + clearInvalid : Ext.emptyFn, // private - initDisabledDays : function(){ - if(this.disabledDates){ - var dd = this.disabledDates, - len = dd.length - 1, - re = "(?:"; - - Ext.each(dd, function(d, i){ - re += Ext.isDate(d) ? '^' + Ext.escapeRe(d.dateFormat(this.format)) + '$' : dd[i]; - if(i != len){ - re += '|'; - } - }, this); - this.disabledDatesRE = new RegExp(re + ')'); + onRender : function(ct, position){ + Ext.form.Checkbox.superclass.onRender.call(this, ct, position); + if(this.inputValue !== undefined){ + this.el.dom.value = this.inputValue; + } + this.wrap = this.el.wrap({cls: 'x-form-check-wrap'}); + if(this.boxLabel){ + this.wrap.createChild({tag: 'label', htmlFor: this.el.id, cls: 'x-form-cb-label', html: this.boxLabel}); + } + if(this.checked){ + this.setValue(true); + }else{ + this.checked = this.el.dom.checked; } + // Need to repaint for IE, otherwise positioning is broken + if(Ext.isIE){ + this.wrap.repaint(); + } + this.resizeEl = this.positionEl = this.wrap; }, - /** - * Replaces any existing disabled dates with new values and refreshes the DatePicker. - * @param {Array} disabledDates An array of date strings (see the {@link #disabledDates} config - * for details on supported values) used to disable a pattern of dates. - */ - setDisabledDates : function(dd){ - this.disabledDates = dd; - this.initDisabledDays(); - if(this.menu){ - this.menu.picker.setDisabledDates(this.disabledDatesRE); - } + // private + onDestroy : function(){ + Ext.destroy(this.wrap); + Ext.form.Checkbox.superclass.onDestroy.call(this); + }, + + // private + initValue : function() { + this.originalValue = this.getValue(); }, /** - * Replaces any existing disabled days (by index, 0-6) with new values and refreshes the DatePicker. - * @param {Array} disabledDays An array of disabled day indexes. See the {@link #disabledDays} - * config for details on supported values. + * Returns the checked state of the checkbox. + * @return {Boolean} True if checked, else false */ - setDisabledDays : function(dd){ - this.disabledDays = dd; - if(this.menu){ - this.menu.picker.setDisabledDays(dd); + getValue : function(){ + if(this.rendered){ + return this.el.dom.checked; } + return this.checked; }, - /** - * Replaces any existing {@link #minValue} with the new value and refreshes the DatePicker. - * @param {Date} value The minimum date that can be selected - */ - setMinValue : function(dt){ - this.minValue = (Ext.isString(dt) ? this.parseDate(dt) : dt); - if(this.menu){ - this.menu.picker.setMinDate(this.minValue); + // private + onClick : function(){ + if(this.el.dom.checked != this.checked){ + this.setValue(this.el.dom.checked); } }, /** - * Replaces any existing {@link #maxValue} with the new value and refreshes the DatePicker. - * @param {Date} value The maximum date that can be selected + * Sets the checked state of the checkbox, fires the 'check' event, and calls a + * {@link #handler} (if configured). + * @param {Boolean/String} checked The following values will check the checkbox: + * true, 'true', '1', or 'on'. Any other value will uncheck the checkbox. + * @return {Ext.form.Field} this */ - setMaxValue : function(dt){ - this.maxValue = (Ext.isString(dt) ? this.parseDate(dt) : dt); - if(this.menu){ - this.menu.picker.setMaxDate(this.maxValue); + setValue : function(v){ + var checked = this.checked ; + this.checked = (v === true || v === 'true' || v == '1' || String(v).toLowerCase() == 'on'); + if(this.rendered){ + this.el.dom.checked = this.checked; + this.el.dom.defaultChecked = this.checked; + } + if(checked != this.checked){ + this.fireEvent('check', this, this.checked); + if(this.handler){ + this.handler.call(this.scope || this, this, this.checked); + } } + return this; + } +}); +Ext.reg('checkbox', Ext.form.Checkbox); +/** + * @class Ext.form.CheckboxGroup + * @extends Ext.form.Field + * A grouping container for {@link Ext.form.Checkbox} controls. + * Sample usage: + * +var myCheckboxGroup = new Ext.form.CheckboxGroup({ + id:'myGroup', + xtype: 'checkboxgroup', + fieldLabel: 'Single Column', + itemCls: 'x-check-group-alt', + // Put all controls in a single column with width 100% + columns: 1, + items: [ + {boxLabel: 'Item 1', name: 'cb-col-1'}, + {boxLabel: 'Item 2', name: 'cb-col-2', checked: true}, + {boxLabel: 'Item 3', name: 'cb-col-3'} + ] +}); + * + * @constructor + * Creates a new CheckboxGroup + * @param {Object} config Configuration options + * @xtype checkboxgroup + */ +Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, { + /** + * @cfg {Array} items An Array of {@link Ext.form.Checkbox Checkbox}es or Checkbox config objects + * to arrange in the group. + */ + /** + * @cfg {String/Number/Array} columns Specifies the number of columns to use when displaying grouped + * checkbox/radio controls using automatic layout. This config can take several types of values: + * 'auto' : The controls will be rendered one per column on one row and the width + * of each column will be evenly distributed based on the width of the overall field container. This is the default. + * Number : If you specific a number (e.g., 3) that number of columns will be + * created and the contained controls will be automatically distributed based on the value of {@link #vertical}. + * Array : ObjectYou can also specify an array of column widths, mixing integer + * (fixed width) and float (percentage width) values as needed (e.g., [100, .25, .75]). Any integer values will + * be rendered first, then any float values will be calculated as a percentage of the remaining space. Float + * values do not have to add up to 1 (100%) although if you want the controls to take up the entire field + * container you should do so. + */ + columns : 'auto', + /** + * @cfg {Boolean} vertical True to distribute contained controls across columns, completely filling each column + * top to bottom before starting on the next column. The number of controls in each column will be automatically + * calculated to keep columns as even as possible. The default value is false, so that controls will be added + * to columns one at a time, completely filling each row left to right before starting on the next row. + */ + vertical : false, + /** + * @cfg {Boolean} allowBlank False to validate that at least one item in the group is checked (defaults to true). + * If no items are selected at validation time, {@link @blankText} will be used as the error text. + */ + allowBlank : true, + /** + * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails (defaults to "You must + * select at least one item in this group") + */ + blankText : "You must select at least one item in this group", + + // private + defaultType : 'checkbox', + + // private + groupCls : 'x-form-check-group', + + // private + initComponent: function(){ + this.addEvents( + /** + * @event change + * Fires when the state of a child checkbox changes. + * @param {Ext.form.CheckboxGroup} this + * @param {Array} checked An array containing the checked boxes. + */ + 'change' + ); + this.on('change', this.validate, this); + Ext.form.CheckboxGroup.superclass.initComponent.call(this); }, // private - validateValue : function(value){ - value = this.formatDate(value); - if(!Ext.form.DateField.superclass.validateValue.call(this, value)){ - return false; - } - if(value.length < 1){ // if it's blank and textfield didn't flag it then it's valid - return true; - } - var svalue = value; - value = this.parseDate(value); - if(!value){ - this.markInvalid(String.format(this.invalidText, svalue, this.format)); - return false; - } - var time = value.getTime(); - if(this.minValue && time < this.minValue.getTime()){ - this.markInvalid(String.format(this.minText, this.formatDate(this.minValue))); - return false; - } - if(this.maxValue && time > this.maxValue.getTime()){ - this.markInvalid(String.format(this.maxText, this.formatDate(this.maxValue))); - return false; - } - if(this.disabledDays){ - var day = value.getDay(); - for(var i = 0; i < this.disabledDays.length; i++) { - if(day === this.disabledDays[i]){ - this.markInvalid(this.disabledDaysText); - return false; + onRender : function(ct, position){ + if(!this.el){ + var panelCfg = { + autoEl: { + id: this.id + }, + cls: this.groupCls, + layout: 'column', + renderTo: ct, + bufferResize: false // Default this to false, since it doesn't really have a proper ownerCt. + }; + var colCfg = { + xtype: 'container', + defaultType: this.defaultType, + layout: 'form', + defaults: { + hideLabel: true, + anchor: '100%' + } + }; + + if(this.items[0].items){ + + // The container has standard ColumnLayout configs, so pass them in directly + + Ext.apply(panelCfg, { + layoutConfig: {columns: this.items.length}, + defaults: this.defaults, + items: this.items + }); + for(var i=0, len=this.items.length; i0 && i%rows==0){ + ri++; + } + if(this.items[i].fieldLabel){ + this.items[i].hideLabel = false; + } + cols[ri].items.push(this.items[i]); + }; + }else{ + for(var i=0, len=this.items.length; i{@link #format} as the date format, according - * to the same rules as {@link Date#parseDate} (the default format used is "m/d/Y"). - * Usage: - * -//All of these calls set the same date value (May 4, 2006) - -//Pass a date object: -var dt = new Date('5/4/2006'); -dateField.setValue(dt); - -//Pass a date string (default format): -dateField.setValue('05/04/2006'); - -//Pass a date string (custom format): -dateField.format = 'Y-m-d'; -dateField.setValue('2006-05-04'); - - * @param {String/Date} date The date or valid date string - * @return {Ext.form.Field} this + * Runs CheckboxGroup's validations and returns an array of any errors. The only error by default + * is if allowBlank is set to true and no items are checked. + * @return {Array} Array of all validation errors */ - setValue : function(date){ - return Ext.form.DateField.superclass.setValue.call(this, this.formatDate(this.parseDate(date))); + getErrors: function() { + var errors = Ext.form.CheckboxGroup.superclass.getErrors.apply(this, arguments); + + if (!this.allowBlank) { + var blank = true; + + this.eachItem(function(f){ + if (f.checked) { + return (blank = false); + } + }); + + if (blank) errors.push(this.blankText); + } + + return errors; }, // private - parseDate : function(value){ - if(!value || Ext.isDate(value)){ - return value; + isDirty: function(){ + //override the behaviour to check sub items. + if (this.disabled || !this.rendered) { + return false; } - var v = Date.parseDate(value, this.format); - if(!v && this.altFormats){ - if(!this.altFormatsArray){ - this.altFormatsArray = this.altFormats.split("|"); - } - for(var i = 0, len = this.altFormatsArray.length; i < len && !v; i++){ - v = Date.parseDate(value, this.altFormatsArray[i]); + + var dirty = false; + + this.eachItem(function(item){ + if(item.isDirty()){ + dirty = true; + return false; } - } - return v; + }); + + return dirty; }, // private - onDestroy : function(){ - Ext.destroy(this.menu, this.keyNav); - Ext.form.DateField.superclass.onDestroy.call(this); + setReadOnly : function(readOnly){ + if(this.rendered){ + this.eachItem(function(item){ + item.setReadOnly(readOnly); + }); + } + this.readOnly = readOnly; }, // private - formatDate : function(date){ - return Ext.isDate(date) ? date.dateFormat(this.format) : date; + onDisable : function(){ + this.eachItem(function(item){ + item.disable(); + }); }, - /** - * @method onTriggerClick - * @hide - */ // private - // Implements the default empty TriggerField.onTriggerClick function to display the DatePicker - onTriggerClick : function(){ - if(this.disabled){ - return; - } - if(this.menu == null){ - this.menu = new Ext.menu.DateMenu({ - hideOnClick: false, - focusOnSelect: false - }); - } - this.onFocus(); - Ext.apply(this.menu.picker, { - minDate : this.minValue, - maxDate : this.maxValue, - disabledDatesRE : this.disabledDatesRE, - disabledDatesText : this.disabledDatesText, - disabledDays : this.disabledDays, - disabledDaysText : this.disabledDaysText, - format : this.format, - showToday : this.showToday, - minText : String.format(this.minText, this.formatDate(this.minValue)), - maxText : String.format(this.maxText, this.formatDate(this.maxValue)) + onEnable : function(){ + this.eachItem(function(item){ + item.enable(); }); - this.menu.picker.setValue(this.getValue() || new Date()); - this.menu.show(this.el, "tl-bl?"); - this.menuEvents('on'); - }, - - //private - menuEvents: function(method){ - this.menu[method]('select', this.onSelect, this); - this.menu[method]('hide', this.onMenuHide, this); - this.menu[method]('show', this.onFocus, this); - }, - - onSelect: function(m, d){ - this.setValue(d); - this.fireEvent('select', this, d); - this.menu.hide(); - }, - - onMenuHide: function(){ - this.focus(false, 60); - this.menuEvents('un'); }, // private - beforeBlur : function(){ - var v = this.parseDate(this.getRawValue()); - if(v){ - this.setValue(v); + onResize : function(w, h){ + this.panel.setSize(w, h); + this.panel.doLayout(); + }, + + // inherit docs from Field + reset : function(){ + if (this.originalValue) { + // Clear all items + this.eachItem(function(c){ + if(c.setValue){ + c.setValue(false); + c.originalValue = c.getValue(); + } + }); + // Set items stored in originalValue, ugly - set a flag to reset the originalValue + // during the horrible onSetValue. This will allow trackResetOnLoad to function. + this.resetOriginal = true; + this.setValue(this.originalValue); + delete this.resetOriginal; + } else { + this.eachItem(function(c){ + if(c.reset){ + c.reset(); + } + }); } - } + // Defer the clearInvalid so if BaseForm's collection is being iterated it will be called AFTER it is complete. + // Important because reset is being called on both the group and the individual items. + (function() { + this.clearInvalid(); + }).defer(50, this); + }, /** - * @cfg {Boolean} grow @hide - */ - /** - * @cfg {Number} growMin @hide - */ - /** - * @cfg {Number} growMax @hide + * {@link Ext.form.Checkbox#setValue Set the value(s)} of an item or items + * in the group. Examples illustrating how this method may be called: + * +// call with name and value +myCheckboxGroup.setValue('cb-col-1', true); +// call with an array of boolean values +myCheckboxGroup.setValue([true, false, false]); +// call with an object literal specifying item:value pairs +myCheckboxGroup.setValue({ + 'cb-col-2': false, + 'cb-col-3': true +}); +// use comma separated string to set items with name to true (checked) +myCheckboxGroup.setValue('cb-col-1,cb-col-3'); + * + * See {@link Ext.form.Checkbox#setValue} for additional information. + * @param {Mixed} id The checkbox to check, or as described by example shown. + * @param {Boolean} value (optional) The value to set the item. + * @return {Ext.form.CheckboxGroup} this */ + setValue: function(){ + if(this.rendered){ + this.onSetValue.apply(this, arguments); + }else{ + this.buffered = true; + this.value = arguments; + } + return this; + }, + /** - * @hide - * @method autoSize + * @private + * Sets the values of one or more of the items within the CheckboxGroup + * @param {String|Array|Object} id Can take multiple forms. Can be optionally: + * + * An ID string to be used with a second argument + * An array of the form ['some', 'list', 'of', 'ids', 'to', 'mark', 'checked'] + * An array in the form [true, true, false, true, false] etc, where each item relates to the check status of + * the checkbox at the same index + * An object containing ids of the checkboxes as keys and check values as properties + * + * @param {String} value The value to set the field to if the first argument was a string */ -}); -Ext.reg('datefield', Ext.form.DateField);/** - * @class Ext.form.DisplayField - * @extends Ext.form.Field - * A display-only text field which is not validated and not submitted. - * @constructor - * Creates a new DisplayField. - * @param {Object} config Configuration options - * @xtype displayfield - */ -Ext.form.DisplayField = Ext.extend(Ext.form.Field, { - validationEvent : false, - validateOnBlur : false, - defaultAutoCreate : {tag: "div"}, - /** - * @cfg {String} fieldClass The default CSS class for the field (defaults to "x-form-display-field") - */ - fieldClass : "x-form-display-field", - /** - * @cfg {Boolean} htmlEncode false to skip HTML-encoding the text when rendering it (defaults to - * false). This might be useful if you want to include tags in the field's innerHTML rather than - * rendering them as string literals per the default logic. - */ - htmlEncode: false, - - // private - initEvents : Ext.emptyFn, - - isValid : function(){ - return true; - }, - - validate : function(){ - return true; - }, - - getRawValue : function(){ - var v = this.rendered ? this.el.dom.innerHTML : Ext.value(this.value, ''); - if(v === this.emptyText){ - v = ''; - } - if(this.htmlEncode){ - v = Ext.util.Format.htmlDecode(v); - } - return v; - }, - - getValue : function(){ - return this.getRawValue(); - }, - - getName: function() { - return this.name; - }, - - setRawValue : function(v){ - if(this.htmlEncode){ - v = Ext.util.Format.htmlEncode(v); - } - return this.rendered ? (this.el.dom.innerHTML = (Ext.isEmpty(v) ? '' : v)) : (this.value = v); - }, - - setValue : function(v){ - this.setRawValue(v); - return this; - } - /** - * @cfg {String} inputType - * @hide - */ - /** - * @cfg {Boolean} disabled - * @hide - */ - /** - * @cfg {Boolean} readOnly - * @hide - */ - /** - * @cfg {Boolean} validateOnBlur - * @hide - */ - /** - * @cfg {Number} validationDelay - * @hide - */ - /** - * @cfg {String/Boolean} validationEvent - * @hide - */ -}); - -Ext.reg('displayfield', Ext.form.DisplayField); -/** - * @class Ext.form.ComboBox - * @extends Ext.form.TriggerField - * A combobox control with support for autocomplete, remote-loading, paging and many other features. - * A ComboBox works in a similar manner to a traditional HTML <select> field. The difference is - * that to submit the {@link #valueField}, you must specify a {@link #hiddenName} to create a hidden input - * field to hold the value of the valueField. The {@link #displayField} is shown in the text field - * which is named according to the {@link #name}. - * Events - * To do something when something in ComboBox is selected, configure the select event: -var cb = new Ext.form.ComboBox({ - // all of your config options - listeners:{ - scope: yourScope, - 'select': yourFunction - } -}); + onSetValue: function(id, value){ + if(arguments.length == 1){ + if(Ext.isArray(id)){ + Ext.each(id, function(val, idx){ + if (Ext.isObject(val) && val.setValue){ // array of checkbox components to be checked + val.setValue(true); + if (this.resetOriginal === true) { + val.originalValue = val.getValue(); + } + } else { // an array of boolean values + var item = this.items.itemAt(idx); + if(item){ + item.setValue(val); + } + } + }, this); + }else if(Ext.isObject(id)){ + // set of name/value pairs + for(var i in id){ + var f = this.getBox(i); + if(f){ + f.setValue(id[i]); + } + } + }else{ + this.setValueForItem(id); + } + }else{ + var f = this.getBox(id); + if(f){ + f.setValue(value); + } + } + }, -// Alternatively, you can assign events after the object is created: -var cb = new Ext.form.ComboBox(yourOptions); -cb.on('select', yourFunction, yourScope); - * - * - * ComboBox in Grid - * If using a ComboBox in an {@link Ext.grid.EditorGridPanel Editor Grid} a {@link Ext.grid.Column#renderer renderer} - * will be needed to show the displayField when the editor is not active. Set up the renderer manually, or implement - * a reusable render, for example: -// create reusable renderer -Ext.util.Format.comboRenderer = function(combo){ - return function(value){ - var record = combo.findRecord(combo.{@link #valueField}, value); - return record ? record.get(combo.{@link #displayField}) : combo.{@link #valueNotFoundText}; - } -} + // private + beforeDestroy: function(){ + Ext.destroy(this.panel); + Ext.form.CheckboxGroup.superclass.beforeDestroy.call(this); -// create the combo instance -var combo = new Ext.form.ComboBox({ - {@link #typeAhead}: true, - {@link #triggerAction}: 'all', - {@link #lazyRender}:true, - {@link #mode}: 'local', - {@link #store}: new Ext.data.ArrayStore({ - id: 0, - fields: [ - 'myId', - 'displayText' - ], - data: [[1, 'item1'], [2, 'item2']] - }), - {@link #valueField}: 'myId', - {@link #displayField}: 'displayText' -}); + }, -// snippet of column model used within grid -var cm = new Ext.grid.ColumnModel([{ - ... - },{ - header: "Some Header", - dataIndex: 'whatever', - width: 130, - editor: combo, // specify reference to combo instance - renderer: Ext.util.Format.comboRenderer(combo) // pass combo instance to reusable renderer + setValueForItem : function(val){ + val = String(val).split(','); + this.eachItem(function(item){ + if(val.indexOf(item.inputValue)> -1){ + item.setValue(true); + } + }); }, - ... -]); - * - * - * Filtering - * A ComboBox {@link #doQuery uses filtering itself}, for information about filtering the ComboBox - * store manually see {@link #lastQuery}. - * @constructor - * Create a new ComboBox. - * @param {Object} config Configuration options - * @xtype combo - */ -Ext.form.ComboBox = Ext.extend(Ext.form.TriggerField, { - /** - * @cfg {Mixed} transform The id, DOM node or element of an existing HTML SELECT to convert to a ComboBox. - * Note that if you specify this and the combo is going to be in an {@link Ext.form.BasicForm} or - * {@link Ext.form.FormPanel}, you must also set {@link #lazyRender} = true. - */ - /** - * @cfg {Boolean} lazyRender true to prevent the ComboBox from rendering until requested - * (should always be used when rendering into an {@link Ext.Editor} (e.g. {@link Ext.grid.EditorGridPanel Grids}), - * defaults to false). - */ - /** - * @cfg {String/Object} autoCreate A {@link Ext.DomHelper DomHelper} element spec, or true for a default - * element spec. Used to create the {@link Ext.Component#getEl Element} which will encapsulate this Component. - * See {@link Ext.Component#autoEl autoEl} for details. Defaults to: - * {tag: "input", type: "text", size: "24", autocomplete: "off"} - */ - /** - * @cfg {Ext.data.Store/Array} store The data source to which this combo is bound (defaults to undefined). - * Acceptable values for this property are: - * - * any {@link Ext.data.Store Store} subclass - * an Array : Arrays will be converted to a {@link Ext.data.ArrayStore} internally, - * automatically generating {@link Ext.data.Field#name field names} to work with all data components. - * - * 1-dimensional array : (e.g., ['Foo','Bar']) - * A 1-dimensional array will automatically be expanded (each array item will be used for both the combo - * {@link #valueField} and {@link #displayField}) - * 2-dimensional array : (e.g., [['f','Foo'],['b','Bar']]) - * For a multi-dimensional array, the value in index 0 of each item will be assumed to be the combo - * {@link #valueField}, while the value at index 1 is assumed to be the combo {@link #displayField}. - * - * See also {@link #mode}. - */ - /** - * @cfg {String} title If supplied, a header element is created containing this text and added into the top of - * the dropdown list (defaults to undefined, with no header element) - */ // private - defaultAutoCreate : {tag: "input", type: "text", size: "24", autocomplete: "off"}, - /** - * @cfg {Number} listWidth The width (used as a parameter to {@link Ext.Element#setWidth}) of the dropdown - * list (defaults to the width of the ComboBox field). See also {@link #minListWidth} - */ - /** - * @cfg {String} displayField The underlying {@link Ext.data.Field#name data field name} to bind to this - * ComboBox (defaults to undefined if {@link #mode} = 'remote' or 'field1' if - * {@link #transform transforming a select} or if the {@link #store field name is autogenerated based on - * the store configuration}). - * See also {@link #valueField}. - * Note: if using a ComboBox in an {@link Ext.grid.EditorGridPanel Editor Grid} a - * {@link Ext.grid.Column#renderer renderer} will be needed to show the displayField when the editor is not - * active. - */ - /** - * @cfg {String} valueField The underlying {@link Ext.data.Field#name data value name} to bind to this - * ComboBox (defaults to undefined if {@link #mode} = 'remote' or 'field2' if - * {@link #transform transforming a select} or if the {@link #store field name is autogenerated based on - * the store configuration}). - * Note: use of a valueField requires the user to make a selection in order for a value to be - * mapped. See also {@link #hiddenName}, {@link #hiddenValue}, and {@link #displayField}. - */ - /** - * @cfg {String} hiddenName If specified, a hidden form field with this name is dynamically generated to store the - * field's data value (defaults to the underlying DOM element's name). Required for the combo's value to automatically - * post during a form submission. See also {@link #valueField}. - * Note: the hidden field's id will also default to this name if {@link #hiddenId} is not specified. - * The ComboBox {@link Ext.Component#id id} and the {@link #hiddenId} should be different, since - * no two DOM nodes should share the same id. So, if the ComboBox {@link Ext.form.Field#name name} and - * hiddenName are the same, you should specify a unique {@link #hiddenId}. - */ - /** - * @cfg {String} hiddenId If {@link #hiddenName} is specified, hiddenId can also be provided - * to give the hidden field a unique id (defaults to the {@link #hiddenName}). The hiddenId - * and combo {@link Ext.Component#id id} should be different, since no two DOM - * nodes should share the same id. - */ - /** - * @cfg {String} hiddenValue Sets the initial value of the hidden field if {@link #hiddenName} is - * specified to contain the selected {@link #valueField}, from the Store. Defaults to the configured - * {@link Ext.form.Field#value value}. - */ - /** - * @cfg {String} listClass The CSS class to add to the predefined 'x-combo-list' class - * applied the dropdown list element (defaults to ''). - */ - listClass : '', - /** - * @cfg {String} selectedClass CSS class to apply to the selected item in the dropdown list - * (defaults to 'x-combo-selected') - */ - selectedClass : 'x-combo-selected', - /** - * @cfg {String} listEmptyText The empty text to display in the data view if no items are found. - * (defaults to '') - */ - listEmptyText: '', - /** - * @cfg {String} triggerClass An additional CSS class used to style the trigger button. The trigger will always - * get the class 'x-form-trigger' and triggerClass will be appended if specified - * (defaults to 'x-form-arrow-trigger' which displays a downward arrow icon). - */ - triggerClass : 'x-form-arrow-trigger', - /** - * @cfg {Boolean/String} shadow true or "sides" for the default effect, "frame" for - * 4-way shadow, and "drop" for bottom-right - */ - shadow : 'sides', - /** - * @cfg {String/Array} listAlign A valid anchor position value. See {@link Ext.Element#alignTo} for details - * on supported anchor positions and offsets. To specify x/y offsets as well, this value - * may be specified as an Array of {@link Ext.Element#alignTo} method arguments. - * [ 'tl-bl?', [6,0] ] (defaults to 'tl-bl?') - */ - listAlign : 'tl-bl?', - /** - * @cfg {Number} maxHeight The maximum height in pixels of the dropdown list before scrollbars are shown - * (defaults to 300) - */ - maxHeight : 300, - /** - * @cfg {Number} minHeight The minimum height in pixels of the dropdown list when the list is constrained by its - * distance to the viewport edges (defaults to 90) - */ - minHeight : 90, - /** - * @cfg {String} triggerAction The action to execute when the trigger is clicked. - * - * 'query' : Default - * {@link #doQuery run the query} using the {@link Ext.form.Field#getRawValue raw value}. - * 'all' : - * {@link #doQuery run the query} specified by the {@link #allQuery} config option - * - * See also {@link #queryParam}. - */ - triggerAction : 'query', - /** - * @cfg {Number} minChars The minimum number of characters the user must type before autocomplete and - * {@link #typeAhead} activate (defaults to 4 if {@link #mode} = 'remote' or 0 if - * {@link #mode} = 'local', does not apply if - * {@link Ext.form.TriggerField#editable editable} = false). - */ - minChars : 4, - /** - * @cfg {Boolean} autoSelect true to select the first result gathered by the data store (defaults - * to true). A false value would require a manual selection from the dropdown list to set the components value - * unless the value of ({@link #typeAheadDelay}) were true. - */ - autoSelect : true, - /** - * @cfg {Boolean} typeAhead true to populate and autoselect the remainder of the text being - * typed after a configurable delay ({@link #typeAheadDelay}) if it matches a known value (defaults - * to false) - */ - typeAhead : false, - /** - * @cfg {Number} queryDelay The length of time in milliseconds to delay between the start of typing and - * sending the query to filter the dropdown list (defaults to 500 if {@link #mode} = 'remote' - * or 10 if {@link #mode} = 'local') - */ - queryDelay : 500, - /** - * @cfg {Number} pageSize If greater than 0, a {@link Ext.PagingToolbar} is displayed in the - * footer of the dropdown list and the {@link #doQuery filter queries} will execute with page start and - * {@link Ext.PagingToolbar#pageSize limit} parameters. Only applies when {@link #mode} = 'remote' - * (defaults to 0). - */ - pageSize : 0, - /** - * @cfg {Boolean} selectOnFocus true to select any existing text in the field immediately on focus. - * Only applies when {@link Ext.form.TriggerField#editable editable} = true (defaults to - * false). - */ - selectOnFocus : false, - /** - * @cfg {String} queryParam Name of the query ({@link Ext.data.Store#baseParam baseParam} name for the store) - * as it will be passed on the querystring (defaults to 'query') - */ - queryParam : 'query', - /** - * @cfg {String} loadingText The text to display in the dropdown list while data is loading. Only applies - * when {@link #mode} = 'remote' (defaults to 'Loading...') - */ - loadingText : 'Loading...', - /** - * @cfg {Boolean} resizable true to add a resize handle to the bottom of the dropdown list - * (creates an {@link Ext.Resizable} with 'se' {@link Ext.Resizable#pinned pinned} handles). - * Defaults to false. - */ - resizable : false, - /** - * @cfg {Number} handleHeight The height in pixels of the dropdown list resize handle if - * {@link #resizable} = true (defaults to 8) - */ - handleHeight : 8, - /** - * @cfg {String} allQuery The text query to send to the server to return all records for the list - * with no filtering (defaults to '') - */ - allQuery: '', + getBox : function(id){ + var box = null; + this.eachItem(function(f){ + if(id == f || f.dataIndex == id || f.id == id || f.getName() == id){ + box = f; + return false; + } + }); + return box; + }, + /** - * @cfg {String} mode Acceptable values are: - * - * 'remote' : Default - * Automatically loads the {@link #store} the first time the trigger - * is clicked. If you do not want the store to be automatically loaded the first time the trigger is - * clicked, set to 'local' and manually load the store. To force a requery of the store - * every time the trigger is clicked see {@link #lastQuery}. - * 'local' : - * ComboBox loads local data - * -var combo = new Ext.form.ComboBox({ - renderTo: document.body, - mode: 'local', - store: new Ext.data.ArrayStore({ - id: 0, - fields: [ - 'myId', // numeric value is the key - 'displayText' - ], - data: [[1, 'item1'], [2, 'item2']] // data is local - }), - valueField: 'myId', - displayField: 'displayText', - triggerAction: 'all' -}); - * - * + * Gets an array of the selected {@link Ext.form.Checkbox} in the group. + * @return {Array} An array of the selected checkboxes. */ - mode: 'remote', + getValue : function(){ + var out = []; + this.eachItem(function(item){ + if(item.checked){ + out.push(item); + } + }); + return out; + }, + /** - * @cfg {Number} minListWidth The minimum width of the dropdown list in pixels (defaults to 70, will - * be ignored if {@link #listWidth} has a higher value) + * @private + * Convenience function which passes the given function to every item in the composite + * @param {Function} fn The function to call + * @param {Object} scope Optional scope object */ - minListWidth : 70, + eachItem: function(fn, scope) { + if(this.items && this.items.each){ + this.items.each(fn, scope || this); + } + }, + /** - * @cfg {Boolean} forceSelection true to restrict the selected value to one of the values in the list, - * false to allow the user to set arbitrary text into the field (defaults to false) + * @cfg {String} name + * @hide */ - forceSelection : false, + /** - * @cfg {Number} typeAheadDelay The length of time in milliseconds to wait until the typeahead text is displayed - * if {@link #typeAhead} = true (defaults to 250) + * @method getRawValue + * @hide */ - typeAheadDelay : 250, + getRawValue : Ext.emptyFn, + /** - * @cfg {String} valueNotFoundText When using a name/value combo, if the value passed to setValue is not found in - * the store, valueNotFoundText will be displayed as the field text if defined (defaults to undefined). If this - * default text is used, it means there is no value set and no validation will occur on this field. + * @method setRawValue + * @hide */ + setRawValue : Ext.emptyFn + +}); + +Ext.reg('checkboxgroup', Ext.form.CheckboxGroup); +/** + * @class Ext.form.CompositeField + * @extends Ext.form.Field + * Composite field allowing a number of form Fields to be rendered on the same row. The fields are rendered + * using an hbox layout internally, so all of the normal HBox layout config items are available. Example usage: + * +{ + xtype: 'compositefield', + labelWidth: 120 + items: [ + { + xtype : 'textfield', + fieldLabel: 'Title', + width : 20 + }, + { + xtype : 'textfield', + fieldLabel: 'First', + flex : 1 + }, + { + xtype : 'textfield', + fieldLabel: 'Last', + flex : 1 + } + ] +} + * + * In the example above the composite's fieldLabel will be set to 'Title, First, Last' as it groups the fieldLabels + * of each of its children. This can be overridden by setting a fieldLabel on the compositefield itself: + * +{ + xtype: 'compositefield', + fieldLabel: 'Custom label', + items: [...] +} + * + * Any Ext.form.* component can be placed inside a composite field. + */ +Ext.form.CompositeField = Ext.extend(Ext.form.Field, { /** - * @cfg {Boolean} lazyInit true to not initialize the list for this combo until the field is focused - * (defaults to true) + * @property defaultMargins + * @type String + * The margins to apply by default to each field in the composite */ - lazyInit : true, + defaultMargins: '0 5 0 0', /** - * @cfg {Boolean} clearFilterOnReset true to clear any filters on the store (when in local mode) when reset is called - * (defaults to true) + * @property skipLastItemMargin + * @type Boolean + * If true, the defaultMargins are not applied to the last item in the composite field set (defaults to true) */ - clearFilterOnReset : true, + skipLastItemMargin: true, /** - * @cfg {Boolean} submitValue False to clear the name attribute on the field so that it is not submitted during a form post. - * If a hiddenName is specified, setting this to true will cause both the hidden field and the element to be submitted. - * Defaults to undefined. + * @property isComposite + * @type Boolean + * Signifies that this is a Composite field */ - submitValue: undefined, + isComposite: true, /** - * The value of the match string used to filter the store. Delete this property to force a requery. - * Example use: - * -var combo = new Ext.form.ComboBox({ - ... - mode: 'remote', - ... - listeners: { - // delete the previous query in the beforequery event or set - // combo.lastQuery = null (this will reload the store the next time it expands) - beforequery: function(qe){ - delete qe.combo.lastQuery; - } - } -}); - * - * To make sure the filter in the store is not cleared the first time the ComboBox trigger is used - * configure the combo with lastQuery=''. Example use: - * -var combo = new Ext.form.ComboBox({ - ... - mode: 'local', - triggerAction: 'all', - lastQuery: '' -}); - * - * @property lastQuery - * @type String + * @property combineErrors + * @type Boolean + * True to combine errors from the individual fields into a single error message at the CompositeField level (defaults to true) */ + combineErrors: true, - // private - initComponent : function(){ - Ext.form.ComboBox.superclass.initComponent.call(this); - this.addEvents( - /** - * @event expand - * Fires when the dropdown list is expanded - * @param {Ext.form.ComboBox} combo This combo box - */ - 'expand', - /** - * @event collapse - * Fires when the dropdown list is collapsed - * @param {Ext.form.ComboBox} combo This combo box - */ - 'collapse', + //inherit docs + //Builds the composite field label + initComponent: function() { + var labels = [], + items = this.items, + item; + for (var i=0, j = items.length; i < j; i++) { + item = items[i]; + + labels.push(item.fieldLabel); + + //apply any defaults + Ext.apply(item, this.defaults); + + //apply default margins to each item except the last + if (!(i == j - 1 && this.skipLastItemMargin)) { + Ext.applyIf(item, {margins: this.defaultMargins}); + } + } + + this.fieldLabel = this.fieldLabel || this.buildLabel(labels); + + /** + * @property fieldErrors + * @type Ext.util.MixedCollection + * MixedCollection of current errors on the Composite's subfields. This is used internally to track when + * to show and hide error messages at the Composite level. Listeners are attached to the MixedCollection's + * add, remove and replace events to update the error icon in the UI as errors are added or removed. + */ + this.fieldErrors = new Ext.util.MixedCollection(true, function(item) { + return item.field; + }); + + this.fieldErrors.on({ + scope : this, + add : this.updateInvalidMark, + remove : this.updateInvalidMark, + replace: this.updateInvalidMark + }); + + Ext.form.CompositeField.superclass.initComponent.apply(this, arguments); + }, + + /** + * @private + * Creates an internal container using hbox and renders the fields to it + */ + onRender: function(ct, position) { + if (!this.el) { /** - * @event beforeselect - * Fires before a list item is selected. Return false to cancel the selection. - * @param {Ext.form.ComboBox} combo This combo box - * @param {Ext.data.Record} record The data record returned from the underlying store - * @param {Number} index The index of the selected item in the dropdown list - */ - 'beforeselect', - /** - * @event select - * Fires when a list item is selected - * @param {Ext.form.ComboBox} combo This combo box - * @param {Ext.data.Record} record The data record returned from the underlying store - * @param {Number} index The index of the selected item in the dropdown list + * @property innerCt + * @type Ext.Container + * A container configured with hbox layout which is responsible for laying out the subfields */ - 'select', + var innerCt = this.innerCt = new Ext.Container({ + layout : 'hbox', + renderTo: ct, + items : this.items, + cls : 'x-form-composite', + defaultMargins: '0 3 0 0' + }); + + this.el = innerCt.getEl(); + + var fields = innerCt.findBy(function(c) { + return c.isFormField; + }, this); + /** - * @event beforequery - * Fires before all queries are processed. Return false to cancel the query or set the queryEvent's - * cancel property to true. - * @param {Object} queryEvent An object that has these properties: - * combo : Ext.form.ComboBox This combo box - * query : String The query - * forceAll : Boolean True to force "all" query - * cancel : Boolean Set to true to cancel the query - * + * @property items + * @type Ext.util.MixedCollection + * Internal collection of all of the subfields in this Composite */ - 'beforequery' - ); - if(this.transform){ - var s = Ext.getDom(this.transform); - if(!this.hiddenName){ - this.hiddenName = s.name; - } - if(!this.store){ - this.mode = 'local'; - var d = [], opts = s.options; - for(var i = 0, len = opts.length;i < len; i++){ - var o = opts[i], - value = (o.hasAttribute ? o.hasAttribute('value') : o.getAttributeNode('value').specified) ? o.value : o.text; - if(o.selected && Ext.isEmpty(this.value, true)) { - this.value = value; - } - d.push([value, o.text]); - } - this.store = new Ext.data.ArrayStore({ - 'id': 0, - fields: ['value', 'text'], - data : d, - autoDestroy: true + this.items = new Ext.util.MixedCollection(); + this.items.addAll(fields); + + //if we're combining subfield errors into a single message, override the markInvalid and clearInvalid + //methods of each subfield and show them at the Composite level instead + if (this.combineErrors) { + this.eachItem(function(field) { + Ext.apply(field, { + markInvalid : this.onFieldMarkInvalid.createDelegate(this, [field], 0), + clearInvalid: this.onFieldClearInvalid.createDelegate(this, [field], 0) + }); }); - this.valueField = 'value'; - this.displayField = 'text'; - } - s.name = Ext.id(); // wipe out the name in case somewhere else they have a reference - if(!this.lazyRender){ - this.target = true; - this.el = Ext.DomHelper.insertBefore(s, this.autoCreate || this.defaultAutoCreate); - this.render(this.el.parentNode, s); } - Ext.removeNode(s); - } - //auto-configure store from local array data - else if(this.store){ - this.store = Ext.StoreMgr.lookup(this.store); - if(this.store.autoCreated){ - this.displayField = this.valueField = 'field1'; - if(!this.store.expandData){ - this.displayField = 'field2'; - } - this.mode = 'local'; + + //set the label 'for' to the first item + var l = this.el.parent().parent().child('label', true); + if (l) { + l.setAttribute('for', this.items.items[0].id); } } - this.selectedIndex = -1; - if(this.mode == 'local'){ - if(!Ext.isDefined(this.initialConfig.queryDelay)){ - this.queryDelay = 10; + Ext.form.CompositeField.superclass.onRender.apply(this, arguments); + }, + + /** + * Called if combineErrors is true and a subfield's markInvalid method is called. + * By default this just adds the subfield's error to the internal fieldErrors MixedCollection + * @param {Ext.form.Field} field The field that was marked invalid + * @param {String} message The error message + */ + onFieldMarkInvalid: function(field, message) { + var name = field.getName(), + error = {field: name, error: message}; + + this.fieldErrors.replace(name, error); + + field.el.addClass(field.invalidClass); + }, + + /** + * Called if combineErrors is true and a subfield's clearInvalid method is called. + * By default this just updates the internal fieldErrors MixedCollection. + * @param {Ext.form.Field} field The field that was marked invalid + */ + onFieldClearInvalid: function(field) { + this.fieldErrors.removeKey(field.getName()); + + field.el.removeClass(field.invalidClass); + }, + + /** + * @private + * Called after a subfield is marked valid or invalid, this checks to see if any of the subfields are + * currently invalid. If any subfields are invalid it builds a combined error message marks the composite + * invalid, otherwise clearInvalid is called + */ + updateInvalidMark: function() { + var ieStrict = Ext.isIE6 && Ext.isStrict; + + if (this.fieldErrors.length == 0) { + this.clearInvalid(); + + //IE6 in strict mode has a layout bug when using 'under' as the error message target. This fixes it + if (ieStrict) { + this.clearInvalid.defer(50, this); } - if(!Ext.isDefined(this.initialConfig.minChars)){ - this.minChars = 0; + } else { + var message = this.buildCombinedErrorMessage(this.fieldErrors.items); + + this.sortErrors(); + this.markInvalid(message); + + //IE6 in strict mode has a layout bug when using 'under' as the error message target. This fixes it + if (ieStrict) { + this.markInvalid(message); } } }, - // private - onRender : function(ct, position){ - if(this.hiddenName && !Ext.isDefined(this.submitValue)){ - this.submitValue = false; - } - Ext.form.ComboBox.superclass.onRender.call(this, ct, position); - if(this.hiddenName){ - this.hiddenField = this.el.insertSibling({tag:'input', type:'hidden', name: this.hiddenName, - id: (this.hiddenId||this.hiddenName)}, 'before', true); + /** + * Performs validation checks on each subfield and returns false if any of them fail validation. + * @return {Boolean} False if any subfield failed validation + */ + validateValue: function() { + var valid = true; - } - if(Ext.isGecko){ - this.el.dom.setAttribute('autocomplete', 'off'); - } + this.eachItem(function(field) { + if (!field.isValid()) valid = false; + }); - if(!this.lazyInit){ - this.initList(); - }else{ - this.on('focus', this.initList, this, {single: true}); - } + return valid; }, - // private - initValue : function(){ - Ext.form.ComboBox.superclass.initValue.call(this); - if(this.hiddenField){ - this.hiddenField.value = - Ext.value(Ext.isDefined(this.hiddenValue) ? this.hiddenValue : this.value, ''); + /** + * Takes an object containing error messages for contained fields, returning a combined error + * string (defaults to just placing each item on a new line). This can be overridden to provide + * custom combined error message handling. + * @param {Array} errors Array of errors in format: [{field: 'title', error: 'some error'}] + * @return {String} The combined error message + */ + buildCombinedErrorMessage: function(errors) { + var combined = [], + error; + + for (var i = 0, j = errors.length; i < j; i++) { + error = errors[i]; + + combined.push(String.format("{0}: {1}", error.field, error.error)); } + + return combined.join(" "); }, - // private - initList : function(){ - if(!this.list){ - var cls = 'x-combo-list', - listParent = Ext.getDom(this.getListParent() || Ext.getBody()), - zindex = parseInt(Ext.fly(listParent).getStyle('z-index') ,10); + /** + * Sorts the internal fieldErrors MixedCollection by the order in which the fields are defined. + * This is called before displaying errors to ensure that the errors are presented in the expected order. + * This function can be overridden to provide a custom sorting order if needed. + */ + sortErrors: function() { + var fields = this.items; - if (this.ownerCt && !zindex){ - this.findParentBy(function(ct){ - zindex = parseInt(ct.getPositionEl().getStyle('z-index'), 10); - return !!zindex; - }); - } + this.fieldErrors.sort("ASC", function(a, b) { + var findByName = function(key) { + return function(field) { + return field.getName() == key; + }; + }; - this.list = new Ext.Layer({ - parentEl: listParent, - shadow: this.shadow, - cls: [cls, this.listClass].join(' '), - constrain:false, - zindex: (zindex || 12000) + 5 - }); + var aIndex = fields.findIndexBy(findByName(a.field)), + bIndex = fields.findIndexBy(findByName(b.field)); - var lw = this.listWidth || Math.max(this.wrap.getWidth(), this.minListWidth); - this.list.setSize(lw, 0); - this.list.swallowEvent('mousewheel'); - this.assetHeight = 0; - if(this.syncFont !== false){ - this.list.setStyle('font-size', this.el.getStyle('font-size')); - } - if(this.title){ - this.header = this.list.createChild({cls:cls+'-hd', html: this.title}); - this.assetHeight += this.header.getHeight(); - } + return aIndex < bIndex ? -1 : 1; + }); + }, - this.innerList = this.list.createChild({cls:cls+'-inner'}); - this.mon(this.innerList, 'mouseover', this.onViewOver, this); - this.mon(this.innerList, 'mousemove', this.onViewMove, this); - this.innerList.setWidth(lw - this.list.getFrameWidth('lr')); + /** + * Resets each field in the composite to their previous value + */ + reset: function() { + this.eachItem(function(item) { + item.reset(); + }); - if(this.pageSize){ - this.footer = this.list.createChild({cls:cls+'-ft'}); - this.pageTb = new Ext.PagingToolbar({ - store: this.store, - pageSize: this.pageSize, - renderTo:this.footer - }); - this.assetHeight += this.footer.getHeight(); - } + // Defer the clearInvalid so if BaseForm's collection is being iterated it will be called AFTER it is complete. + // Important because reset is being called on both the group and the individual items. + (function() { + this.clearInvalid(); + }).defer(50, this); + }, + + /** + * Calls clearInvalid on all child fields. This is a convenience function and should not often need to be called + * as fields usually take care of clearing themselves + */ + clearInvalidChildren: function() { + this.eachItem(function(item) { + item.clearInvalid(); + }); + }, - if(!this.tpl){ - /** - * @cfg {String/Ext.XTemplate} tpl The template string, or {@link Ext.XTemplate} instance to - * use to display each item in the dropdown list. The dropdown list is displayed in a - * DataView. See {@link #view}. - * The default template string is: - '<tpl for="."><div class="x-combo-list-item">{' + this.displayField + '}</div></tpl>' - * - * Override the default value to create custom UI layouts for items in the list. - * For example: - '<tpl for="."><div ext:qtip="{state}. {nick}" class="x-combo-list-item">{state}</div></tpl>' - * - * The template must contain one or more substitution parameters using field - * names from the Combo's {@link #store Store}. In the example above an - * ext:qtip attribute is added to display other fields from the Store. - * To preserve the default visual look of list items, add the CSS class name - * x-combo-list-item to the template's container element. - * Also see {@link #itemSelector} for additional details. - */ - this.tpl = '{' + this.displayField + '}'; - /** - * @cfg {String} itemSelector - * A simple CSS selector (e.g. div.some-class or span:first-child) that will be - * used to determine what nodes the {@link #view Ext.DataView} which handles the dropdown - * display will be working with. - * Note: this setting is required if a custom XTemplate has been - * specified in {@link #tpl} which assigns a class other than 'x-combo-list-item' - * to dropdown list items - */ + /** + * Builds a label string from an array of subfield labels. + * By default this just joins the labels together with a comma + * @param {Array} segments Array of each of the labels in the composite field's subfields + * @return {String} The built label + */ + buildLabel: function(segments) { + return segments.join(", "); + }, + + /** + * Checks each field in the composite and returns true if any is dirty + * @return {Boolean} True if any field is dirty + */ + isDirty: function(){ + //override the behaviour to check sub items. + if (this.disabled || !this.rendered) { + return false; + } + + var dirty = false; + this.eachItem(function(item){ + if(item.isDirty()){ + dirty = true; + return false; } + }); + return dirty; + }, - /** - * The {@link Ext.DataView DataView} used to display the ComboBox's options. - * @type Ext.DataView - */ - this.view = new Ext.DataView({ - applyTo: this.innerList, - tpl: this.tpl, - singleSelect: true, - selectedClass: this.selectedClass, - itemSelector: this.itemSelector || '.' + cls + '-item', - emptyText: this.listEmptyText, - deferEmptyText: false - }); + /** + * @private + * Convenience function which passes the given function to every item in the composite + * @param {Function} fn The function to call + * @param {Object} scope Optional scope object + */ + eachItem: function(fn, scope) { + if(this.items && this.items.each){ + this.items.each(fn, scope || this); + } + }, - this.mon(this.view, { - containerclick : this.onViewClick, - click : this.onViewClick, - scope :this - }); + /** + * @private + * Passes the resize call through to the inner panel + */ + onResize: function(adjWidth, adjHeight, rawWidth, rawHeight) { + var innerCt = this.innerCt; - this.bindStore(this.store, true); + if (this.rendered && innerCt.rendered) { + innerCt.setSize(adjWidth, adjHeight); + } - if(this.resizable){ - this.resizer = new Ext.Resizable(this.list, { - pinned:true, handles:'se' - }); - this.mon(this.resizer, 'resize', function(r, w, h){ - this.maxHeight = h-this.handleHeight-this.list.getFrameWidth('tb')-this.assetHeight; - this.listWidth = w; - this.innerList.setWidth(w - this.list.getFrameWidth('lr')); - this.restrictHeight(); - }, this); + Ext.form.CompositeField.superclass.onResize.apply(this, arguments); + }, - this[this.pageSize?'footer':'innerList'].setStyle('margin-bottom', this.handleHeight+'px'); - } + /** + * @private + * Forces the internal container to be laid out again + */ + doLayout: function(shallow, force) { + if (this.rendered) { + var innerCt = this.innerCt; + + innerCt.forceLayout = this.ownerCt.forceLayout; + innerCt.doLayout(shallow, force); } }, /** - * Returns the element used to house this ComboBox's pop-up list. Defaults to the document body. - * A custom implementation may be provided as a configuration option if the floating list needs to be rendered - * to a different Element. An example might be rendering the list inside a Menu so that clicking - * the list does not hide the Menu: -var store = new Ext.data.ArrayStore({ - autoDestroy: true, - fields: ['initials', 'fullname'], - data : [ - ['FF', 'Fred Flintstone'], - ['BR', 'Barney Rubble'] - ] -}); + * @private + */ + beforeDestroy: function(){ + Ext.destroy(this.innerCt); -var combo = new Ext.form.ComboBox({ - store: store, - displayField: 'fullname', - emptyText: 'Select a name...', - forceSelection: true, - getListParent: function() { - return this.el.up('.x-menu'); + Ext.form.CompositeField.superclass.beforeDestroy.call(this); }, - iconCls: 'no-icon', //use iconCls if placing within menu to shift to right side of menu - mode: 'local', - selectOnFocus: true, - triggerAction: 'all', - typeAhead: true, - width: 135 -}); -var menu = new Ext.menu.Menu({ - id: 'mainMenu', - items: [ - combo // A Field in a Menu - ] + //override the behaviour to check sub items. + setReadOnly : function(readOnly) { + readOnly = readOnly || true; + + if(this.rendered){ + this.eachItem(function(item){ + item.setReadOnly(readOnly); + }); + } + this.readOnly = readOnly; + }, + + onShow : function() { + Ext.form.CompositeField.superclass.onShow.call(this); + this.doLayout(); + }, + + //override the behaviour to check sub items. + onDisable : function(){ + this.eachItem(function(item){ + item.disable(); + }); + }, + + //override the behaviour to check sub items. + onEnable : function(){ + this.eachItem(function(item){ + item.enable(); + }); + } }); - + +Ext.reg('compositefield', Ext.form.CompositeField); +/** + * @class Ext.form.Radio + * @extends Ext.form.Checkbox + * Single radio field. Same as Checkbox, but provided as a convenience for automatically setting the input type. + * Radio grouping is handled automatically by the browser if you give each radio in a group the same name. + * @constructor + * Creates a new Radio + * @param {Object} config Configuration options + * @xtype radio + */ +Ext.form.Radio = Ext.extend(Ext.form.Checkbox, { + inputType: 'radio', + + /** + * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide + * @method */ - getListParent : function() { - return document.body; + markInvalid : Ext.emptyFn, + /** + * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide + * @method + */ + clearInvalid : Ext.emptyFn, + + /** + * If this radio is part of a group, it will return the selected value + * @return {String} + */ + getGroupValue : function(){ + var p = this.el.up('form') || Ext.getBody(); + var c = p.child('input[name='+this.el.dom.name+']:checked', true); + return c ? c.value : null; + }, + + // private + onClick : function(){ + if(this.el.dom.checked != this.checked){ + var els = this.getCheckEl().select('input[name=' + this.el.dom.name + ']'); + els.each(function(el){ + if(el.dom.id == this.id){ + this.setValue(true); + }else{ + Ext.getCmp(el.dom.id).setValue(false); + } + }, this); + } }, /** - * Returns the store associated with this combo. - * @return {Ext.data.Store} The store + * Sets either the checked/unchecked status of this Radio, or, if a string value + * is passed, checks a sibling Radio of the same name whose value is the value specified. + * @param value {String/Boolean} Checked value, or the value of the sibling radio button to check. + * @return {Ext.form.Field} this */ - getStore : function(){ - return this.store; + setValue : function(v){ + if (typeof v == 'boolean') { + Ext.form.Radio.superclass.setValue.call(this, v); + } else if (this.rendered) { + var r = this.getCheckEl().child('input[name=' + this.el.dom.name + '][value=' + v + ']', true); + if(r){ + Ext.getCmp(r.id).setValue(true); + } + } + return this; }, // private - bindStore : function(store, initial){ - if(this.store && !initial){ - if(this.store !== store && this.store.autoDestroy){ - this.store.destroy(); - }else{ - this.store.un('beforeload', this.onBeforeLoad, this); - this.store.un('load', this.onLoad, this); - this.store.un('exception', this.collapse, this); - } - if(!store){ - this.store = null; - if(this.view){ - this.view.bindStore(null); - } - if(this.pageTb){ - this.pageTb.bindStore(null); - } - } + getCheckEl: function(){ + if(this.inGroup){ + return this.el.up('.x-form-radio-group') } - if(store){ - if(!initial) { - this.lastQuery = null; - if(this.pageTb) { - this.pageTb.bindStore(store); - } + return this.el.up('form') || Ext.getBody(); + } +}); +Ext.reg('radio', Ext.form.Radio); +/** + * @class Ext.form.RadioGroup + * @extends Ext.form.CheckboxGroup + * A grouping container for {@link Ext.form.Radio} controls. + * @constructor + * Creates a new RadioGroup + * @param {Object} config Configuration options + * @xtype radiogroup + */ +Ext.form.RadioGroup = Ext.extend(Ext.form.CheckboxGroup, { + /** + * @cfg {Array} items An Array of {@link Ext.form.Radio Radio}s or Radio config objects + * to arrange in the group. + */ + /** + * @cfg {Boolean} allowBlank True to allow every item in the group to be blank (defaults to true). + * If allowBlank = false and no items are selected at validation time, {@link @blankText} will + * be used as the error text. + */ + allowBlank : true, + /** + * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails + * (defaults to 'You must select one item in this group') + */ + blankText : 'You must select one item in this group', + + // private + defaultType : 'radio', + + // private + groupCls : 'x-form-radio-group', + + /** + * @event change + * Fires when the state of a child radio changes. + * @param {Ext.form.RadioGroup} this + * @param {Ext.form.Radio} checked The checked radio + */ + + /** + * Gets the selected {@link Ext.form.Radio} in the group, if it exists. + * @return {Ext.form.Radio} The selected radio. + */ + getValue : function(){ + var out = null; + this.eachItem(function(item){ + if(item.checked){ + out = item; + return false; } - - this.store = Ext.StoreMgr.lookup(store); - this.store.on({ - scope: this, - beforeload: this.onBeforeLoad, - load: this.onLoad, - exception: this.collapse - }); - - if(this.view){ - this.view.bindStore(store); + }); + return out; + }, + + /** + * Sets the checked radio in the group. + * @param {String/Ext.form.Radio} id The radio to check. + * @param {Boolean} value The value to set the radio. + * @return {Ext.form.RadioGroup} this + */ + onSetValue : function(id, value){ + if(arguments.length > 1){ + var f = this.getBox(id); + if(f){ + f.setValue(value); + if(f.checked){ + this.eachItem(function(item){ + if (item !== f){ + item.setValue(false); + } + }); + } } + }else{ + this.setValueForItem(id); } }, - - reset : function(){ - Ext.form.ComboBox.superclass.reset.call(this); - if(this.clearFilterOnReset && this.mode == 'local'){ - this.store.clearFilter(); + + setValueForItem : function(val){ + val = String(val).split(',')[0]; + this.eachItem(function(item){ + item.setValue(val == item.inputValue); + }); + }, + + // private + fireChecked : function(){ + if(!this.checkTask){ + this.checkTask = new Ext.util.DelayedTask(this.bufferChecked, this); } + this.checkTask.delay(10); }, - + // private - initEvents : function(){ - Ext.form.ComboBox.superclass.initEvents.call(this); - - - this.keyNav = new Ext.KeyNav(this.el, { - "up" : function(e){ - this.inKeyMode = true; - this.selectPrev(); - }, - - "down" : function(e){ - if(!this.isExpanded()){ - this.onTriggerClick(); - }else{ - this.inKeyMode = true; - this.selectNext(); - } - }, - - "enter" : function(e){ - this.onViewClick(); - }, - - "esc" : function(e){ - this.collapse(); - }, - - "tab" : function(e){ - this.collapse(); - return true; - }, - - scope : this, - - doRelay : function(e, h, hname){ - if(hname == 'down' || this.scope.isExpanded()){ - // this MUST be called before ComboBox#fireKey() - var relay = Ext.KeyNav.prototype.doRelay.apply(this, arguments); - if(!Ext.isIE && Ext.EventManager.useKeydown){ - // call Combo#fireKey() for browsers which use keydown event (except IE) - this.scope.fireKey(e); - } - return relay; - } - return true; - }, - - forceKeyDown : true, - defaultEventAction: 'stopEvent' + bufferChecked : function(){ + var out = null; + this.eachItem(function(item){ + if(item.checked){ + out = item; + return false; + } }); - this.queryDelay = Math.max(this.queryDelay || 10, - this.mode == 'local' ? 10 : 250); - this.dqTask = new Ext.util.DelayedTask(this.initQuery, this); - if(this.typeAhead){ - this.taTask = new Ext.util.DelayedTask(this.onTypeAhead, this); - } - if(!this.enableKeyEvents){ - this.mon(this.el, 'keyup', this.onKeyUp, this); - } + this.fireEvent('change', this, out); }, + + onDestroy : function(){ + if(this.checkTask){ + this.checkTask.cancel(); + this.checkTask = null; + } + Ext.form.RadioGroup.superclass.onDestroy.call(this); + } +}); +Ext.reg('radiogroup', Ext.form.RadioGroup); +/** + * @class Ext.form.Hidden + * @extends Ext.form.Field + * A basic hidden field for storing hidden values in forms that need to be passed in the form submit. + * @constructor + * Create a new Hidden field. + * @param {Object} config Configuration options + * @xtype hidden + */ +Ext.form.Hidden = Ext.extend(Ext.form.Field, { // private - onDestroy : function(){ - if (this.dqTask){ - this.dqTask.cancel(); - this.dqTask = null; - } - this.bindStore(null); - Ext.destroy( - this.resizer, - this.view, - this.pageTb, - this.list - ); - Ext.destroyMembers(this, 'hiddenField'); - Ext.form.ComboBox.superclass.onDestroy.call(this); - }, + inputType : 'hidden', // private - fireKey : function(e){ - if (!this.isExpanded()) { - Ext.form.ComboBox.superclass.fireKey.call(this, e); - } + onRender : function(){ + Ext.form.Hidden.superclass.onRender.apply(this, arguments); }, // private - onResize : function(w, h){ - Ext.form.ComboBox.superclass.onResize.apply(this, arguments); - if(this.isVisible() && this.list){ - this.doResize(w); - }else{ - this.bufferSize = w; - } + initEvents : function(){ + this.originalValue = this.getValue(); }, - doResize: function(w){ - if(!Ext.isDefined(this.listWidth)){ - var lw = Math.max(w, this.minListWidth); - this.list.setWidth(lw); - this.innerList.setWidth(lw - this.list.getFrameWidth('lr')); - } - }, + // These are all private overrides + setSize : Ext.emptyFn, + setWidth : Ext.emptyFn, + setHeight : Ext.emptyFn, + setPosition : Ext.emptyFn, + setPagePosition : Ext.emptyFn, + markInvalid : Ext.emptyFn, + clearInvalid : Ext.emptyFn +}); +Ext.reg('hidden', Ext.form.Hidden);/** + * @class Ext.form.BasicForm + * @extends Ext.util.Observable + * Encapsulates the DOM <form> element at the heart of the {@link Ext.form.FormPanel FormPanel} class, and provides + * input field management, validation, submission, and form loading services. + * By default, Ext Forms are submitted through Ajax, using an instance of {@link Ext.form.Action.Submit}. + * To enable normal browser submission of an Ext Form, use the {@link #standardSubmit} config option. + * File Uploads + * {@link #fileUpload File uploads} are not performed using Ajax submission, 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. + * Characters which are significant to an HTML parser must be sent as HTML entities, so encode + * "<" as "<", "&" as "&" etc. + * 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 {Mixed} el The form element or its id + * @param {Object} config Configuration options + */ +Ext.form.BasicForm = Ext.extend(Ext.util.Observable, { - // private - onEnable : function(){ - Ext.form.ComboBox.superclass.onEnable.apply(this, arguments); - if(this.hiddenField){ - this.hiddenField.disabled = false; + constructor: function(el, config){ + Ext.apply(this, config); + if(Ext.isString(this.paramOrder)){ + this.paramOrder = this.paramOrder.split(/[\s,|]/); } - }, + /** + * A {@link Ext.util.MixedCollection MixedCollection} containing all the Ext.form.Fields in this form. + * @type MixedCollection + * @property items + */ + this.items = new Ext.util.MixedCollection(false, function(o){ + return o.getItemId(); + }); + this.addEvents( + /** + * @event beforeaction + * Fires before any action is performed. Return false to cancel the action. + * @param {Form} this + * @param {Action} action The {@link Ext.form.Action} to be performed + */ + 'beforeaction', + /** + * @event actionfailed + * Fires when an action fails. + * @param {Form} this + * @param {Action} action The {@link Ext.form.Action} that failed + */ + 'actionfailed', + /** + * @event actioncomplete + * Fires when an action is completed. + * @param {Form} this + * @param {Action} action The {@link Ext.form.Action} that completed + */ + 'actioncomplete' + ); - // private - onDisable : function(){ - Ext.form.ComboBox.superclass.onDisable.apply(this, arguments); - if(this.hiddenField){ - this.hiddenField.disabled = true; + if(el){ + this.initEl(el); } + Ext.form.BasicForm.superclass.constructor.call(this); }, - // private - onBeforeLoad : function(){ - if(!this.hasFocus){ - return; - } - this.innerList.update(this.loadingText ? - ''+this.loadingText+'' : ''); - this.restrictHeight(); - this.selectedIndex = -1; - }, + /** + * @cfg {String} method + * The request method to use (GET or POST) for form actions if one isn't supplied in the action options. + */ + /** + * @cfg {DataReader} reader + * An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to read + * data when executing 'load' actions. This is optional as there is built-in + * support for processing JSON. For additional information on using an XMLReader + * see the example provided in examples/form/xml-form.html. + */ + /** + * @cfg {DataReader} errorReader + * An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to + * read field error messages returned from 'submit' actions. This is optional + * as there is built-in support for processing JSON. + * The Records which provide messages for the invalid Fields must use the + * Field name (or id) as the Record ID, and must contain a field called 'msg' + * which contains the error message. + * The errorReader does not have to be a full-blown implementation of a + * DataReader. It simply needs to implement a read(xhr) function + * which returns an Array of Records in an object with the following + * structure: +{ + records: recordArray +} + + */ + /** + * @cfg {String} url + * The URL to use for form actions if one isn't supplied in the + * {@link #doAction doAction} options. + */ + /** + * @cfg {Boolean} fileUpload + * Set to true if this form is a file upload. + * 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. + * Characters which are significant to an HTML parser must be sent as HTML entities, so encode + * "<" as "<", "&" as "&" etc. + * 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. + */ + /** + * @cfg {Object} baseParams + * Parameters to pass with all requests. e.g. baseParams: {id: '123', foo: 'bar'}. + * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. + */ + /** + * @cfg {Number} timeout Timeout for form actions in seconds (default is 30 seconds). + */ + timeout: 30, + + /** + * @cfg {Object} api (Optional) If specified load and submit actions will be handled + * with {@link Ext.form.Action.DirectLoad} and {@link Ext.form.Action.DirectSubmit}. + * Methods which have been imported by Ext.Direct can be specified here to load and submit + * forms. + * Such as the following: +api: { + load: App.ss.MyProfile.load, + submit: App.ss.MyProfile.submit +} + + * Load actions can use {@link #paramOrder} or {@link #paramsAsHash} + * to customize how the load method is invoked. + * Submit actions will always use a standard form submit. The formHandler configuration must + * be set on the associated server-side method which has been imported by Ext.Direct + */ + + /** + * @cfg {Array/String} paramOrder A list of params to be executed server side. + * Defaults to undefined. Only used for the {@link #api} + * load configuration. + * Specify the params in the order in which they must be executed on the + * server-side as either (1) an Array of String values, or (2) a String of params + * delimited by either whitespace, comma, or pipe. For example, + * any of the following would be acceptable: +paramOrder: ['param1','param2','param3'] +paramOrder: 'param1 param2 param3' +paramOrder: 'param1,param2,param3' +paramOrder: 'param1|param2|param' + + */ + paramOrder: undefined, + + /** + * @cfg {Boolean} paramsAsHash Only used for the {@link #api} + * load configuration. Send parameters as a collection of named + * arguments (defaults to false). Providing a + * {@link #paramOrder} nullifies this configuration. + */ + paramsAsHash: false, + + /** + * @cfg {String} waitTitle + * The default title to show for the waiting message box (defaults to 'Please Wait...') + */ + waitTitle: 'Please Wait...', // private - onLoad : function(){ - if(!this.hasFocus){ - return; - } - if(this.store.getCount() > 0 || this.listEmptyText){ - this.expand(); - this.restrictHeight(); - if(this.lastQuery == this.allQuery){ - if(this.editable){ - this.el.dom.select(); - } + activeAction : null, - if(this.autoSelect !== false && !this.selectByValue(this.value, true)){ - this.select(0, true); - } - }else{ - if(this.autoSelect !== false){ - this.selectNext(); - } - if(this.typeAhead && this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE){ - this.taTask.delay(this.typeAheadDelay); - } - } - }else{ - this.collapse(); - } + /** + * @cfg {Boolean} trackResetOnLoad If set to true, {@link #reset}() resets to the last loaded + * or {@link #setValues}() data instead of when the form was first created. Defaults to false. + */ + trackResetOnLoad : false, + /** + * @cfg {Boolean} standardSubmit + * If set to true, standard HTML form submits are used instead + * of XHR (Ajax) style form submissions. Defaults to false. + * Note: When using standardSubmit, the + * options to {@link #submit} are ignored because + * Ext's Ajax infrastracture is bypassed. To pass extra parameters (e.g. + * baseParams and params), utilize hidden fields + * to submit extra data, for example: + * +new Ext.FormPanel({ + standardSubmit: true, + baseParams: { + foo: 'bar' }, - - // private - onTypeAhead : function(){ - if(this.store.getCount() > 0){ - var r = this.store.getAt(0); - var newValue = r.data[this.displayField]; - var len = newValue.length; - var selStart = this.getRawValue().length; - if(selStart != len){ - this.setRawValue(newValue); - this.selectText(selStart, newValue.length); + {@link url}: 'myProcess.php', + items: [{ + xtype: 'textfield', + name: 'userName' + }], + buttons: [{ + text: 'Save', + handler: function(){ + var fp = this.ownerCt.ownerCt, + form = fp.getForm(); + if (form.isValid()) { + // check if there are baseParams and if + // hiddent items have been added already + if (fp.baseParams && !fp.paramsAdded) { + // add hidden items for all baseParams + for (i in fp.baseParams) { + fp.add({ + xtype: 'hidden', + name: i, + value: fp.baseParams[i] + }); + } + fp.doLayout(); + // set a custom flag to prevent re-adding + fp.paramsAdded = true; + } + form.{@link #submit}(); } } - }, + }] +}); + * + */ + /** + * By default wait messages are displayed with Ext.MessageBox.wait. You can target a specific + * element by passing it or its id or mask the form itself by passing in true. + * @type Mixed + * @property waitMsgTarget + */ // private - assertValue : function(){ - - var val = this.getRawValue(), - rec = this.findRecord(this.displayField, val); - - if(!rec && this.forceSelection){ - if(val.length > 0 && val != this.emptyText){ - this.el.dom.value = Ext.value(this.lastSelectionText, ''); - this.applyEmptyText(); - }else{ - this.clearValue(); - } - }else{ - if(rec){ - val = rec.get(this.valueField || this.displayField); - } - this.setValue(val); + initEl : function(el){ + this.el = Ext.get(el); + this.id = this.el.id || Ext.id(); + if(!this.standardSubmit){ + this.el.on('submit', this.onSubmit, this); } + this.el.addClass('x-form'); + }, + /** + * Get the HTML form Element + * @return Ext.Element + */ + getEl: function(){ + return this.el; }, // private - onSelect : function(record, index){ - if(this.fireEvent('beforeselect', this, record, index) !== false){ - this.setValue(record.data[this.valueField || this.displayField]); - this.collapse(); - this.fireEvent('select', this, record, index); - } + onSubmit : function(e){ + e.stopEvent(); }, - // inherit docs - getName: function(){ - var hf = this.hiddenField; - return hf && hf.name ? hf.name : this.hiddenName || Ext.form.ComboBox.superclass.getName.call(this); + /** + * Destroys this object. + * @private + * @param {Boolean} bound true if the object is bound to a form panel. If this is the case + * the FormPanel will take care of destroying certain things, so we're just doubling up. + */ + destroy: function(bound){ + if(bound !== true){ + this.items.each(function(f){ + Ext.destroy(f); + }); + Ext.destroy(this.el); + } + this.items.clear(); + this.purgeListeners(); }, /** - * Returns the currently selected field value or empty string if no value is set. - * @return {String} value The selected value + * Returns true if client-side validation on the form is successful. + * @return Boolean */ - getValue : function(){ - if(this.valueField){ - return Ext.isDefined(this.value) ? this.value : ''; - }else{ - return Ext.form.ComboBox.superclass.getValue.call(this); - } + isValid : function(){ + var valid = true; + this.items.each(function(f){ + if(!f.validate()){ + valid = false; + } + }); + return valid; }, /** - * Clears any text/value currently set in the field + * Returns true if any fields in this form have changed from their original values. + * Note that if this BasicForm was configured with {@link #trackResetOnLoad} then the + * Fields' original values are updated when the values are loaded by {@link #setValues} + * or {@link #loadRecord}. + * @return Boolean */ - clearValue : function(){ - if(this.hiddenField){ - this.hiddenField.value = ''; - } - this.setRawValue(''); - this.lastSelectionText = ''; - this.applyEmptyText(); - this.value = ''; + isDirty : function(){ + var dirty = false; + this.items.each(function(f){ + if(f.isDirty()){ + dirty = true; + return false; + } + }); + return dirty; }, /** - * Sets the specified value into the field. If the value finds a match, the corresponding record text - * will be displayed in the field. If the value does not match the data value of an existing item, - * and the valueNotFoundText config option is defined, it will be displayed as the default field text. - * Otherwise the field will be blank (although the value will still be set). - * @param {String} value The value to match - * @return {Ext.form.Field} this + * Performs a predefined action ({@link Ext.form.Action.Submit} or + * {@link Ext.form.Action.Load}) or a custom extension of {@link Ext.form.Action} + * to perform application-specific processing. + * @param {String/Object} actionName The name of the predefined action type, + * or instance of {@link Ext.form.Action} to perform. + * @param {Object} options (optional) The options to pass to the {@link Ext.form.Action}. + * All of the config options listed below are supported by both the + * {@link Ext.form.Action.Submit submit} and {@link Ext.form.Action.Load load} + * actions unless otherwise noted (custom actions could also accept + * other config options): + * + * url : StringThe url for the action (defaults + * to the form's {@link #url}.) + * + * method : StringThe form method to use (defaults + * to the form's method, or POST if not defined) + * + * params : String/ObjectThe params to pass + * (defaults to the form's baseParams, or none if not defined) + * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. + * + * headers : ObjectRequest headers to set for the action + * (defaults to the form's default headers) + * + * success : FunctionThe callback that will + * be invoked after a successful response (see top of + * {@link Ext.form.Action.Submit submit} and {@link Ext.form.Action.Load load} + * for a description of what constitutes a successful response). + * The function is passed the following parameters: + * form : Ext.form.BasicFormThe form that requested the action + * action : The {@link Ext.form.Action Action} object which performed the operation. + * The action object contains these properties of interest: + * {@link Ext.form.Action#response response} + * {@link Ext.form.Action#result result} : interrogate for custom postprocessing + * {@link Ext.form.Action#type type} + * + * + * failure : FunctionThe callback that will be invoked after a + * failed transaction attempt. The function is passed the following parameters: + * form : The {@link Ext.form.BasicForm} that requested the action. + * action : The {@link Ext.form.Action Action} object which performed the operation. + * The action object contains these properties of interest: + * {@link Ext.form.Action#failureType failureType} + * {@link Ext.form.Action#response response} + * {@link Ext.form.Action#result result} : interrogate for custom postprocessing + * {@link Ext.form.Action#type type} + * + * + * scope : ObjectThe scope in which to call the + * callback functions (The this reference for the callback functions). + * + * clientValidation : BooleanSubmit Action only. + * Determines whether a Form's fields are validated in a final call to + * {@link Ext.form.BasicForm#isValid isValid} prior to submission. Set to false + * to prevent this. If undefined, pre-submission field validation is performed. + * + * @return {BasicForm} this */ - setValue : function(v){ - var text = v; - if(this.valueField){ - var r = this.findRecord(this.valueField, v); - if(r){ - text = r.data[this.displayField]; - }else if(Ext.isDefined(this.valueNotFoundText)){ - text = this.valueNotFoundText; - } + doAction : function(action, options){ + if(Ext.isString(action)){ + action = new Ext.form.Action.ACTION_TYPES[action](this, options); } - this.lastSelectionText = text; - if(this.hiddenField){ - this.hiddenField.value = Ext.value(v, ''); + if(this.fireEvent('beforeaction', this, action) !== false){ + this.beforeAction(action); + action.run.defer(100, action); } - Ext.form.ComboBox.superclass.setValue.call(this, text); - this.value = v; return this; }, - // private - findRecord : function(prop, value){ - var record; - if(this.store.getCount() > 0){ - this.store.each(function(r){ - if(r.data[prop] == value){ - record = r; - return false; - } - }); - } - return record; - }, - - // private - onViewMove : function(e, t){ - this.inKeyMode = false; + /** + * Shortcut to {@link #doAction do} a {@link Ext.form.Action.Submit submit action}. + * @param {Object} options The options to pass to the action (see {@link #doAction} for details). + * Note: this is ignored when using the {@link #standardSubmit} option. + * The following code: +myFormPanel.getForm().submit({ + clientValidation: true, + url: 'updateConsignment.php', + params: { + newStatus: 'delivered' }, - - // private - onViewOver : function(e, t){ - if(this.inKeyMode){ // prevent key nav and mouse over conflicts - return; - } - var item = this.view.findItemFromChild(t); - if(item){ - var index = this.view.indexOf(item); - this.select(index, false); - } + success: function(form, action) { + Ext.Msg.alert('Success', action.result.msg); }, - - // private - onViewClick : function(doFocus){ - var index = this.view.getSelectedIndexes()[0], - s = this.store, - r = s.getAt(index); - if(r){ - this.onSelect(r, index); - }else { - this.collapse(); - } - if(doFocus !== false){ - this.el.focus(); + failure: function(form, action) { + switch (action.failureType) { + case Ext.form.Action.CLIENT_INVALID: + Ext.Msg.alert('Failure', 'Form fields may not be submitted with invalid values'); + break; + case Ext.form.Action.CONNECT_FAILURE: + Ext.Msg.alert('Failure', 'Ajax communication failed'); + break; + case Ext.form.Action.SERVER_INVALID: + Ext.Msg.alert('Failure', action.result.msg); + } + } +}); + + * would process the following server response for a successful submission: +{ + "success":true, // note this is Boolean, not string + "msg":"Consignment updated" +} + + * and the following server response for a failed submission: +{ + "success":false, // note this is Boolean, not string + "msg":"You do not have permission to perform this operation" +} + + * @return {BasicForm} this + */ + submit : function(options){ + options = options || {}; + if(this.standardSubmit){ + var v = options.clientValidation === false || this.isValid(); + if(v){ + var el = this.el.dom; + if(this.url && Ext.isEmpty(el.action)){ + el.action = this.url; + } + el.submit(); + } + return v; } - }, - - - // private - restrictHeight : function(){ - this.innerList.dom.style.height = ''; - var inner = this.innerList.dom, - pad = this.list.getFrameWidth('tb') + (this.resizable ? this.handleHeight : 0) + this.assetHeight, - h = Math.max(inner.clientHeight, inner.offsetHeight, inner.scrollHeight), - ha = this.getPosition()[1]-Ext.getBody().getScroll().top, - hb = Ext.lib.Dom.getViewHeight()-ha-this.getSize().height, - space = Math.max(ha, hb, this.minHeight || 0)-this.list.shadowOffset-pad-5; - - h = Math.min(h, space, this.maxHeight); - - this.innerList.setHeight(h); - this.list.beginUpdate(); - this.list.setHeight(h+pad); - this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign)); - this.list.endUpdate(); + var submitAction = String.format('{0}submit', this.api ? 'direct' : ''); + this.doAction(submitAction, options); + return this; }, /** - * Returns true if the dropdown list is expanded, else false. + * Shortcut to {@link #doAction do} a {@link Ext.form.Action.Load load action}. + * @param {Object} options The options to pass to the action (see {@link #doAction} for details) + * @return {BasicForm} this */ - isExpanded : function(){ - return this.list && this.list.isVisible(); + load : function(options){ + var loadAction = String.format('{0}load', this.api ? 'direct' : ''); + this.doAction(loadAction, options); + return this; }, /** - * Select an item in the dropdown list by its data value. This function does NOT cause the select event to fire. - * The store must be loaded and the list expanded for this function to work, otherwise use setValue. - * @param {String} value The data value of the item to select - * @param {Boolean} scrollIntoView False to prevent the dropdown list from autoscrolling to display the - * selected item if it is not currently in view (defaults to true) - * @return {Boolean} True if the value matched an item in the list, else false + * Persists the values in this form into the passed {@link Ext.data.Record} object in a beginEdit/endEdit block. + * @param {Record} record The record to edit + * @return {BasicForm} this */ - selectByValue : function(v, scrollIntoView){ - if(!Ext.isEmpty(v, true)){ - var r = this.findRecord(this.valueField || this.displayField, v); - if(r){ - this.select(this.store.indexOf(r), scrollIntoView); - return true; + updateRecord : function(record){ + record.beginEdit(); + var fs = record.fields; + fs.each(function(f){ + var field = this.findField(f.name); + if(field){ + record.set(f.name, field.getValue()); } - } - return false; + }, this); + record.endEdit(); + return this; }, /** - * Select an item in the dropdown list by its numeric index in the list. This function does NOT cause the select event to fire. - * The store must be loaded and the list expanded for this function to work, otherwise use setValue. - * @param {Number} index The zero-based index of the list item to select - * @param {Boolean} scrollIntoView False to prevent the dropdown list from autoscrolling to display the - * selected item if it is not currently in view (defaults to true) + * Loads an {@link Ext.data.Record} into this form by calling {@link #setValues} with the + * {@link Ext.data.Record#data record data}. + * See also {@link #trackResetOnLoad}. + * @param {Record} record The record to load + * @return {BasicForm} this */ - select : function(index, scrollIntoView){ - this.selectedIndex = index; - this.view.select(index); - if(scrollIntoView !== false){ - var el = this.view.getNode(index); - if(el){ - this.innerList.scrollChildIntoView(el, false); - } - } - + loadRecord : function(record){ + this.setValues(record.data); + return this; }, // private - selectNext : function(){ - var ct = this.store.getCount(); - if(ct > 0){ - if(this.selectedIndex == -1){ - this.select(0); - }else if(this.selectedIndex < ct-1){ - this.select(this.selectedIndex+1); + beforeAction : function(action){ + // Call HtmlEditor's syncValue before actions + this.items.each(function(f){ + if(f.isFormField && f.syncValue){ + f.syncValue(); + } + }); + var o = action.options; + if(o.waitMsg){ + if(this.waitMsgTarget === true){ + this.el.mask(o.waitMsg, 'x-mask-loading'); + }else if(this.waitMsgTarget){ + this.waitMsgTarget = Ext.get(this.waitMsgTarget); + this.waitMsgTarget.mask(o.waitMsg, 'x-mask-loading'); + }else{ + Ext.MessageBox.wait(o.waitMsg, o.waitTitle || this.waitTitle); } } }, // private - selectPrev : function(){ - var ct = this.store.getCount(); - if(ct > 0){ - if(this.selectedIndex == -1){ - this.select(0); - }else if(this.selectedIndex !== 0){ - this.select(this.selectedIndex-1); + afterAction : function(action, success){ + this.activeAction = null; + var o = action.options; + if(o.waitMsg){ + if(this.waitMsgTarget === true){ + this.el.unmask(); + }else if(this.waitMsgTarget){ + this.waitMsgTarget.unmask(); + }else{ + Ext.MessageBox.updateProgress(1); + Ext.MessageBox.hide(); + } + } + if(success){ + if(o.reset){ + this.reset(); } + Ext.callback(o.success, o.scope, [this, action]); + this.fireEvent('actioncomplete', this, action); + }else{ + Ext.callback(o.failure, o.scope, [this, action]); + this.fireEvent('actionfailed', this, action); } }, - // private - onKeyUp : function(e){ - var k = e.getKey(); - if(this.editable !== false && this.readOnly !== true && (k == e.BACKSPACE || !e.isSpecialKey())){ + /** + * Find a {@link Ext.form.Field} in this form. + * @param {String} id The value to search for (specify either a {@link Ext.Component#id id}, + * {@link Ext.grid.Column#dataIndex dataIndex}, {@link Ext.form.Field#getName name or hiddenName}). + * @return Field + */ + findField : function(id) { + var field = this.items.get(id); - this.lastKey = k; - this.dqTask.delay(this.queryDelay); - } - Ext.form.ComboBox.superclass.onKeyUp.call(this, e); - }, + if (!Ext.isObject(field)) { + //searches for the field corresponding to the given id. Used recursively for composite fields + var findMatchingField = function(f) { + if (f.isFormField) { + if (f.dataIndex == id || f.id == id || f.getName() == id) { + field = f; + return false; + } else if (f.isComposite) { + return f.items.each(findMatchingField); + } + } + }; - // private - validateBlur : function(){ - return !this.list || !this.list.isVisible(); + this.items.each(findMatchingField); + } + return field || null; }, - // private - initQuery : function(){ - this.doQuery(this.getRawValue()); - }, - // private - beforeBlur : function(){ - this.assertValue(); - }, + /** + * Mark fields in this form invalid in bulk. + * @param {Array/Object} errors Either an array in the form [{id:'fieldId', msg:'The message'},...] or an object hash of {id: msg, id2: msg2} + * @return {BasicForm} this + */ + markInvalid : function(errors){ + if (Ext.isArray(errors)) { + for(var i = 0, len = errors.length; i < len; i++){ + var fieldError = errors[i]; + var f = this.findField(fieldError.id); + if(f){ + f.markInvalid(fieldError.msg); + } + } + } else { + var field, id; + for(id in errors){ + if(!Ext.isFunction(errors[id]) && (field = this.findField(id))){ + field.markInvalid(errors[id]); + } + } + } - // private - postBlur : function(){ - Ext.form.ComboBox.superclass.postBlur.call(this); - this.collapse(); - this.inKeyMode = false; + return this; }, /** - * Execute a query to filter the dropdown list. Fires the {@link #beforequery} event prior to performing the - * query allowing the query action to be canceled if needed. - * @param {String} query The SQL query to execute - * @param {Boolean} forceAll true to force the query to execute even if there are currently fewer - * characters in the field than the minimum specified by the {@link #minChars} config option. It - * also clears any filter previously saved in the current store (defaults to false) + * Set values for fields in this form in bulk. + * @param {Array/Object} values Either an array in the form: +[{id:'clientName', value:'Fred. Olsen Lines'}, + {id:'portOfLoading', value:'FXT'}, + {id:'portOfDischarge', value:'OSL'} ] + * or an object hash of the form: +{ + clientName: 'Fred. Olsen Lines', + portOfLoading: 'FXT', + portOfDischarge: 'OSL' +} + * @return {BasicForm} this */ - doQuery : function(q, forceAll){ - q = Ext.isEmpty(q) ? '' : q; - var qe = { - query: q, - forceAll: forceAll, - combo: this, - cancel:false - }; - if(this.fireEvent('beforequery', qe)===false || qe.cancel){ - return false; - } - q = qe.query; - forceAll = qe.forceAll; - if(forceAll === true || (q.length >= this.minChars)){ - if(this.lastQuery !== q){ - this.lastQuery = q; - if(this.mode == 'local'){ - this.selectedIndex = -1; - if(forceAll){ - this.store.clearFilter(); - }else{ - this.store.filter(this.displayField, q); + setValues : function(values){ + if(Ext.isArray(values)){ // array of objects + for(var i = 0, len = values.length; i < len; i++){ + var v = values[i]; + var f = this.findField(v.id); + if(f){ + f.setValue(v.value); + if(this.trackResetOnLoad){ + f.originalValue = f.getValue(); + } + } + } + }else{ // object hash + var field, id; + for(id in values){ + if(!Ext.isFunction(values[id]) && (field = this.findField(id))){ + field.setValue(values[id]); + if(this.trackResetOnLoad){ + field.originalValue = field.getValue(); } - this.onLoad(); - }else{ - this.store.baseParams[this.queryParam] = q; - this.store.load({ - params: this.getParams(q) - }); - this.expand(); } - }else{ - this.selectedIndex = -1; - this.onLoad(); } } + return this; }, - // private - getParams : function(q){ - var p = {}; - //p[this.queryParam] = q; - if(this.pageSize){ - p.start = 0; - p.limit = this.pageSize; + /** + * Returns the fields in this form as an object with key/value pairs as they would be submitted using a standard form submit. + * If multiple fields exist with the same name they are returned as an array. + * Note: The values are collected from all enabled HTML input elements within the form, not from + * the Ext Field objects. This means that all returned values are Strings (or Arrays of Strings) and that the + * value can potentially be the emptyText of a field. + * @param {Boolean} asString (optional) Pass true to return the values as a string. (defaults to false, returning an Object) + * @return {String/Object} + */ + getValues : function(asString){ + var fs = Ext.lib.Ajax.serializeForm(this.el.dom); + if(asString === true){ + return fs; } - return p; + return Ext.urlDecode(fs); }, /** - * Hides the dropdown list if it is currently expanded. Fires the {@link #collapse} event on completion. + * Retrieves the fields in the form as a set of key/value pairs, using the {@link Ext.form.Field#getValue getValue()} method. + * If multiple fields exist with the same name they are returned as an array. + * @param {Boolean} dirtyOnly (optional) True to return only fields that are dirty. + * @return {Object} The values in the form */ - collapse : function(){ - if(!this.isExpanded()){ - return; - } - this.list.hide(); - Ext.getDoc().un('mousewheel', this.collapseIf, this); - Ext.getDoc().un('mousedown', this.collapseIf, this); - this.fireEvent('collapse', this); + getFieldValues : function(dirtyOnly){ + var o = {}, + n, + key, + val; + this.items.each(function(f) { + if (dirtyOnly !== true || f.isDirty()) { + n = f.getName(); + key = o[n]; + val = f.getValue(); + + if(Ext.isDefined(key)){ + if(Ext.isArray(key)){ + o[n].push(val); + }else{ + o[n] = [key, val]; + } + }else{ + o[n] = val; + } + } + }); + return o; }, - // private - collapseIf : function(e){ - if(!e.within(this.wrap) && !e.within(this.list)){ - this.collapse(); - } + /** + * Clears all invalid messages in this form. + * @return {BasicForm} this + */ + clearInvalid : function(){ + this.items.each(function(f){ + f.clearInvalid(); + }); + return this; }, /** - * Expands the dropdown list if it is currently hidden. Fires the {@link #expand} event on completion. + * Resets this form. + * @return {BasicForm} this */ - expand : function(){ - if(this.isExpanded() || !this.hasFocus){ - return; - } - if(this.bufferSize){ - this.doResize(this.bufferSize); - delete this.bufferSize; - } - this.list.alignTo.apply(this.list, [this.el].concat(this.listAlign)); - this.list.show(); - if(Ext.isGecko2){ - this.innerList.setOverflow('auto'); // necessary for FF 2.0/Mac - } - this.mon(Ext.getDoc(), { - scope: this, - mousewheel: this.collapseIf, - mousedown: this.collapseIf + reset : function(){ + this.items.each(function(f){ + f.reset(); }); - this.fireEvent('expand', this); + return this; }, /** - * @method onTriggerClick - * @hide + * Add Ext.form Components to this form's Collection. This does not result in rendering of + * the passed Component, it just enables the form to validate Fields, and distribute values to + * Fields. + * You will not usually call this function. In order to be rendered, a Field must be added + * to a {@link Ext.Container Container}, usually an {@link Ext.form.FormPanel FormPanel}. + * The FormPanel to which the field is added takes care of adding the Field to the BasicForm's + * collection. + * @param {Field} field1 + * @param {Field} field2 (optional) + * @param {Field} etc (optional) + * @return {BasicForm} this */ - // private - // Implements the default empty TriggerField.onTriggerClick function - onTriggerClick : function(){ - if(this.readOnly || this.disabled){ - return; - } - if(this.isExpanded()){ - this.collapse(); - this.el.focus(); - }else { - this.onFocus({}); - if(this.triggerAction == 'all') { - this.doQuery(this.allQuery, true); - } else { - this.doQuery(this.getRawValue()); - } - this.el.focus(); - } - } + add : function(){ + this.items.addAll(Array.prototype.slice.call(arguments, 0)); + return this; + }, /** - * @hide - * @method autoSize + * Removes a field from the items collection (does NOT remove its markup). + * @param {Field} field + * @return {BasicForm} this */ + remove : function(field){ + this.items.remove(field); + return this; + }, + /** - * @cfg {Boolean} grow @hide + * Iterates through the {@link Ext.form.Field Field}s which have been {@link #add add}ed to this BasicForm, + * checks them for an id attribute, and calls {@link Ext.form.Field#applyToMarkup} on the existing dom element with that id. + * @return {BasicForm} this */ + render : function(){ + this.items.each(function(f){ + if(f.isFormField && !f.rendered && document.getElementById(f.id)){ // if the element exists + f.applyToMarkup(f.id); + } + }); + return this; + }, + /** - * @cfg {Number} growMin @hide + * Calls {@link Ext#apply} for all fields in this form with the passed object. + * @param {Object} values + * @return {BasicForm} this */ + applyToFields : function(o){ + this.items.each(function(f){ + Ext.apply(f, o); + }); + return this; + }, + /** - * @cfg {Number} growMax @hide + * Calls {@link Ext#applyIf} for all field in this form with the passed object. + * @param {Object} values + * @return {BasicForm} this */ + applyIfToFields : function(o){ + this.items.each(function(f){ + Ext.applyIf(f, o); + }); + return this; + }, + callFieldMethod : function(fnName, args){ + args = args || []; + this.items.each(function(f){ + if(Ext.isFunction(f[fnName])){ + f[fnName].apply(f, args); + } + }); + return this; + } }); -Ext.reg('combo', Ext.form.ComboBox); + +// back compat +Ext.BasicForm = Ext.form.BasicForm; /** - * @class Ext.form.Checkbox - * @extends Ext.form.Field - * Single checkbox field. Can be used as a direct replacement for traditional checkbox fields. + * @class Ext.form.FormPanel + * @extends Ext.Panel + * Standard form container. + * + * Layout + * By default, FormPanel is configured with layout:'form' to use an {@link Ext.layout.FormLayout} + * layout manager, which styles and renders fields and labels correctly. When nesting additional Containers + * within a FormPanel, you should ensure that any descendant Containers which host input Fields use the + * {@link Ext.layout.FormLayout} layout manager. + * + * BasicForm + * Although not listed as configuration options of FormPanel, the FormPanel class accepts all + * of the config options required to configure its internal {@link Ext.form.BasicForm} for: + * + * {@link Ext.form.BasicForm#fileUpload file uploads} + * functionality for {@link Ext.form.BasicForm#doAction loading, validating and submitting} the form + * + * + * Note: If subclassing FormPanel, any configuration options for the BasicForm must be applied to + * the initialConfig property of the FormPanel. Applying {@link Ext.form.BasicForm BasicForm} + * configuration settings to this will not affect the BasicForm's configuration. + * + * Form Validation + * For information on form validation see the following: + * + * {@link Ext.form.TextField} + * {@link Ext.form.VTypes} + * {@link Ext.form.BasicForm#doAction BasicForm.doAction clientValidation notes} + * {@link Ext.form.FormPanel#monitorValid monitorValid} + * + * + * Form Submission + * By default, Ext Forms are submitted through Ajax, using {@link Ext.form.Action}. To enable normal browser + * submission of the {@link Ext.form.BasicForm BasicForm} contained in this FormPanel, see the + * {@link Ext.form.BasicForm#standardSubmit standardSubmit} option. + * * @constructor - * Creates a new Checkbox * @param {Object} config Configuration options - * @xtype checkbox + * @xtype form */ -Ext.form.Checkbox = Ext.extend(Ext.form.Field, { - /** - * @cfg {String} focusClass The CSS class to use when the checkbox receives focus (defaults to undefined) - */ - focusClass : undefined, - /** - * @cfg {String} fieldClass The default CSS class for the checkbox (defaults to 'x-form-field') - */ - fieldClass : 'x-form-field', - /** - * @cfg {Boolean} checked true if the checkbox should render initially checked (defaults to false) - */ - checked : false, +Ext.FormPanel = Ext.extend(Ext.Panel, { /** - * @cfg {String/Object} autoCreate A DomHelper element spec, or true for a default element spec (defaults to - * {tag: 'input', type: 'checkbox', autocomplete: 'off'}) + * @cfg {String} formId (optional) The id of the FORM tag (defaults to an auto-generated id). */ - defaultAutoCreate : { tag: 'input', type: 'checkbox', autocomplete: 'off'}, /** - * @cfg {String} boxLabel The text that appears beside the checkbox + * @cfg {Boolean} hideLabels + * true to hide field labels by default (sets display:none). Defaults to + * false. + * Also see {@link Ext.Component}.{@link Ext.Component#hideLabel hideLabel}. */ /** - * @cfg {String} inputValue The value that should go into the generated input element's value attribute + * @cfg {Number} labelPad + * The default padding in pixels for field labels (defaults to 5). labelPad only + * applies if {@link #labelWidth} is also specified, otherwise it will be ignored. */ /** - * @cfg {Function} handler A function called when the {@link #checked} value changes (can be used instead of - * handling the check event). The handler is passed the following parameters: - * - * checkbox : Ext.form.CheckboxThe Checkbox being toggled. - * checked : BooleanThe new checked state of the checkbox. - * + * @cfg {String} labelSeparator + * See {@link Ext.Component}.{@link Ext.Component#labelSeparator labelSeparator} */ /** - * @cfg {Object} scope An object to use as the scope ('this' reference) of the {@link #handler} function - * (defaults to this Checkbox). + * @cfg {Number} labelWidth The width of labels in pixels. This property cascades to child containers + * and can be overridden on any child container (e.g., a fieldset can specify a different labelWidth + * for its fields) (defaults to 100). */ - - // private - actionMode : 'wrap', - - // private - initComponent : function(){ - Ext.form.Checkbox.superclass.initComponent.call(this); - this.addEvents( - /** - * @event check - * Fires when the checkbox is checked or unchecked. - * @param {Ext.form.Checkbox} this This checkbox - * @param {Boolean} checked The new checked value - */ - 'check' - ); - }, - - // private - onResize : function(){ - Ext.form.Checkbox.superclass.onResize.apply(this, arguments); - if(!this.boxLabel && !this.fieldLabel){ - this.el.alignTo(this.wrap, 'c-c'); - } - }, - - // private - initEvents : function(){ - Ext.form.Checkbox.superclass.initEvents.call(this); - this.mon(this.el, { - scope: this, - click: this.onClick, - change: this.onClick - }); - }, - /** - * @hide - * Overridden and disabled. The editor element does not support standard valid/invalid marking. - * @method + * @cfg {String} itemCls A css class to apply to the x-form-item of fields. This property cascades to child containers. */ - markInvalid : Ext.emptyFn, /** - * @hide - * Overridden and disabled. The editor element does not support standard valid/invalid marking. - * @method + * @cfg {Array} buttons + * An array of {@link Ext.Button}s or {@link Ext.Button} configs used to add buttons to the footer of this FormPanel. + * Buttons in the footer of a FormPanel may be configured with the option formBind: true. This causes + * the form's {@link #monitorValid valid state monitor task} to enable/disable those Buttons depending on + * the form's valid/invalid state. */ - clearInvalid : Ext.emptyFn, - - // private - onRender : function(ct, position){ - Ext.form.Checkbox.superclass.onRender.call(this, ct, position); - if(this.inputValue !== undefined){ - this.el.dom.value = this.inputValue; - } - this.wrap = this.el.wrap({cls: 'x-form-check-wrap'}); - if(this.boxLabel){ - this.wrap.createChild({tag: 'label', htmlFor: this.el.id, cls: 'x-form-cb-label', html: this.boxLabel}); - } - if(this.checked){ - this.setValue(true); - }else{ - this.checked = this.el.dom.checked; - } - // Need to repaint for IE, otherwise positioning is broken - if(Ext.isIE){ - this.wrap.repaint(); - } - this.resizeEl = this.positionEl = this.wrap; - }, - - // private - onDestroy : function(){ - Ext.destroy(this.wrap); - Ext.form.Checkbox.superclass.onDestroy.call(this); - }, - // private - initValue : function() { - this.originalValue = this.getValue(); - }, /** - * Returns the checked state of the checkbox. - * @return {Boolean} True if checked, else false + * @cfg {Number} minButtonWidth Minimum width of all buttons in pixels (defaults to 75). */ - getValue : function(){ - if(this.rendered){ - return this.el.dom.checked; - } - return this.checked; - }, - - // private - onClick : function(){ - if(this.el.dom.checked != this.checked){ - this.setValue(this.el.dom.checked); - } - }, + minButtonWidth : 75, - /** - * Sets the checked state of the checkbox, fires the 'check' event, and calls a - * {@link #handler} (if configured). - * @param {Boolean/String} checked The following values will check the checkbox: - * true, 'true', '1', or 'on'. Any other value will uncheck the checkbox. - * @return {Ext.form.Field} this - */ - setValue : function(v){ - var checked = this.checked ; - this.checked = (v === true || v === 'true' || v == '1' || String(v).toLowerCase() == 'on'); - if(this.rendered){ - this.el.dom.checked = this.checked; - this.el.dom.defaultChecked = this.checked; - } - if(checked != this.checked){ - this.fireEvent('check', this, this.checked); - if(this.handler){ - this.handler.call(this.scope || this, this, this.checked); - } - } - return this; - } -}); -Ext.reg('checkbox', Ext.form.Checkbox); -/** - * @class Ext.form.CheckboxGroup - * @extends Ext.form.Field - * A grouping container for {@link Ext.form.Checkbox} controls. - * Sample usage: - * -var myCheckboxGroup = new Ext.form.CheckboxGroup({ - id:'myGroup', - xtype: 'checkboxgroup', - fieldLabel: 'Single Column', - itemCls: 'x-check-group-alt', - // Put all controls in a single column with width 100% - columns: 1, - items: [ - {boxLabel: 'Item 1', name: 'cb-col-1'}, - {boxLabel: 'Item 2', name: 'cb-col-2', checked: true}, - {boxLabel: 'Item 3', name: 'cb-col-3'} - ] -}); - * - * @constructor - * Creates a new CheckboxGroup - * @param {Object} config Configuration options - * @xtype checkboxgroup - */ -Ext.form.CheckboxGroup = Ext.extend(Ext.form.Field, { - /** - * @cfg {Array} items An Array of {@link Ext.form.Checkbox Checkbox}es or Checkbox config objects - * to arrange in the group. - */ - /** - * @cfg {String/Number/Array} columns Specifies the number of columns to use when displaying grouped - * checkbox/radio controls using automatic layout. This config can take several types of values: - * 'auto' : The controls will be rendered one per column on one row and the width - * of each column will be evenly distributed based on the width of the overall field container. This is the default. - * Number : If you specific a number (e.g., 3) that number of columns will be - * created and the contained controls will be automatically distributed based on the value of {@link #vertical}. - * Array : ObjectYou can also specify an array of column widths, mixing integer - * (fixed width) and float (percentage width) values as needed (e.g., [100, .25, .75]). Any integer values will - * be rendered first, then any float values will be calculated as a percentage of the remaining space. Float - * values do not have to add up to 1 (100%) although if you want the controls to take up the entire field - * container you should do so. + /** + * @cfg {String} labelAlign The label alignment value used for the text-align specification + * for the container. Valid values are "left", "top" or "right" + * (defaults to "left"). This property cascades to child containers and can be + * overridden on any child container (e.g., a fieldset can specify a different labelAlign + * for its fields). */ - columns : 'auto', + labelAlign : 'left', + /** - * @cfg {Boolean} vertical True to distribute contained controls across columns, completely filling each column - * top to bottom before starting on the next column. The number of controls in each column will be automatically - * calculated to keep columns as even as possible. The default value is false, so that controls will be added - * to columns one at a time, completely filling each row left to right before starting on the next row. + * @cfg {Boolean} monitorValid If true, the form monitors its valid state client-side and + * regularly fires the {@link #clientvalidation} event passing that state. + * When monitoring valid state, the FormPanel enables/disables any of its configured + * {@link #buttons} which have been configured with formBind: true depending + * on whether the {@link Ext.form.BasicForm#isValid form is valid} or not. Defaults to false */ - vertical : false, + monitorValid : false, + /** - * @cfg {Boolean} allowBlank False to validate that at least one item in the group is checked (defaults to true). - * If no items are selected at validation time, {@link @blankText} will be used as the error text. + * @cfg {Number} monitorPoll The milliseconds to poll valid state, ignored if monitorValid is not true (defaults to 200) */ - allowBlank : true, + monitorPoll : 200, + /** - * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails (defaults to "You must - * select at least one item in this group") + * @cfg {String} layout Defaults to 'form'. Normally this configuration property should not be altered. + * For additional details see {@link Ext.layout.FormLayout} and {@link Ext.Container#layout Ext.Container.layout}. */ - blankText : "You must select at least one item in this group", + layout : 'form', // private - defaultType : 'checkbox', + initComponent : function(){ + this.form = this.createForm(); + Ext.FormPanel.superclass.initComponent.call(this); - // private - groupCls : 'x-form-check-group', + this.bodyCfg = { + tag: 'form', + cls: this.baseCls + '-body', + method : this.method || 'POST', + id : this.formId || Ext.id() + }; + if(this.fileUpload) { + this.bodyCfg.enctype = 'multipart/form-data'; + } + this.initItems(); - // private - initComponent: function(){ this.addEvents( /** - * @event change - * Fires when the state of a child checkbox changes. - * @param {Ext.form.CheckboxGroup} this - * @param {Array} checked An array containing the checked boxes. + * @event clientvalidation + * If the monitorValid config option is true, this event fires repetitively to notify of valid state + * @param {Ext.form.FormPanel} this + * @param {Boolean} valid true if the form has passed client-side validation */ - 'change' + 'clientvalidation' ); - this.on('change', this.validate, this); - Ext.form.CheckboxGroup.superclass.initComponent.call(this); + + this.relayEvents(this.form, ['beforeaction', 'actionfailed', 'actioncomplete']); }, // private - onRender : function(ct, position){ - if(!this.el){ - var panelCfg = { - autoEl: { - id: this.id - }, - cls: this.groupCls, - layout: 'column', - renderTo: ct, - bufferResize: false // Default this to false, since it doesn't really have a proper ownerCt. - }; - var colCfg = { - xtype: 'container', - defaultType: this.defaultType, - layout: 'form', - defaults: { - hideLabel: true, - anchor: '100%' - } - }; - - if(this.items[0].items){ - - // The container has standard ColumnLayout configs, so pass them in directly - - Ext.apply(panelCfg, { - layoutConfig: {columns: this.items.length}, - defaults: this.defaults, - items: this.items - }); - for(var i=0, len=this.items.length; i0 && i%rows==0){ - ri++; - } - if(this.items[i].fieldLabel){ - this.items[i].hideLabel = false; - } - cols[ri].items.push(this.items[i]); - }; - }else{ - for(var i=0, len=this.items.length; i -// call with name and value -myCheckboxGroup.setValue('cb-col-1', true); -// call with an array of boolean values -myCheckboxGroup.setValue([true, false, false]); -// call with an object literal specifying item:value pairs -myCheckboxGroup.setValue({ - 'cb-col-2': false, - 'cb-col-3': true -}); -// use comma separated string to set items with name to true (checked) -myCheckboxGroup.setValue('cb-col-1,cb-col-3'); - *
- * See {@link Ext.form.Checkbox#setValue} for additional information. - * @param {Mixed} id The checkbox to check, or as described by example shown. - * @param {Boolean} value (optional) The value to set the item. - * @return {Ext.form.CheckboxGroup} this + * Starts monitoring of the valid state of this form. Usually this is done by passing the config + * option "monitorValid" */ - setValue: function(){ - if(this.rendered){ - this.onSetValue.apply(this, arguments); - }else{ - this.buffered = true; - this.value = arguments; + startMonitoring : function(){ + if(!this.validTask){ + this.validTask = new Ext.util.TaskRunner(); + this.validTask.start({ + run : this.bindHandler, + interval : this.monitorPoll || 200, + scope: this + }); } - return this; }, - onSetValue: function(id, value){ - if(arguments.length == 1){ - if(Ext.isArray(id)){ - // an array of boolean values - Ext.each(id, function(val, idx){ - var item = this.items.itemAt(idx); - if(item){ - item.setValue(val); - } - }, this); - }else if(Ext.isObject(id)){ - // set of name/value pairs - for(var i in id){ - var f = this.getBox(i); - if(f){ - f.setValue(id[i]); - } - } - }else{ - this.setValueForItem(id); - } - }else{ - var f = this.getBox(id); - if(f){ - f.setValue(value); - } + /** + * Stops monitoring of the valid state of this form + */ + stopMonitoring : function(){ + if(this.validTask){ + this.validTask.stopAll(); + this.validTask = null; } }, - // private - beforeDestroy: function(){ - Ext.destroy(this.panel); - Ext.form.CheckboxGroup.superclass.beforeDestroy.call(this); + /** + * This is a proxy for the underlying BasicForm's {@link Ext.form.BasicForm#load} call. + * @param {Object} options The options to pass to the action (see {@link Ext.form.BasicForm#doAction} for details) + */ + load : function(){ + this.form.load.apply(this.form, arguments); + }, + // private + onDisable : function(){ + Ext.FormPanel.superclass.onDisable.call(this); + if(this.form){ + this.form.items.each(function(){ + this.disable(); + }); + } }, - setValueForItem : function(val){ - val = String(val).split(','); - this.eachItem(function(item){ - if(val.indexOf(item.inputValue)> -1){ - item.setValue(true); - } - }); + // private + onEnable : function(){ + Ext.FormPanel.superclass.onEnable.call(this); + if(this.form){ + this.form.items.each(function(){ + this.enable(); + }); + } }, // private - getBox : function(id){ - var box = null; - this.eachItem(function(f){ - if(id == f || f.dataIndex == id || f.id == id || f.getName() == id){ - box = f; + bindHandler : function(){ + var valid = true; + this.form.items.each(function(f){ + if(!f.isValid(true)){ + valid = false; return false; } }); - return box; - }, + if(this.fbar){ + var fitems = this.fbar.items.items; + for(var i = 0, len = fitems.length; i < len; i++){ + var btn = fitems[i]; + if(btn.formBind === true && btn.disabled === valid){ + btn.setDisabled(!valid); + } + } + } + this.fireEvent('clientvalidation', this, valid); + } +}); +Ext.reg('form', Ext.FormPanel); +Ext.form.FormPanel = Ext.FormPanel;/** + * @class Ext.form.FieldSet + * @extends Ext.Panel + * Standard container used for grouping items within a {@link Ext.form.FormPanel form}. + * +var form = new Ext.FormPanel({ + title: 'Simple Form with FieldSets', + labelWidth: 75, // label settings here cascade unless overridden + url: 'save-form.php', + frame:true, + bodyStyle:'padding:5px 5px 0', + width: 700, + renderTo: document.body, + layout:'column', // arrange items in columns + defaults: { // defaults applied to items + layout: 'form', + border: false, + bodyStyle: 'padding:4px' + }, + items: [{ + // Fieldset in Column 1 + xtype:'fieldset', + columnWidth: 0.5, + title: 'Fieldset 1', + collapsible: true, + autoHeight:true, + defaults: { + anchor: '-20' // leave room for error icon + }, + defaultType: 'textfield', + items :[{ + fieldLabel: 'Field 1' + }, { + fieldLabel: 'Field 2' + }, { + fieldLabel: 'Field 3' + } + ] + },{ + // Fieldset in Column 2 - Panel inside + xtype:'fieldset', + title: 'Show Panel', // title, header, or checkboxToggle creates fieldset header + autoHeight:true, + columnWidth: 0.5, + checkboxToggle: true, + collapsed: true, // fieldset initially collapsed + layout:'anchor', + items :[{ + xtype: 'panel', + anchor: '100%', + title: 'Panel inside a fieldset', + frame: true, + height: 100 + }] + }] +}); + * + * @constructor + * @param {Object} config Configuration options + * @xtype fieldset + */ +Ext.form.FieldSet = Ext.extend(Ext.Panel, { + /** + * @cfg {Mixed} checkboxToggle true to render a checkbox into the fieldset frame just + * in front of the legend to expand/collapse the fieldset when the checkbox is toggled. (defaults + * to false). + * A {@link Ext.DomHelper DomHelper} element spec may also be specified to create the checkbox. + * If true is specified, the default DomHelper config object used to create the element + * is: + * {tag: 'input', type: 'checkbox', name: this.checkboxName || this.id+'-checkbox'} + * + */ /** - * Gets an array of the selected {@link Ext.form.Checkbox} in the group. - * @return {Array} An array of the selected checkboxes. + * @cfg {String} checkboxName The name to assign to the fieldset's checkbox if {@link #checkboxToggle} = true + * (defaults to '[checkbox id]-checkbox'). */ - getValue : function(){ - var out = []; - this.eachItem(function(item){ - if(item.checked){ - out.push(item); + /** + * @cfg {Boolean} collapsible + * true to make the fieldset collapsible and have the expand/collapse toggle button automatically + * rendered into the legend element, false to keep the fieldset statically sized with no collapse + * button (defaults to false). Another option is to configure {@link #checkboxToggle}. + */ + /** + * @cfg {Number} labelWidth The width of labels. This property cascades to child containers. + */ + /** + * @cfg {String} itemCls A css class to apply to the x-form-item of fields (see + * {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl} for details). + * This property cascades to child containers. + */ + /** + * @cfg {String} baseCls The base CSS class applied to the fieldset (defaults to 'x-fieldset'). + */ + baseCls : 'x-fieldset', + /** + * @cfg {String} layout The {@link Ext.Container#layout} to use inside the fieldset (defaults to 'form'). + */ + layout : 'form', + /** + * @cfg {Boolean} animCollapse + * true to animate the transition when the panel is collapsed, false to skip the + * animation (defaults to false). + */ + animCollapse : false, + + // private + onRender : function(ct, position){ + if(!this.el){ + this.el = document.createElement('fieldset'); + this.el.id = this.id; + if (this.title || this.header || this.checkboxToggle) { + this.el.appendChild(document.createElement('legend')).className = this.baseCls + '-header'; } - }); - return out; + } + + Ext.form.FieldSet.superclass.onRender.call(this, ct, position); + + if(this.checkboxToggle){ + var o = typeof this.checkboxToggle == 'object' ? + this.checkboxToggle : + {tag: 'input', type: 'checkbox', name: this.checkboxName || this.id+'-checkbox'}; + this.checkbox = this.header.insertFirst(o); + this.checkbox.dom.checked = !this.collapsed; + this.mon(this.checkbox, 'click', this.onCheckClick, this); + } + }, + + // private + onCollapse : function(doAnim, animArg){ + if(this.checkbox){ + this.checkbox.dom.checked = false; + } + Ext.form.FieldSet.superclass.onCollapse.call(this, doAnim, animArg); + }, // private - eachItem: function(fn){ - if(this.items && this.items.each){ - this.items.each(fn, this); + onExpand : function(doAnim, animArg){ + if(this.checkbox){ + this.checkbox.dom.checked = true; } + Ext.form.FieldSet.superclass.onExpand.call(this, doAnim, animArg); }, /** - * @cfg {String} name - * @hide + * This function is called by the fieldset's checkbox when it is toggled (only applies when + * checkboxToggle = true). This method should never be called externally, but can be + * overridden to provide custom behavior when the checkbox is toggled if needed. */ + onCheckClick : function(){ + this[this.checkbox.dom.checked ? 'expand' : 'collapse'](); + } /** - * @method getRawValue + * @cfg {String/Number} activeItem * @hide */ - getRawValue : Ext.emptyFn, - /** - * @method setRawValue + * @cfg {Mixed} applyTo * @hide */ - setRawValue : Ext.emptyFn - -}); - -Ext.reg('checkboxgroup', Ext.form.CheckboxGroup); -/** - * @class Ext.form.Radio - * @extends Ext.form.Checkbox - * Single radio field. Same as Checkbox, but provided as a convenience for automatically setting the input type. - * Radio grouping is handled automatically by the browser if you give each radio in a group the same name. - * @constructor - * Creates a new Radio - * @param {Object} config Configuration options - * @xtype radio - */ -Ext.form.Radio = Ext.extend(Ext.form.Checkbox, { - inputType: 'radio', - /** - * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide - * @method + * @cfg {Boolean} bodyBorder + * @hide */ - markInvalid : Ext.emptyFn, /** - * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide - * @method + * @cfg {Boolean} border + * @hide */ - clearInvalid : Ext.emptyFn, - /** - * If this radio is part of a group, it will return the selected value - * @return {String} + * @cfg {Boolean/Number} bufferResize + * @hide */ - getGroupValue : function(){ - var p = this.el.up('form') || Ext.getBody(); - var c = p.child('input[name='+this.el.dom.name+']:checked', true); - return c ? c.value : null; - }, - - // private - onClick : function(){ - if(this.el.dom.checked != this.checked){ - var els = this.getCheckEl().select('input[name=' + this.el.dom.name + ']'); - els.each(function(el){ - if(el.dom.id == this.id){ - this.setValue(true); - }else{ - Ext.getCmp(el.dom.id).setValue(false); - } - }, this); - } - }, - /** - * Sets either the checked/unchecked status of this Radio, or, if a string value - * is passed, checks a sibling Radio of the same name whose value is the value specified. - * @param value {String/Boolean} Checked value, or the value of the sibling radio button to check. - * @return {Ext.form.Field} this + * @cfg {Boolean} collapseFirst + * @hide */ - setValue : function(v){ - if (typeof v == 'boolean') { - Ext.form.Radio.superclass.setValue.call(this, v); - } else if (this.rendered) { - var r = this.getCheckEl().child('input[name=' + this.el.dom.name + '][value=' + v + ']', true); - if(r){ - Ext.getCmp(r.id).setValue(true); - } - } - return this; - }, - - // private - getCheckEl: function(){ - if(this.inGroup){ - return this.el.up('.x-form-radio-group') - } - return this.el.up('form') || Ext.getBody(); - } -}); -Ext.reg('radio', Ext.form.Radio); -/** - * @class Ext.form.RadioGroup - * @extends Ext.form.CheckboxGroup - * A grouping container for {@link Ext.form.Radio} controls. - * @constructor - * Creates a new RadioGroup - * @param {Object} config Configuration options - * @xtype radiogroup - */ -Ext.form.RadioGroup = Ext.extend(Ext.form.CheckboxGroup, { /** - * @cfg {Array} items An Array of {@link Ext.form.Radio Radio}s or Radio config objects - * to arrange in the group. + * @cfg {String} defaultType + * @hide */ /** - * @cfg {Boolean} allowBlank True to allow every item in the group to be blank (defaults to true). - * If allowBlank = false and no items are selected at validation time, {@link @blankText} will - * be used as the error text. + * @cfg {String} disabledClass + * @hide */ - allowBlank : true, /** - * @cfg {String} blankText Error text to display if the {@link #allowBlank} validation fails - * (defaults to 'You must select one item in this group') + * @cfg {String} elements + * @hide */ - blankText : 'You must select one item in this group', - - // private - defaultType : 'radio', - - // private - groupCls : 'x-form-radio-group', - /** - * @event change - * Fires when the state of a child radio changes. - * @param {Ext.form.RadioGroup} this - * @param {Ext.form.Radio} checked The checked radio + * @cfg {Boolean} floating + * @hide */ - /** - * Gets the selected {@link Ext.form.Radio} in the group, if it exists. - * @return {Ext.form.Radio} The selected radio. + * @cfg {Boolean} footer + * @hide */ - getValue : function(){ - var out = null; - this.eachItem(function(item){ - if(item.checked){ - out = item; - return false; - } - }); - return out; - }, - /** - * Sets the checked radio in the group. - * @param {String/Ext.form.Radio} id The radio to check. - * @param {Boolean} value The value to set the radio. - * @return {Ext.form.RadioGroup} this + * @cfg {Boolean} frame + * @hide */ - onSetValue : function(id, value){ - if(arguments.length > 1){ - var f = this.getBox(id); - if(f){ - f.setValue(value); - if(f.checked){ - this.eachItem(function(item){ - if (item !== f){ - item.setValue(false); - } - }); - } - } - }else{ - this.setValueForItem(id); - } - }, - - setValueForItem : function(val){ - val = String(val).split(',')[0]; - this.eachItem(function(item){ - item.setValue(val == item.inputValue); - }); - }, - - // private - fireChecked : function(){ - if(!this.checkTask){ - this.checkTask = new Ext.util.DelayedTask(this.bufferChecked, this); - } - this.checkTask.delay(10); - }, - - // private - bufferChecked : function(){ - var out = null; - this.eachItem(function(item){ - if(item.checked){ - out = item; - return false; - } - }); - this.fireEvent('change', this, out); - }, - - onDestroy : function(){ - if(this.checkTask){ - this.checkTask.cancel(); - this.checkTask = null; - } - Ext.form.RadioGroup.superclass.onDestroy.call(this); - } - -}); - -Ext.reg('radiogroup', Ext.form.RadioGroup); -/** - * @class Ext.form.Hidden - * @extends Ext.form.Field - * A basic hidden field for storing hidden values in forms that need to be passed in the form submit. - * @constructor - * Create a new Hidden field. - * @param {Object} config Configuration options - * @xtype hidden - */ -Ext.form.Hidden = Ext.extend(Ext.form.Field, { - // private - inputType : 'hidden', - - // private - onRender : function(){ - Ext.form.Hidden.superclass.onRender.apply(this, arguments); - }, - - // private - initEvents : function(){ - this.originalValue = this.getValue(); - }, - - // These are all private overrides - setSize : Ext.emptyFn, - setWidth : Ext.emptyFn, - setHeight : Ext.emptyFn, - setPosition : Ext.emptyFn, - setPagePosition : Ext.emptyFn, - markInvalid : Ext.emptyFn, - clearInvalid : Ext.emptyFn -}); -Ext.reg('hidden', Ext.form.Hidden);/** - * @class Ext.form.BasicForm - * @extends Ext.util.Observable - * Encapsulates the DOM <form> element at the heart of the {@link Ext.form.FormPanel FormPanel} class, and provides - * input field management, validation, submission, and form loading services. - * By default, Ext Forms are submitted through Ajax, using an instance of {@link Ext.form.Action.Submit}. - * To enable normal browser submission of an Ext Form, use the {@link #standardSubmit} config option. - * File Uploads - * {@link #fileUpload File uploads} are not performed using Ajax submission, 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. - * Characters which are significant to an HTML parser must be sent as HTML entities, so encode - * "<" as "<", "&" as "&" etc. - * 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 {Mixed} el The form element or its id - * @param {Object} config Configuration options - */ -Ext.form.BasicForm = Ext.extend(Ext.util.Observable, { - - constructor: function(el, config){ - Ext.apply(this, config); - if(Ext.isString(this.paramOrder)){ - this.paramOrder = this.paramOrder.split(/[\s,|]/); - } - /** - * A {@link Ext.util.MixedCollection MixedCollection} containing all the Ext.form.Fields in this form. - * @type MixedCollection - * @property items - */ - this.items = new Ext.util.MixedCollection(false, function(o){ - return o.getItemId(); - }); - this.addEvents( - /** - * @event beforeaction - * Fires before any action is performed. Return false to cancel the action. - * @param {Form} this - * @param {Action} action The {@link Ext.form.Action} to be performed - */ - 'beforeaction', - /** - * @event actionfailed - * Fires when an action fails. - * @param {Form} this - * @param {Action} action The {@link Ext.form.Action} that failed - */ - 'actionfailed', - /** - * @event actioncomplete - * Fires when an action is completed. - * @param {Form} this - * @param {Action} action The {@link Ext.form.Action} that completed - */ - 'actioncomplete' - ); - - if(el){ - this.initEl(el); - } - Ext.form.BasicForm.superclass.constructor.call(this); - }, - /** - * @cfg {String} method - * The request method to use (GET or POST) for form actions if one isn't supplied in the action options. + * @cfg {Boolean} header + * @hide */ /** - * @cfg {DataReader} reader - * An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to read - * data when executing 'load' actions. This is optional as there is built-in - * support for processing JSON. For additional information on using an XMLReader - * see the example provided in examples/form/xml-form.html. + * @cfg {Boolean} headerAsText + * @hide */ /** - * @cfg {DataReader} errorReader - * An Ext.data.DataReader (e.g. {@link Ext.data.XmlReader}) to be used to - * read field error messages returned from 'submit' actions. This is optional - * as there is built-in support for processing JSON. - * The Records which provide messages for the invalid Fields must use the - * Field name (or id) as the Record ID, and must contain a field called 'msg' - * which contains the error message. - * The errorReader does not have to be a full-blown implementation of a - * DataReader. It simply needs to implement a read(xhr) function - * which returns an Array of Records in an object with the following - * structure: -{ - records: recordArray -} - + * @cfg {Boolean} hideCollapseTool + * @hide */ /** - * @cfg {String} url - * The URL to use for form actions if one isn't supplied in the - * {@link #doAction doAction} options. + * @cfg {String} iconCls + * @hide */ /** - * @cfg {Boolean} fileUpload - * Set to true if this form is a file upload. - * 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. - * Characters which are significant to an HTML parser must be sent as HTML entities, so encode - * "<" as "<", "&" as "&" etc. - * 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. + * @cfg {Boolean/String} shadow + * @hide */ /** - * @cfg {Object} baseParams - * Parameters to pass with all requests. e.g. baseParams: {id: '123', foo: 'bar'}. - * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. + * @cfg {Number} shadowOffset + * @hide */ /** - * @cfg {Number} timeout Timeout for form actions in seconds (default is 30 seconds). + * @cfg {Boolean} shim + * @hide */ - timeout: 30, - /** - * @cfg {Object} api (Optional) If specified load and submit actions will be handled - * with {@link Ext.form.Action.DirectLoad} and {@link Ext.form.Action.DirectSubmit}. - * Methods which have been imported by Ext.Direct can be specified here to load and submit - * forms. - * Such as the following: -api: { - load: App.ss.MyProfile.load, - submit: App.ss.MyProfile.submit -} - - * Load actions can use {@link #paramOrder} or {@link #paramsAsHash} - * to customize how the load method is invoked. - * Submit actions will always use a standard form submit. The formHandler configuration must - * be set on the associated server-side method which has been imported by Ext.Direct + * @cfg {Object/Array} tbar + * @hide */ - /** - * @cfg {Array/String} paramOrder A list of params to be executed server side. - * Defaults to undefined. Only used for the {@link #api} - * load configuration. - * Specify the params in the order in which they must be executed on the - * server-side as either (1) an Array of String values, or (2) a String of params - * delimited by either whitespace, comma, or pipe. For example, - * any of the following would be acceptable: -paramOrder: ['param1','param2','param3'] -paramOrder: 'param1 param2 param3' -paramOrder: 'param1,param2,param3' -paramOrder: 'param1|param2|param' - + * @cfg {Array} tools + * @hide */ - paramOrder: undefined, - /** - * @cfg {Boolean} paramsAsHash Only used for the {@link #api} - * load configuration. Send parameters as a collection of named - * arguments (defaults to false). Providing a - * {@link #paramOrder} nullifies this configuration. + * @cfg {Ext.Template/Ext.XTemplate} toolTemplate + * @hide */ - paramsAsHash: false, - /** - * @cfg {String} waitTitle - * The default title to show for the waiting message box (defaults to 'Please Wait...') + * @cfg {String} xtype + * @hide */ - waitTitle: 'Please Wait...', - - // private - activeAction : null, - /** - * @cfg {Boolean} trackResetOnLoad If set to true, {@link #reset}() resets to the last loaded - * or {@link #setValues}() data instead of when the form was first created. Defaults to false. + * @property header + * @hide */ - trackResetOnLoad : false, - /** - * @cfg {Boolean} standardSubmit - * If set to true, standard HTML form submits are used instead - * of XHR (Ajax) style form submissions. Defaults to false. - * Note: When using standardSubmit, the - * options to {@link #submit} are ignored because - * Ext's Ajax infrastracture is bypassed. To pass extra parameters (e.g. - * baseParams and params), utilize hidden fields - * to submit extra data, for example: - * -new Ext.FormPanel({ - standardSubmit: true, - baseParams: { - foo: 'bar' - }, - {@link url}: 'myProcess.php', - items: [{ - xtype: 'textfield', - name: 'userName' - }], - buttons: [{ - text: 'Save', - handler: function(){ - var fp = this.ownerCt.ownerCt, - form = fp.getForm(); - if (form.isValid()) { - // check if there are baseParams and if - // hiddent items have been added already - if (fp.baseParams && !fp.paramsAdded) { - // add hidden items for all baseParams - for (i in fp.baseParams) { - fp.add({ - xtype: 'hidden', - name: i, - value: fp.baseParams[i] - }); - } - fp.doLayout(); - // set a custom flag to prevent re-adding - fp.paramsAdded = true; - } - form.{@link #submit}(); - } - } - }] + * @property footer + * @hide + */ + /** + * @method focus + * @hide + */ + /** + * @method getBottomToolbar + * @hide + */ + /** + * @method getTopToolbar + * @hide + */ + /** + * @method setIconClass + * @hide + */ + /** + * @event activate + * @hide + */ + /** + * @event beforeclose + * @hide + */ + /** + * @event bodyresize + * @hide + */ + /** + * @event close + * @hide + */ + /** + * @event deactivate + * @hide + */ +}); +Ext.reg('fieldset', Ext.form.FieldSet);/** + * @class Ext.form.HtmlEditor + * @extends Ext.form.Field + * Provides a lightweight HTML Editor component. Some toolbar features are not supported by Safari and will be + * automatically hidden when needed. These are noted in the config options where appropriate. + * The editor's toolbar buttons have tooltips defined in the {@link #buttonTips} property, but they are not + * enabled by default unless the global {@link Ext.QuickTips} singleton is {@link Ext.QuickTips#init initialized}. + * Note: The focus/blur and validation marking functionality inherited from Ext.form.Field is NOT + * supported by this editor. + * An Editor is a sensitive component that can't be used in all spots standard fields can be used. Putting an Editor within + * any element that has display set to 'none' can cause problems in Safari and Firefox due to their default iframe reloading bugs. + * Example usage: + * +// Simple example rendered with default options: +Ext.QuickTips.init(); // enable tooltips +new Ext.form.HtmlEditor({ + renderTo: Ext.getBody(), + width: 800, + height: 300 +}); + +// Passed via xtype into a container and with custom options: +Ext.QuickTips.init(); // enable tooltips +new Ext.Panel({ + title: 'HTML Editor', + renderTo: Ext.getBody(), + width: 600, + height: 300, + frame: true, + layout: 'fit', + items: { + xtype: 'htmleditor', + enableColors: false, + enableAlignments: false + } }); - * + + * @constructor + * Create a new HtmlEditor + * @param {Object} config + * @xtype htmleditor + */ + +Ext.form.HtmlEditor = Ext.extend(Ext.form.Field, { + /** + * @cfg {Boolean} enableFormat Enable the bold, italic and underline buttons (defaults to true) */ + enableFormat : true, /** - * By default wait messages are displayed with Ext.MessageBox.wait. You can target a specific - * element by passing it or its id or mask the form itself by passing in true. - * @type Mixed - * @property waitMsgTarget + * @cfg {Boolean} enableFontSize Enable the increase/decrease font size buttons (defaults to true) */ - - // private - initEl : function(el){ - this.el = Ext.get(el); - this.id = this.el.id || Ext.id(); - if(!this.standardSubmit){ - this.el.on('submit', this.onSubmit, this); - } - this.el.addClass('x-form'); - }, - + enableFontSize : true, /** - * Get the HTML form Element - * @return Ext.Element + * @cfg {Boolean} enableColors Enable the fore/highlight color buttons (defaults to true) */ - getEl: function(){ - return this.el; + enableColors : true, + /** + * @cfg {Boolean} enableAlignments Enable the left, center, right alignment buttons (defaults to true) + */ + enableAlignments : true, + /** + * @cfg {Boolean} enableLists Enable the bullet and numbered list buttons. Not available in Safari. (defaults to true) + */ + enableLists : true, + /** + * @cfg {Boolean} enableSourceEdit Enable the switch to source edit button. Not available in Safari. (defaults to true) + */ + enableSourceEdit : true, + /** + * @cfg {Boolean} enableLinks Enable the create link button. Not available in Safari. (defaults to true) + */ + enableLinks : true, + /** + * @cfg {Boolean} enableFont Enable font selection. Not available in Safari. (defaults to true) + */ + enableFont : true, + /** + * @cfg {String} createLinkText The default text for the create link prompt + */ + createLinkText : 'Please enter the URL for the link:', + /** + * @cfg {String} defaultLinkValue The default value for the create link prompt (defaults to http:/ /) + */ + defaultLinkValue : 'http:/'+'/', + /** + * @cfg {Array} fontFamilies An array of available font families + */ + fontFamilies : [ + 'Arial', + 'Courier New', + 'Tahoma', + 'Times New Roman', + 'Verdana' + ], + defaultFont: 'tahoma', + /** + * @cfg {String} defaultValue A default value to be put into the editor to resolve focus issues (defaults to (Non-breaking space) in Opera and IE6, (Zero-width space) in all other browsers). + */ + defaultValue: (Ext.isOpera || Ext.isIE6) ? ' ' : '', + + // private properties + actionMode: 'wrap', + validationEvent : false, + deferHeight: true, + initialized : false, + activated : false, + sourceEditMode : false, + onFocus : Ext.emptyFn, + iframePad:3, + hideMode:'offsets', + defaultAutoCreate : { + tag: "textarea", + style:"width:500px;height:300px;", + autocomplete: "off" }, // private - onSubmit : function(e){ - e.stopEvent(); + initComponent : function(){ + this.addEvents( + /** + * @event initialize + * Fires when the editor is fully initialized (including the iframe) + * @param {HtmlEditor} this + */ + 'initialize', + /** + * @event activate + * Fires when the editor is first receives the focus. Any insertion must wait + * until after this event. + * @param {HtmlEditor} this + */ + 'activate', + /** + * @event beforesync + * Fires before the textarea is updated with content from the editor iframe. Return false + * to cancel the sync. + * @param {HtmlEditor} this + * @param {String} html + */ + 'beforesync', + /** + * @event beforepush + * Fires before the iframe editor is updated with content from the textarea. Return false + * to cancel the push. + * @param {HtmlEditor} this + * @param {String} html + */ + 'beforepush', + /** + * @event sync + * Fires when the textarea is updated with content from the editor iframe. + * @param {HtmlEditor} this + * @param {String} html + */ + 'sync', + /** + * @event push + * Fires when the iframe editor is updated with content from the textarea. + * @param {HtmlEditor} this + * @param {String} html + */ + 'push', + /** + * @event editmodechange + * Fires when the editor switches edit modes + * @param {HtmlEditor} this + * @param {Boolean} sourceEdit True if source edit, false if standard editing. + */ + 'editmodechange' + ); }, // private - destroy: function() { - this.items.each(function(f){ - Ext.destroy(f); - }); - if(this.el){ - this.el.removeAllListeners(); - this.el.remove(); + createFontOptions : function(){ + var buf = [], fs = this.fontFamilies, ff, lc; + for(var i = 0, len = fs.length; i< len; i++){ + ff = fs[i]; + lc = ff.toLowerCase(); + buf.push( + '' + ); } - this.purgeListeners(); + return buf.join(''); }, - /** - * Returns true if client-side validation on the form is successful. - * @return Boolean + /* + * Protected method that will not generally be called directly. It + * is called when the editor creates its toolbar. Override this method if you need to + * add custom toolbar buttons. + * @param {HtmlEditor} editor */ - isValid : function(){ - var valid = true; - this.items.each(function(f){ - if(!f.validate()){ - valid = false; - } - }); - return valid; - }, + createToolbar : function(editor){ + var items = []; + var tipsEnabled = Ext.QuickTips && Ext.QuickTips.isEnabled(); - /** - * Returns true if any fields in this form have changed from their original values. - * Note that if this BasicForm was configured with {@link #trackResetOnLoad} then the - * Fields' original values are updated when the values are loaded by {@link #setValues} - * or {@link #loadRecord}. - * @return Boolean - */ - isDirty : function(){ - var dirty = false; - this.items.each(function(f){ - if(f.isDirty()){ - dirty = true; - return false; - } - }); - return dirty; - }, - /** - * Performs a predefined action ({@link Ext.form.Action.Submit} or - * {@link Ext.form.Action.Load}) or a custom extension of {@link Ext.form.Action} - * to perform application-specific processing. - * @param {String/Object} actionName The name of the predefined action type, - * or instance of {@link Ext.form.Action} to perform. - * @param {Object} options (optional) The options to pass to the {@link Ext.form.Action}. - * All of the config options listed below are supported by both the - * {@link Ext.form.Action.Submit submit} and {@link Ext.form.Action.Load load} - * actions unless otherwise noted (custom actions could also accept - * other config options): - * - * url : StringThe url for the action (defaults - * to the form's {@link #url}.) - * - * method : StringThe form method to use (defaults - * to the form's method, or POST if not defined) - * - * params : String/ObjectThe params to pass - * (defaults to the form's baseParams, or none if not defined) - * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. - * - * headers : ObjectRequest headers to set for the action - * (defaults to the form's default headers) - * - * success : FunctionThe callback that will - * be invoked after a successful response (see top of - * {@link Ext.form.Action.Submit submit} and {@link Ext.form.Action.Load load} - * for a description of what constitutes a successful response). - * The function is passed the following parameters: - * form : Ext.form.BasicFormThe form that requested the action - * action : The {@link Ext.form.Action Action} object which performed the operation. - * The action object contains these properties of interest: - * {@link Ext.form.Action#response response} - * {@link Ext.form.Action#result result} : interrogate for custom postprocessing - * {@link Ext.form.Action#type type} - * - * - * failure : FunctionThe callback that will be invoked after a - * failed transaction attempt. The function is passed the following parameters: - * form : The {@link Ext.form.BasicForm} that requested the action. - * action : The {@link Ext.form.Action Action} object which performed the operation. - * The action object contains these properties of interest: - * {@link Ext.form.Action#failureType failureType} - * {@link Ext.form.Action#response response} - * {@link Ext.form.Action#result result} : interrogate for custom postprocessing - * {@link Ext.form.Action#type type} - * - * - * scope : ObjectThe scope in which to call the - * callback functions (The this reference for the callback functions). - * - * clientValidation : BooleanSubmit Action only. - * Determines whether a Form's fields are validated in a final call to - * {@link Ext.form.BasicForm#isValid isValid} prior to submission. Set to false - * to prevent this. If undefined, pre-submission field validation is performed. - * - * @return {BasicForm} this - */ - doAction : function(action, options){ - if(Ext.isString(action)){ - action = new Ext.form.Action.ACTION_TYPES[action](this, options); + function btn(id, toggle, handler){ + return { + itemId : id, + cls : 'x-btn-icon', + iconCls: 'x-edit-'+id, + enableToggle:toggle !== false, + scope: editor, + handler:handler||editor.relayBtnCmd, + clickEvent:'mousedown', + tooltip: tipsEnabled ? editor.buttonTips[id] || undefined : undefined, + overflowText: editor.buttonTips[id].title || undefined, + tabIndex:-1 + }; } - if(this.fireEvent('beforeaction', this, action) !== false){ - this.beforeAction(action); - action.run.defer(100, action); + + + if(this.enableFont && !Ext.isSafari2){ + var fontSelectItem = new Ext.Toolbar.Item({ + autoEl: { + tag:'select', + cls:'x-font-select', + html: this.createFontOptions() + } + }); + + items.push( + fontSelectItem, + '-' + ); } - return this; - }, - /** - * Shortcut to {@link #doAction do} a {@link Ext.form.Action.Submit submit action}. - * @param {Object} options The options to pass to the action (see {@link #doAction} for details). - * Note: this is ignored when using the {@link #standardSubmit} option. - * The following code: -myFormPanel.getForm().submit({ - clientValidation: true, - url: 'updateConsignment.php', - params: { - newStatus: 'delivered' - }, - success: function(form, action) { - Ext.Msg.alert('Success', action.result.msg); - }, - failure: function(form, action) { - switch (action.failureType) { - case Ext.form.Action.CLIENT_INVALID: - Ext.Msg.alert('Failure', 'Form fields may not be submitted with invalid values'); - break; - case Ext.form.Action.CONNECT_FAILURE: - Ext.Msg.alert('Failure', 'Ajax communication failed'); - break; - case Ext.form.Action.SERVER_INVALID: - Ext.Msg.alert('Failure', action.result.msg); - } - } -}); - - * would process the following server response for a successful submission: -{ - "success":true, // note this is Boolean, not string - "msg":"Consignment updated" -} - - * and the following server response for a failed submission: -{ - "success":false, // note this is Boolean, not string - "msg":"You do not have permission to perform this operation" -} - - * @return {BasicForm} this - */ - submit : function(options){ - if(this.standardSubmit){ - var v = this.isValid(); - if(v){ - var el = this.el.dom; - if(this.url && Ext.isEmpty(el.action)){ - el.action = this.url; + if(this.enableFormat){ + items.push( + btn('bold'), + btn('italic'), + btn('underline') + ); + } + + if(this.enableFontSize){ + items.push( + '-', + btn('increasefontsize', false, this.adjustFont), + btn('decreasefontsize', false, this.adjustFont) + ); + } + + if(this.enableColors){ + items.push( + '-', { + itemId:'forecolor', + cls:'x-btn-icon', + iconCls: 'x-edit-forecolor', + clickEvent:'mousedown', + tooltip: tipsEnabled ? editor.buttonTips.forecolor || undefined : undefined, + tabIndex:-1, + menu : new Ext.menu.ColorMenu({ + allowReselect: true, + focus: Ext.emptyFn, + value:'000000', + plain:true, + listeners: { + scope: this, + select: function(cp, color){ + this.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color); + this.deferFocus(); + } + }, + clickEvent:'mousedown' + }) + }, { + itemId:'backcolor', + cls:'x-btn-icon', + iconCls: 'x-edit-backcolor', + clickEvent:'mousedown', + tooltip: tipsEnabled ? editor.buttonTips.backcolor || undefined : undefined, + tabIndex:-1, + menu : new Ext.menu.ColorMenu({ + focus: Ext.emptyFn, + value:'FFFFFF', + plain:true, + allowReselect: true, + listeners: { + scope: this, + select: function(cp, color){ + if(Ext.isGecko){ + this.execCmd('useCSS', false); + this.execCmd('hilitecolor', color); + this.execCmd('useCSS', true); + this.deferFocus(); + }else{ + this.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color); + this.deferFocus(); + } + } + }, + clickEvent:'mousedown' + }) } - el.submit(); + ); + } + + if(this.enableAlignments){ + items.push( + '-', + btn('justifyleft'), + btn('justifycenter'), + btn('justifyright') + ); + } + + if(!Ext.isSafari2){ + if(this.enableLinks){ + items.push( + '-', + btn('createlink', false, this.createLink) + ); + } + + if(this.enableLists){ + items.push( + '-', + btn('insertorderedlist'), + btn('insertunorderedlist') + ); + } + if(this.enableSourceEdit){ + items.push( + '-', + btn('sourceedit', true, function(btn){ + this.toggleSourceEdit(!this.sourceEditMode); + }) + ); } - return v; } - var submitAction = String.format('{0}submit', this.api ? 'direct' : ''); - this.doAction(submitAction, options); - return this; + + // build the toolbar + var tb = new Ext.Toolbar({ + renderTo: this.wrap.dom.firstChild, + items: items + }); + + if (fontSelectItem) { + this.fontSelect = fontSelectItem.el; + + this.mon(this.fontSelect, 'change', function(){ + var font = this.fontSelect.dom.value; + this.relayCmd('fontname', font); + this.deferFocus(); + }, this); + } + + // stop form submits + this.mon(tb.el, 'click', function(e){ + e.preventDefault(); + }); + + this.tb = tb; + this.tb.doLayout(); }, - /** - * Shortcut to {@link #doAction do} a {@link Ext.form.Action.Load load action}. - * @param {Object} options The options to pass to the action (see {@link #doAction} for details) - * @return {BasicForm} this - */ - load : function(options){ - var loadAction = String.format('{0}load', this.api ? 'direct' : ''); - this.doAction(loadAction, options); - return this; + onDisable: function(){ + this.wrap.mask(); + Ext.form.HtmlEditor.superclass.onDisable.call(this); }, - /** - * Persists the values in this form into the passed {@link Ext.data.Record} object in a beginEdit/endEdit block. - * @param {Record} record The record to edit - * @return {BasicForm} this - */ - updateRecord : function(record){ - record.beginEdit(); - var fs = record.fields; - fs.each(function(f){ - var field = this.findField(f.name); - if(field){ - record.set(f.name, field.getValue()); + onEnable: function(){ + this.wrap.unmask(); + Ext.form.HtmlEditor.superclass.onEnable.call(this); + }, + + setReadOnly: function(readOnly){ + + Ext.form.HtmlEditor.superclass.setReadOnly.call(this, readOnly); + if(this.initialized){ + this.setDesignMode(!readOnly); + var bd = this.getEditorBody(); + if(bd){ + bd.style.cursor = this.readOnly ? 'default' : 'text'; } - }, this); - record.endEdit(); - return this; + this.disableItems(readOnly); + } }, /** - * Loads an {@link Ext.data.Record} into this form by calling {@link #setValues} with the - * {@link Ext.data.Record#data record data}. - * See also {@link #trackResetOnLoad}. - * @param {Record} record The record to load - * @return {BasicForm} this + * Protected method that will not generally be called directly. It + * is called when the editor initializes the iframe with HTML contents. Override this method if you + * want to change the initialization markup of the iframe (e.g. to add stylesheets). + * + * Note: IE8-Standards has unwanted scroller behavior, so the default meta tag forces IE7 compatibility */ - loadRecord : function(record){ - this.setValues(record.data); - return this; + getDocMarkup : function(){ + var h = Ext.fly(this.iframe).getHeight() - this.iframePad * 2; + return String.format('', this.iframePad, h); }, // private - beforeAction : function(action){ - var o = action.options; - if(o.waitMsg){ - if(this.waitMsgTarget === true){ - this.el.mask(o.waitMsg, 'x-mask-loading'); - }else if(this.waitMsgTarget){ - this.waitMsgTarget = Ext.get(this.waitMsgTarget); - this.waitMsgTarget.mask(o.waitMsg, 'x-mask-loading'); - }else{ - Ext.MessageBox.wait(o.waitMsg, o.waitTitle || this.waitTitle); - } - } + getEditorBody : function(){ + var doc = this.getDoc(); + return doc.body || doc.documentElement; }, // private - afterAction : function(action, success){ - this.activeAction = null; - var o = action.options; - if(o.waitMsg){ - if(this.waitMsgTarget === true){ - this.el.unmask(); - }else if(this.waitMsgTarget){ - this.waitMsgTarget.unmask(); - }else{ - Ext.MessageBox.updateProgress(1); - Ext.MessageBox.hide(); - } + getDoc : function(){ + return Ext.isIE ? this.getWin().document : (this.iframe.contentDocument || this.getWin().document); + }, + + // private + getWin : function(){ + return Ext.isIE ? this.iframe.contentWindow : window.frames[this.iframe.name]; + }, + + // private + onRender : function(ct, position){ + Ext.form.HtmlEditor.superclass.onRender.call(this, ct, position); + this.el.dom.style.border = '0 none'; + this.el.dom.setAttribute('tabIndex', -1); + this.el.addClass('x-hidden'); + if(Ext.isIE){ // fix IE 1px bogus margin + this.el.applyStyles('margin-top:-1px;margin-bottom:-1px;'); } - if(success){ - if(o.reset){ - this.reset(); - } - Ext.callback(o.success, o.scope, [this, action]); - this.fireEvent('actioncomplete', this, action); - }else{ - Ext.callback(o.failure, o.scope, [this, action]); - this.fireEvent('actionfailed', this, action); + this.wrap = this.el.wrap({ + cls:'x-html-editor-wrap', cn:{cls:'x-html-editor-tb'} + }); + + this.createToolbar(this); + + this.disableItems(true); + + this.tb.doLayout(); + + this.createIFrame(); + + if(!this.width){ + var sz = this.el.getSize(); + this.setSize(sz.width, this.height || sz.height); } + this.resizeEl = this.positionEl = this.wrap; }, - /** - * Find a {@link Ext.form.Field} in this form. - * @param {String} id The value to search for (specify either a {@link Ext.Component#id id}, - * {@link Ext.grid.Column#dataIndex dataIndex}, {@link Ext.form.Field#getName name or hiddenName}). - * @return Field - */ - findField : function(id){ - var field = this.items.get(id); - if(!Ext.isObject(field)){ - this.items.each(function(f){ - if(f.isFormField && (f.dataIndex == id || f.id == id || f.getName() == id)){ - field = f; - return false; - } - }); - } - return field || null; + createIFrame: function(){ + var iframe = document.createElement('iframe'); + iframe.name = Ext.id(); + iframe.frameBorder = '0'; + iframe.style.overflow = 'auto'; + + this.wrap.dom.appendChild(iframe); + this.iframe = iframe; + + this.monitorTask = Ext.TaskMgr.start({ + run: this.checkDesignMode, + scope: this, + interval:100 + }); }, + initFrame : function(){ + Ext.TaskMgr.stop(this.monitorTask); + var doc = this.getDoc(); + this.win = this.getWin(); + + doc.open(); + doc.write(this.getDocMarkup()); + doc.close(); - /** - * Mark fields in this form invalid in bulk. - * @param {Array/Object} errors Either an array in the form [{id:'fieldId', msg:'The message'},...] or an object hash of {id: msg, id2: msg2} - * @return {BasicForm} this - */ - markInvalid : function(errors){ - if(Ext.isArray(errors)){ - for(var i = 0, len = errors.length; i < len; i++){ - var fieldError = errors[i]; - var f = this.findField(fieldError.id); - if(f){ - f.markInvalid(fieldError.msg); + var task = { // must defer to wait for browser to be ready + run : function(){ + var doc = this.getDoc(); + if(doc.body || doc.readyState == 'complete'){ + Ext.TaskMgr.stop(task); + this.setDesignMode(true); + this.initEditor.defer(10, this); } + }, + interval : 10, + duration:10000, + scope: this + }; + Ext.TaskMgr.start(task); + }, + + + checkDesignMode : function(){ + if(this.wrap && this.wrap.dom.offsetWidth){ + var doc = this.getDoc(); + if(!doc){ + return; } - }else{ - var field, id; - for(id in errors){ - if(!Ext.isFunction(errors[id]) && (field = this.findField(id))){ - field.markInvalid(errors[id]); - } + if(!doc.editorInitialized || this.getDesignMode() != 'on'){ + this.initFrame(); } } - return this; }, - /** - * Set values for fields in this form in bulk. - * @param {Array/Object} values Either an array in the form: -[{id:'clientName', value:'Fred. Olsen Lines'}, - {id:'portOfLoading', value:'FXT'}, - {id:'portOfDischarge', value:'OSL'} ] - * or an object hash of the form: -{ - clientName: 'Fred. Olsen Lines', - portOfLoading: 'FXT', - portOfDischarge: 'OSL' -} - * @return {BasicForm} this + /* private + * set current design mode. To enable, mode can be true or 'on', off otherwise */ - setValues : function(values){ - if(Ext.isArray(values)){ // array of objects - for(var i = 0, len = values.length; i < len; i++){ - var v = values[i]; - var f = this.findField(v.id); - if(f){ - f.setValue(v.value); - if(this.trackResetOnLoad){ - f.originalValue = f.getValue(); - } - } - } - }else{ // object hash - var field, id; - for(id in values){ - if(!Ext.isFunction(values[id]) && (field = this.findField(id))){ - field.setValue(values[id]); - if(this.trackResetOnLoad){ - field.originalValue = field.getValue(); - } - } + setDesignMode : function(mode){ + var doc ; + if(doc = this.getDoc()){ + if(this.readOnly){ + mode = false; } + doc.designMode = (/on|true/i).test(String(mode).toLowerCase()) ?'on':'off'; } - return this; + }, - /** - * Returns the fields in this form as an object with key/value pairs as they would be submitted using a standard form submit. - * If multiple fields exist with the same name they are returned as an array. - * Note: The values are collected from all enabled HTML input elements within the form, not from - * the Ext Field objects. This means that all returned values are Strings (or Arrays of Strings) and that the - * value can potentially be the emptyText of a field. - * @param {Boolean} asString (optional) Pass true to return the values as a string. (defaults to false, returning an Object) - * @return {String/Object} - */ - getValues : function(asString){ - var fs = Ext.lib.Ajax.serializeForm(this.el.dom); - if(asString === true){ - return fs; - } - return Ext.urlDecode(fs); + // private + getDesignMode : function(){ + var doc = this.getDoc(); + if(!doc){ return ''; } + return String(doc.designMode).toLowerCase(); + }, - /** - * Retrieves the fields in the form as a set of key/value pairs, using the {@link Ext.form.Field#getValue getValue()} method. - * If multiple fields exist with the same name they are returned as an array. - * @param {Boolean} dirtyOnly (optional) True to return only fields that are dirty. - * @return {Object} The values in the form - */ - getFieldValues : function(dirtyOnly){ - var o = {}, - n, - key, - val; - this.items.each(function(f){ - if(dirtyOnly !== true || f.isDirty()){ - n = f.getName(); - key = o[n]; - val = f.getValue(); - - if(Ext.isDefined(key)){ - if(Ext.isArray(key)){ - o[n].push(val); - }else{ - o[n] = [key, val]; - } - }else{ - o[n] = val; - } + disableItems: function(disabled){ + if(this.fontSelect){ + this.fontSelect.dom.disabled = disabled; + } + this.tb.items.each(function(item){ + if(item.getItemId() != 'sourceedit'){ + item.setDisabled(disabled); } }); - return o; }, - /** - * Clears all invalid messages in this form. - * @return {BasicForm} this - */ - clearInvalid : function(){ - this.items.each(function(f){ - f.clearInvalid(); - }); - return this; + // private + onResize : function(w, h){ + Ext.form.HtmlEditor.superclass.onResize.apply(this, arguments); + if(this.el && this.iframe){ + if(Ext.isNumber(w)){ + var aw = w - this.wrap.getFrameWidth('lr'); + this.el.setWidth(aw); + this.tb.setWidth(aw); + this.iframe.style.width = Math.max(aw, 0) + 'px'; + } + if(Ext.isNumber(h)){ + var ah = h - this.wrap.getFrameWidth('tb') - this.tb.el.getHeight(); + this.el.setHeight(ah); + this.iframe.style.height = Math.max(ah, 0) + 'px'; + var bd = this.getEditorBody(); + if(bd){ + bd.style.height = Math.max((ah - (this.iframePad*2)), 0) + 'px'; + } + } + } }, /** - * Resets this form. - * @return {BasicForm} this + * Toggles the editor between standard and source edit mode. + * @param {Boolean} sourceEdit (optional) True for source edit, false for standard */ - reset : function(){ - this.items.each(function(f){ - f.reset(); - }); - return this; - }, + toggleSourceEdit : function(sourceEditMode){ + var iframeHeight, elHeight; + if(sourceEditMode === undefined){ + sourceEditMode = !this.sourceEditMode; + } + this.sourceEditMode = sourceEditMode === true; + var btn = this.tb.getComponent('sourceedit'); - /** - * Add Ext.form Components to this form's Collection. This does not result in rendering of - * the passed Component, it just enables the form to validate Fields, and distribute values to - * Fields. - * You will not usually call this function. In order to be rendered, a Field must be added - * to a {@link Ext.Container Container}, usually an {@link Ext.form.FormPanel FormPanel}. - * The FormPanel to which the field is added takes care of adding the Field to the BasicForm's - * collection. - * @param {Field} field1 - * @param {Field} field2 (optional) - * @param {Field} etc (optional) - * @return {BasicForm} this - */ - add : function(){ - this.items.addAll(Array.prototype.slice.call(arguments, 0)); - return this; - }, + if(btn.pressed !== this.sourceEditMode){ + btn.toggle(this.sourceEditMode); + if(!btn.xtbHidden){ + return; + } + } + if(this.sourceEditMode){ + // grab the height of the containing panel before we hide the iframe + ls = this.getSize(); + iframeHeight = Ext.get(this.iframe).getHeight(); - /** - * Removes a field from the items collection (does NOT remove its markup). - * @param {Field} field - * @return {BasicForm} this - */ - remove : function(field){ - this.items.remove(field); - return this; + this.disableItems(true); + this.syncValue(); + this.iframe.className = 'x-hidden'; + this.el.removeClass('x-hidden'); + this.el.dom.removeAttribute('tabIndex'); + this.el.focus(); + this.el.dom.style.height = iframeHeight + 'px'; + }else{ + elHeight = parseInt(this.el.dom.style.height, 10); + if(this.initialized){ + this.disableItems(this.readOnly); + } + this.pushValue(); + this.iframe.className = ''; + this.el.addClass('x-hidden'); + this.el.dom.setAttribute('tabIndex', -1); + this.deferFocus(); + + this.setSize(ls); + this.iframe.style.height = elHeight + 'px'; + } + this.fireEvent('editmodechange', this, this.sourceEditMode); }, - /** - * Iterates through the {@link Ext.form.Field Field}s which have been {@link #add add}ed to this BasicForm, - * checks them for an id attribute, and calls {@link Ext.form.Field#applyToMarkup} on the existing dom element with that id. - * @return {BasicForm} this - */ - render : function(){ - this.items.each(function(f){ - if(f.isFormField && !f.rendered && document.getElementById(f.id)){ // if the element exists - f.applyToMarkup(f.id); - } - }); - return this; + // private used internally + createLink : function(){ + var url = prompt(this.createLinkText, this.defaultLinkValue); + if(url && url != 'http:/'+'/'){ + this.relayCmd('createlink', url); + } + }, + + // private + initEvents : function(){ + this.originalValue = this.getValue(); }, /** - * Calls {@link Ext#apply} for all fields in this form with the passed object. - * @param {Object} values - * @return {BasicForm} this + * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide + * @method */ - applyToFields : function(o){ - this.items.each(function(f){ - Ext.apply(f, o); - }); - return this; - }, + markInvalid : Ext.emptyFn, /** - * Calls {@link Ext#applyIf} for all field in this form with the passed object. - * @param {Object} values - * @return {BasicForm} this + * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide + * @method */ - applyIfToFields : function(o){ - this.items.each(function(f){ - Ext.applyIf(f, o); - }); - return this; - }, + clearInvalid : Ext.emptyFn, - callFieldMethod : function(fnName, args){ - args = args || []; - this.items.each(function(f){ - if(Ext.isFunction(f[fnName])){ - f[fnName].apply(f, args); - } - }); + // docs inherit from Field + setValue : function(v){ + Ext.form.HtmlEditor.superclass.setValue.call(this, v); + this.pushValue(); return this; - } -}); + }, -// back compat -Ext.BasicForm = Ext.form.BasicForm;/** - * @class Ext.form.FormPanel - * @extends Ext.Panel - * Standard form container. - * - * Layout - * By default, FormPanel is configured with layout:'form' to use an {@link Ext.layout.FormLayout} - * layout manager, which styles and renders fields and labels correctly. When nesting additional Containers - * within a FormPanel, you should ensure that any descendant Containers which host input Fields use the - * {@link Ext.layout.FormLayout} layout manager. - * - * BasicForm - * Although not listed as configuration options of FormPanel, the FormPanel class accepts all - * of the config options required to configure its internal {@link Ext.form.BasicForm} for: - * - * {@link Ext.form.BasicForm#fileUpload file uploads} - * functionality for {@link Ext.form.BasicForm#doAction loading, validating and submitting} the form - * - * - * Note: If subclassing FormPanel, any configuration options for the BasicForm must be applied to - * the initialConfig property of the FormPanel. Applying {@link Ext.form.BasicForm BasicForm} - * configuration settings to this will not affect the BasicForm's configuration. - * - * Form Validation - * For information on form validation see the following: - * - * {@link Ext.form.TextField} - * {@link Ext.form.VTypes} - * {@link Ext.form.BasicForm#doAction BasicForm.doAction clientValidation notes} - * {@link Ext.form.FormPanel#monitorValid monitorValid} - * - * - * Form Submission - * By default, Ext Forms are submitted through Ajax, using {@link Ext.form.Action}. To enable normal browser - * submission of the {@link Ext.form.BasicForm BasicForm} contained in this FormPanel, see the - * {@link Ext.form.BasicForm#standardSubmit standardSubmit} option. - * - * @constructor - * @param {Object} config Configuration options - * @xtype form - */ -Ext.FormPanel = Ext.extend(Ext.Panel, { - /** - * @cfg {String} formId (optional) The id of the FORM tag (defaults to an auto-generated id). - */ - /** - * @cfg {Boolean} hideLabels - * true to hide field labels by default (sets display:none). Defaults to - * false. - * Also see {@link Ext.Component}.{@link Ext.Component#hideLabel hideLabel}. - */ - /** - * @cfg {Number} labelPad - * The default padding in pixels for field labels (defaults to 5). labelPad only - * applies if {@link #labelWidth} is also specified, otherwise it will be ignored. - */ - /** - * @cfg {String} labelSeparator - * See {@link Ext.Component}.{@link Ext.Component#labelSeparator labelSeparator} - */ - /** - * @cfg {Number} labelWidth The width of labels in pixels. This property cascades to child containers - * and can be overridden on any child container (e.g., a fieldset can specify a different labelWidth - * for its fields) (defaults to 100). - */ /** - * @cfg {String} itemCls A css class to apply to the x-form-item of fields. This property cascades to child containers. - */ - /** - * @cfg {Array} buttons - * An array of {@link Ext.Button}s or {@link Ext.Button} configs used to add buttons to the footer of this FormPanel. - * Buttons in the footer of a FormPanel may be configured with the option formBind: true. This causes - * the form's {@link #monitorValid valid state monitor task} to enable/disable those Buttons depending on - * the form's valid/invalid state. + * Protected method that will not generally be called directly. If you need/want + * custom HTML cleanup, this is the method you should override. + * @param {String} html The HTML to be cleaned + * @return {String} The cleaned HTML */ + cleanHtml: function(html) { + html = String(html); + if(Ext.isWebKit){ // strip safari nonsense + html = html.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi, ''); + } + /* + * Neat little hack. Strips out all the non-digit characters from the default + * value and compares it to the character code of the first character in the string + * because it can cause encoding issues when posted to the server. + */ + if(html.charCodeAt(0) == this.defaultValue.replace(/\D/g, '')){ + html = html.substring(1); + } + return html; + }, /** - * @cfg {Number} minButtonWidth Minimum width of all buttons in pixels (defaults to 75). + * Protected method that will not generally be called directly. Syncs the contents + * of the editor iframe with the textarea. */ - minButtonWidth : 75, + syncValue : function(){ + if(this.initialized){ + var bd = this.getEditorBody(); + var html = bd.innerHTML; + if(Ext.isWebKit){ + var bs = bd.getAttribute('style'); // Safari puts text-align styles on the body element! + var m = bs.match(/text-align:(.*?);/i); + if(m && m[1]){ + html = '' + html + ''; + } + } + html = this.cleanHtml(html); + if(this.fireEvent('beforesync', this, html) !== false){ + this.el.dom.value = html; + this.fireEvent('sync', this, html); + } + } + }, - /** - * @cfg {String} labelAlign The label alignment value used for the text-align specification - * for the container. Valid values are "left", "top" or "right" - * (defaults to "left"). This property cascades to child containers and can be - * overridden on any child container (e.g., a fieldset can specify a different labelAlign - * for its fields). - */ - labelAlign : 'left', + //docs inherit from Field + getValue : function() { + this[this.sourceEditMode ? 'pushValue' : 'syncValue'](); + return Ext.form.HtmlEditor.superclass.getValue.call(this); + }, /** - * @cfg {Boolean} monitorValid If true, the form monitors its valid state client-side and - * regularly fires the {@link #clientvalidation} event passing that state. - * When monitoring valid state, the FormPanel enables/disables any of its configured - * {@link #buttons} which have been configured with formBind: true depending - * on whether the {@link Ext.form.BasicForm#isValid form is valid} or not. Defaults to false + * Protected method that will not generally be called directly. Pushes the value of the textarea + * into the iframe editor. */ - monitorValid : false, + pushValue : function(){ + if(this.initialized){ + var v = this.el.dom.value; + if(!this.activated && v.length < 1){ + v = this.defaultValue; + } + if(this.fireEvent('beforepush', this, v) !== false){ + this.getEditorBody().innerHTML = v; + if(Ext.isGecko){ + // Gecko hack, see: https://bugzilla.mozilla.org/show_bug.cgi?id=232791#c8 + this.setDesignMode(false); //toggle off first - /** - * @cfg {Number} monitorPoll The milliseconds to poll valid state, ignored if monitorValid is not true (defaults to 200) - */ - monitorPoll : 200, + } + this.setDesignMode(true); + this.fireEvent('push', this, v); + } - /** - * @cfg {String} layout Defaults to 'form'. Normally this configuration property should not be altered. - * For additional details see {@link Ext.layout.FormLayout} and {@link Ext.Container#layout Ext.Container.layout}. - */ - layout : 'form', + } + }, // private - initComponent : function(){ - this.form = this.createForm(); - Ext.FormPanel.superclass.initComponent.call(this); + deferFocus : function(){ + this.focus.defer(10, this); + }, - this.bodyCfg = { - tag: 'form', - cls: this.baseCls + '-body', - method : this.method || 'POST', - id : this.formId || Ext.id() - }; - if(this.fileUpload) { - this.bodyCfg.enctype = 'multipart/form-data'; + // docs inherit from Field + focus : function(){ + if(this.win && !this.sourceEditMode){ + this.win.focus(); + }else{ + this.el.focus(); } - this.initItems(); + }, - this.addEvents( - /** - * @event clientvalidation - * If the monitorValid config option is true, this event fires repetitively to notify of valid state - * @param {Ext.form.FormPanel} this - * @param {Boolean} valid true if the form has passed client-side validation + // private + initEditor : function(){ + //Destroying the component during/before initEditor can cause issues. + try{ + var dbody = this.getEditorBody(), + ss = this.el.getStyles('font-size', 'font-family', 'background-image', 'background-repeat', 'background-color', 'color'), + doc, + fn; + + ss['background-attachment'] = 'fixed'; // w3c + dbody.bgProperties = 'fixed'; // ie + + Ext.DomHelper.applyStyles(dbody, ss); + + doc = this.getDoc(); + + if(doc){ + try{ + Ext.EventManager.removeAll(doc); + }catch(e){} + } + + /* + * We need to use createDelegate here, because when using buffer, the delayed task is added + * as a property to the function. When the listener is removed, the task is deleted from the function. + * Since onEditorEvent is shared on the prototype, if we have multiple html editors, the first time one of the editors + * is destroyed, it causes the fn to be deleted from the prototype, which causes errors. Essentially, we're just anonymizing the function. */ - 'clientvalidation' - ); + fn = this.onEditorEvent.createDelegate(this); + Ext.EventManager.on(doc, { + mousedown: fn, + dblclick: fn, + click: fn, + keyup: fn, + buffer:100 + }); - this.relayEvents(this.form, ['beforeaction', 'actionfailed', 'actioncomplete']); + if(Ext.isGecko){ + Ext.EventManager.on(doc, 'keypress', this.applyCommand, this); + } + if(Ext.isIE || Ext.isWebKit || Ext.isOpera){ + Ext.EventManager.on(doc, 'keydown', this.fixKeys, this); + } + doc.editorInitialized = true; + this.initialized = true; + this.pushValue(); + this.setReadOnly(this.readOnly); + this.fireEvent('initialize', this); + }catch(e){} }, // private - createForm : function(){ - var config = Ext.applyIf({listeners: {}}, this.initialConfig); - return new Ext.form.BasicForm(null, config); + onDestroy : function(){ + if(this.monitorTask){ + Ext.TaskMgr.stop(this.monitorTask); + } + if(this.rendered){ + Ext.destroy(this.tb); + var doc = this.getDoc(); + if(doc){ + try{ + Ext.EventManager.removeAll(doc); + for (var prop in doc){ + delete doc[prop]; + } + }catch(e){} + } + if(this.wrap){ + this.wrap.dom.innerHTML = ''; + this.wrap.remove(); + } + } + + if(this.el){ + this.el.removeAllListeners(); + this.el.remove(); + } + this.purgeListeners(); }, // private - initFields : function(){ - var f = this.form; - var formPanel = this; - var fn = function(c){ - if(formPanel.isField(c)){ - f.add(c); - }else if(c.findBy && c != formPanel){ - formPanel.applySettings(c); - //each check required for check/radio groups. - if(c.items && c.items.each){ - c.items.each(fn, this); - } + onFirstFocus : function(){ + this.activated = true; + this.disableItems(this.readOnly); + if(Ext.isGecko){ // prevent silly gecko errors + this.win.focus(); + var s = this.win.getSelection(); + if(!s.focusNode || s.focusNode.nodeType != 3){ + var r = s.getRangeAt(0); + r.selectNodeContents(this.getEditorBody()); + r.collapse(true); + this.deferFocus(); } - }; - this.items.each(fn, this); + try{ + this.execCmd('useCSS', true); + this.execCmd('styleWithCSS', false); + }catch(e){} + } + this.fireEvent('activate', this); }, // private - applySettings: function(c){ - var ct = c.ownerCt; - Ext.applyIf(c, { - labelAlign: ct.labelAlign, - labelWidth: ct.labelWidth, - itemCls: ct.itemCls - }); + adjustFont: function(btn){ + var adjust = btn.getItemId() == 'increasefontsize' ? 1 : -1, + doc = this.getDoc(), + v = parseInt(doc.queryCommandValue('FontSize') || 2, 10); + if((Ext.isSafari && !Ext.isSafari2) || Ext.isChrome || Ext.isAir){ + // Safari 3 values + // 1 = 10px, 2 = 13px, 3 = 16px, 4 = 18px, 5 = 24px, 6 = 32px + if(v <= 10){ + v = 1 + adjust; + }else if(v <= 13){ + v = 2 + adjust; + }else if(v <= 16){ + v = 3 + adjust; + }else if(v <= 18){ + v = 4 + adjust; + }else if(v <= 24){ + v = 5 + adjust; + }else { + v = 6 + adjust; + } + v = v.constrain(1, 6); + }else{ + if(Ext.isSafari){ // safari + adjust *= 2; + } + v = Math.max(1, v+adjust) + (Ext.isSafari ? 'px' : 0); + } + this.execCmd('FontSize', v); }, // private - getLayoutTarget : function(){ - return this.form.el; + onEditorEvent : function(e){ + this.updateToolbar(); }, + /** - * Provides access to the {@link Ext.form.BasicForm Form} which this Panel contains. - * @return {Ext.form.BasicForm} The {@link Ext.form.BasicForm Form} which this Panel contains. + * Protected method that will not generally be called directly. It triggers + * a toolbar update by reading the markup state of the current selection in the editor. */ - getForm : function(){ - return this.form; - }, + updateToolbar: function(){ - // private - onRender : function(ct, position){ - this.initFields(); - Ext.FormPanel.superclass.onRender.call(this, ct, position); - this.form.initEl(this.body); + if(this.readOnly){ + return; + } + + if(!this.activated){ + this.onFirstFocus(); + return; + } + + var btns = this.tb.items.map, + doc = this.getDoc(); + + if(this.enableFont && !Ext.isSafari2){ + var name = (doc.queryCommandValue('FontName')||this.defaultFont).toLowerCase(); + if(name != this.fontSelect.dom.value){ + this.fontSelect.dom.value = name; + } + } + if(this.enableFormat){ + btns.bold.toggle(doc.queryCommandState('bold')); + btns.italic.toggle(doc.queryCommandState('italic')); + btns.underline.toggle(doc.queryCommandState('underline')); + } + if(this.enableAlignments){ + btns.justifyleft.toggle(doc.queryCommandState('justifyleft')); + btns.justifycenter.toggle(doc.queryCommandState('justifycenter')); + btns.justifyright.toggle(doc.queryCommandState('justifyright')); + } + if(!Ext.isSafari2 && this.enableLists){ + btns.insertorderedlist.toggle(doc.queryCommandState('insertorderedlist')); + btns.insertunorderedlist.toggle(doc.queryCommandState('insertunorderedlist')); + } + + Ext.menu.MenuMgr.hideAll(); + + this.syncValue(); }, // private - beforeDestroy : function(){ - this.stopMonitoring(); - /* - * Don't move this behaviour to BasicForm because it can be used - * on it's own. - */ - Ext.destroy(this.form); - this.form.items.clear(); - Ext.FormPanel.superclass.beforeDestroy.call(this); + relayBtnCmd : function(btn){ + this.relayCmd(btn.getItemId()); }, - // Determine if a Component is usable as a form Field. - isField : function(c) { - return !!c.setValue && !!c.getValue && !!c.markInvalid && !!c.clearInvalid; + /** + * Executes a Midas editor command on the editor document and performs necessary focus and + * toolbar updates. This should only be called after the editor is initialized. + * @param {String} cmd The Midas command + * @param {String/Boolean} value (optional) The value to pass to the command (defaults to null) + */ + relayCmd : function(cmd, value){ + (function(){ + this.focus(); + this.execCmd(cmd, value); + this.updateToolbar(); + }).defer(10, this); }, - // private - initEvents : function(){ - Ext.FormPanel.superclass.initEvents.call(this); - // Listeners are required here to catch bubbling events from children. - this.on({ - scope: this, - add: this.onAddEvent, - remove: this.onRemoveEvent - }); - if(this.monitorValid){ // initialize after render - this.startMonitoring(); - } + /** + * Executes a Midas editor command directly on the editor document. + * For visual commands, you should use {@link #relayCmd} instead. + * This should only be called after the editor is initialized. + * @param {String} cmd The Midas command + * @param {String/Boolean} value (optional) The value to pass to the command (defaults to null) + */ + execCmd : function(cmd, value){ + var doc = this.getDoc(); + doc.execCommand(cmd, false, value === undefined ? null : value); + this.syncValue(); }, // private - onAdd: function(c){ - Ext.FormPanel.superclass.onAdd.call(this, c); - this.processAdd(c); + applyCommand : function(e){ + if(e.ctrlKey){ + var c = e.getCharCode(), cmd; + if(c > 0){ + c = String.fromCharCode(c); + switch(c){ + case 'b': + cmd = 'bold'; + break; + case 'i': + cmd = 'italic'; + break; + case 'u': + cmd = 'underline'; + break; + } + if(cmd){ + this.win.focus(); + this.execCmd(cmd); + this.deferFocus(); + e.preventDefault(); + } + } + } }, - // private - onAddEvent: function(ct, c){ - if(ct !== this){ - this.processAdd(c); + /** + * Inserts the passed text at the current cursor position. Note: the editor must be initialized and activated + * to insert text. + * @param {String} text + */ + insertAtCursor : function(text){ + if(!this.activated){ + return; + } + if(Ext.isIE){ + this.win.focus(); + var doc = this.getDoc(), + r = doc.selection.createRange(); + if(r){ + r.pasteHTML(text); + this.syncValue(); + this.deferFocus(); + } + }else{ + this.win.focus(); + this.execCmd('InsertHTML', text); + this.deferFocus(); } }, // private - processAdd : function(c){ - // If a single form Field, add it - if(this.isField(c)){ - this.form.add(c); - // If a Container, add any Fields it might contain - }else if(c.findBy){ - this.applySettings(c); - this.form.add.apply(this.form, c.findBy(this.isField)); + fixKeys : function(){ // load time branching for fastest keydown performance + if(Ext.isIE){ + return function(e){ + var k = e.getKey(), + doc = this.getDoc(), + r; + if(k == e.TAB){ + e.stopEvent(); + r = doc.selection.createRange(); + if(r){ + r.collapse(true); + r.pasteHTML('    '); + this.deferFocus(); + } + }else if(k == e.ENTER){ + r = doc.selection.createRange(); + if(r){ + var target = r.parentElement(); + if(!target || target.tagName.toLowerCase() != 'li'){ + e.stopEvent(); + r.pasteHTML(' '); + r.collapse(false); + r.select(); + } + } + } + }; + }else if(Ext.isOpera){ + return function(e){ + var k = e.getKey(); + if(k == e.TAB){ + e.stopEvent(); + this.win.focus(); + this.execCmd('InsertHTML','    '); + this.deferFocus(); + } + }; + }else if(Ext.isWebKit){ + return function(e){ + var k = e.getKey(); + if(k == e.TAB){ + e.stopEvent(); + this.execCmd('InsertText','\t'); + this.deferFocus(); + }else if(k == e.ENTER){ + e.stopEvent(); + this.execCmd('InsertHtml',' '); + this.deferFocus(); + } + }; } - }, + }(), - // private - onRemove: function(c){ - Ext.FormPanel.superclass.onRemove.call(this, c); - this.processRemove(c); + /** + * Returns the editor's toolbar. This is only available after the editor has been rendered. + * @return {Ext.Toolbar} + */ + getToolbar : function(){ + return this.tb; }, - onRemoveEvent: function(ct, c){ - if(ct !== this){ - this.processRemove(c); - } + /** + * Object collection of toolbar tooltips for the buttons in the editor. The key + * is the command id associated with that button and the value is a valid QuickTips object. + * For example: + +{ + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: 'x-html-editor-tip' }, - - // private - processRemove : function(c){ - // If a single form Field, remove it - if(this.isField(c)){ - this.form.remove(c); - // If a Container, its already destroyed by the time it gets here. Remove any references to destroyed fields. - }else if(c.findBy){ - var isDestroyed = function(o) { - return !!o.isDestroyed; - } - this.form.items.filterBy(isDestroyed, this.form).each(this.form.remove, this.form); + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: 'x-html-editor-tip' + }, + ... + + * @type Object + */ + buttonTips : { + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: 'x-html-editor-tip' + }, + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: 'x-html-editor-tip' + }, + underline : { + title: 'Underline (Ctrl+U)', + text: 'Underline the selected text.', + cls: 'x-html-editor-tip' + }, + increasefontsize : { + title: 'Grow Text', + text: 'Increase the font size.', + cls: 'x-html-editor-tip' + }, + decreasefontsize : { + title: 'Shrink Text', + text: 'Decrease the font size.', + cls: 'x-html-editor-tip' + }, + backcolor : { + title: 'Text Highlight Color', + text: 'Change the background color of the selected text.', + cls: 'x-html-editor-tip' + }, + forecolor : { + title: 'Font Color', + text: 'Change the color of the selected text.', + cls: 'x-html-editor-tip' + }, + justifyleft : { + title: 'Align Text Left', + text: 'Align text to the left.', + cls: 'x-html-editor-tip' + }, + justifycenter : { + title: 'Center Text', + text: 'Center text in the editor.', + cls: 'x-html-editor-tip' + }, + justifyright : { + title: 'Align Text Right', + text: 'Align text to the right.', + cls: 'x-html-editor-tip' + }, + insertunorderedlist : { + title: 'Bullet List', + text: 'Start a bulleted list.', + cls: 'x-html-editor-tip' + }, + insertorderedlist : { + title: 'Numbered List', + text: 'Start a numbered list.', + cls: 'x-html-editor-tip' + }, + createlink : { + title: 'Hyperlink', + text: 'Make the selected text a hyperlink.', + cls: 'x-html-editor-tip' + }, + sourceedit : { + title: 'Source Edit', + text: 'Switch to source editing mode.', + cls: 'x-html-editor-tip' } - }, + } + // hide stuff that is not compatible /** - * Starts monitoring of the valid state of this form. Usually this is done by passing the config - * option "monitorValid" + * @event blur + * @hide */ - startMonitoring : function(){ - if(!this.validTask){ - this.validTask = new Ext.util.TaskRunner(); - this.validTask.start({ - run : this.bindHandler, - interval : this.monitorPoll || 200, - scope: this - }); - } - }, - /** - * Stops monitoring of the valid state of this form + * @event change + * @hide */ - stopMonitoring : function(){ - if(this.validTask){ - this.validTask.stopAll(); - this.validTask = null; - } - }, - /** - * This is a proxy for the underlying BasicForm's {@link Ext.form.BasicForm#load} call. - * @param {Object} options The options to pass to the action (see {@link Ext.form.BasicForm#doAction} for details) + * @event focus + * @hide */ - load : function(){ - this.form.load.apply(this.form, arguments); - }, - - // private - onDisable : function(){ - Ext.FormPanel.superclass.onDisable.call(this); - if(this.form){ - this.form.items.each(function(){ - this.disable(); - }); - } - }, - - // private - onEnable : function(){ - Ext.FormPanel.superclass.onEnable.call(this); - if(this.form){ - this.form.items.each(function(){ - this.enable(); - }); - } - }, - - // private - bindHandler : function(){ - var valid = true; - this.form.items.each(function(f){ - if(!f.isValid(true)){ - valid = false; - return false; - } - }); - if(this.fbar){ - var fitems = this.fbar.items.items; - for(var i = 0, len = fitems.length; i < len; i++){ - var btn = fitems[i]; - if(btn.formBind === true && btn.disabled === valid){ - btn.setDisabled(!valid); - } - } - } - this.fireEvent('clientvalidation', this, valid); - } -}); -Ext.reg('form', Ext.FormPanel); - -Ext.form.FormPanel = Ext.FormPanel; -/** - * @class Ext.form.FieldSet - * @extends Ext.Panel - * Standard container used for grouping items within a {@link Ext.form.FormPanel form}. - * -var form = new Ext.FormPanel({ - title: 'Simple Form with FieldSets', - labelWidth: 75, // label settings here cascade unless overridden - url: 'save-form.php', - frame:true, - bodyStyle:'padding:5px 5px 0', - width: 700, - renderTo: document.body, - layout:'column', // arrange items in columns - defaults: { // defaults applied to items - layout: 'form', - border: false, - bodyStyle: 'padding:4px' - }, - items: [{ - // Fieldset in Column 1 - xtype:'fieldset', - columnWidth: 0.5, - title: 'Fieldset 1', - collapsible: true, - autoHeight:true, - defaults: { - anchor: '-20' // leave room for error icon - }, - defaultType: 'textfield', - items :[{ - fieldLabel: 'Field 1' - }, { - fieldLabel: 'Field 2' - }, { - fieldLabel: 'Field 3' - } - ] - },{ - // Fieldset in Column 2 - Panel inside - xtype:'fieldset', - title: 'Show Panel', // title, header, or checkboxToggle creates fieldset header - autoHeight:true, - columnWidth: 0.5, - checkboxToggle: true, - collapsed: true, // fieldset initially collapsed - layout:'anchor', - items :[{ - xtype: 'panel', - anchor: '100%', - title: 'Panel inside a fieldset', - frame: true, - height: 100 - }] - }] -}); - * - * @constructor - * @param {Object} config Configuration options - * @xtype fieldset - */ -Ext.form.FieldSet = Ext.extend(Ext.Panel, { - /** - * @cfg {Mixed} checkboxToggle true to render a checkbox into the fieldset frame just - * in front of the legend to expand/collapse the fieldset when the checkbox is toggled. (defaults - * to false). - * A {@link Ext.DomHelper DomHelper} element spec may also be specified to create the checkbox. - * If true is specified, the default DomHelper config object used to create the element - * is: - * {tag: 'input', type: 'checkbox', name: this.checkboxName || this.id+'-checkbox'} - * - */ - /** - * @cfg {String} checkboxName The name to assign to the fieldset's checkbox if {@link #checkboxToggle} = true - * (defaults to '[checkbox id]-checkbox'). - */ - /** - * @cfg {Boolean} collapsible - * true to make the fieldset collapsible and have the expand/collapse toggle button automatically - * rendered into the legend element, false to keep the fieldset statically sized with no collapse - * button (defaults to false). Another option is to configure {@link #checkboxToggle}. - */ - /** - * @cfg {Number} labelWidth The width of labels. This property cascades to child containers. - */ - /** - * @cfg {String} itemCls A css class to apply to the x-form-item of fields (see - * {@link Ext.layout.FormLayout}.{@link Ext.layout.FormLayout#fieldTpl fieldTpl} for details). - * This property cascades to child containers. - */ - /** - * @cfg {String} baseCls The base CSS class applied to the fieldset (defaults to 'x-fieldset'). - */ - baseCls : 'x-fieldset', - /** - * @cfg {String} layout The {@link Ext.Container#layout} to use inside the fieldset (defaults to 'form'). - */ - layout : 'form', - /** - * @cfg {Boolean} animCollapse - * true to animate the transition when the panel is collapsed, false to skip the - * animation (defaults to false). - */ - animCollapse : false, - - // private - onRender : function(ct, position){ - if(!this.el){ - this.el = document.createElement('fieldset'); - this.el.id = this.id; - if (this.title || this.header || this.checkboxToggle) { - this.el.appendChild(document.createElement('legend')).className = this.baseCls + '-header'; - } - } - - Ext.form.FieldSet.superclass.onRender.call(this, ct, position); - - if(this.checkboxToggle){ - var o = typeof this.checkboxToggle == 'object' ? - this.checkboxToggle : - {tag: 'input', type: 'checkbox', name: this.checkboxName || this.id+'-checkbox'}; - this.checkbox = this.header.insertFirst(o); - this.checkbox.dom.checked = !this.collapsed; - this.mon(this.checkbox, 'click', this.onCheckClick, this); - } - }, - - // private - onCollapse : function(doAnim, animArg){ - if(this.checkbox){ - this.checkbox.dom.checked = false; - } - Ext.form.FieldSet.superclass.onCollapse.call(this, doAnim, animArg); - - }, - - // private - onExpand : function(doAnim, animArg){ - if(this.checkbox){ - this.checkbox.dom.checked = true; - } - Ext.form.FieldSet.superclass.onExpand.call(this, doAnim, animArg); - }, - - /** - * This function is called by the fieldset's checkbox when it is toggled (only applies when - * checkboxToggle = true). This method should never be called externally, but can be - * overridden to provide custom behavior when the checkbox is toggled if needed. - */ - onCheckClick : function(){ - this[this.checkbox.dom.checked ? 'expand' : 'collapse'](); - } - - /** - * @cfg {String/Number} activeItem - * @hide - */ - /** - * @cfg {Mixed} applyTo - * @hide - */ - /** - * @cfg {Boolean} bodyBorder - * @hide - */ - /** - * @cfg {Boolean} border - * @hide - */ - /** - * @cfg {Boolean/Number} bufferResize - * @hide - */ - /** - * @cfg {Boolean} collapseFirst - * @hide - */ - /** - * @cfg {String} defaultType - * @hide - */ - /** - * @cfg {String} disabledClass - * @hide - */ - /** - * @cfg {String} elements - * @hide - */ - /** - * @cfg {Boolean} floating - * @hide - */ - /** - * @cfg {Boolean} footer - * @hide - */ - /** - * @cfg {Boolean} frame - * @hide - */ - /** - * @cfg {Boolean} header - * @hide - */ - /** - * @cfg {Boolean} headerAsText - * @hide - */ - /** - * @cfg {Boolean} hideCollapseTool - * @hide - */ - /** - * @cfg {String} iconCls - * @hide - */ - /** - * @cfg {Boolean/String} shadow - * @hide - */ - /** - * @cfg {Number} shadowOffset - * @hide - */ - /** - * @cfg {Boolean} shim - * @hide - */ - /** - * @cfg {Object/Array} tbar - * @hide - */ - /** - * @cfg {Array} tools - * @hide - */ - /** - * @cfg {Ext.Template/Ext.XTemplate} toolTemplate - * @hide - */ - /** - * @cfg {String} xtype - * @hide - */ - /** - * @property header - * @hide - */ - /** - * @property footer - * @hide - */ - /** - * @method focus - * @hide - */ - /** - * @method getBottomToolbar - * @hide - */ - /** - * @method getTopToolbar - * @hide - */ - /** - * @method setIconClass - * @hide - */ - /** - * @event activate - * @hide - */ - /** - * @event beforeclose - * @hide - */ - /** - * @event bodyresize - * @hide - */ - /** - * @event close - * @hide - */ - /** - * @event deactivate - * @hide - */ -}); -Ext.reg('fieldset', Ext.form.FieldSet); -/** - * @class Ext.form.HtmlEditor - * @extends Ext.form.Field - * Provides a lightweight HTML Editor component. Some toolbar features are not supported by Safari and will be - * automatically hidden when needed. These are noted in the config options where appropriate. - * The editor's toolbar buttons have tooltips defined in the {@link #buttonTips} property, but they are not - * enabled by default unless the global {@link Ext.QuickTips} singleton is {@link Ext.QuickTips#init initialized}. - * Note: The focus/blur and validation marking functionality inherited from Ext.form.Field is NOT - * supported by this editor. - * An Editor is a sensitive component that can't be used in all spots standard fields can be used. Putting an Editor within - * any element that has display set to 'none' can cause problems in Safari and Firefox due to their default iframe reloading bugs. - * Example usage: - * -// Simple example rendered with default options: -Ext.QuickTips.init(); // enable tooltips -new Ext.form.HtmlEditor({ - renderTo: Ext.getBody(), - width: 800, - height: 300 -}); - -// Passed via xtype into a container and with custom options: -Ext.QuickTips.init(); // enable tooltips -new Ext.Panel({ - title: 'HTML Editor', - renderTo: Ext.getBody(), - width: 600, - height: 300, - frame: true, - layout: 'fit', - items: { - xtype: 'htmleditor', - enableColors: false, - enableAlignments: false - } -}); - - * @constructor - * Create a new HtmlEditor - * @param {Object} config - * @xtype htmleditor - */ - -Ext.form.HtmlEditor = Ext.extend(Ext.form.Field, { /** - * @cfg {Boolean} enableFormat Enable the bold, italic and underline buttons (defaults to true) + * @event specialkey + * @hide */ - enableFormat : true, /** - * @cfg {Boolean} enableFontSize Enable the increase/decrease font size buttons (defaults to true) + * @cfg {String} fieldClass @hide */ - enableFontSize : true, /** - * @cfg {Boolean} enableColors Enable the fore/highlight color buttons (defaults to true) + * @cfg {String} focusClass @hide */ - enableColors : true, /** - * @cfg {Boolean} enableAlignments Enable the left, center, right alignment buttons (defaults to true) + * @cfg {String} autoCreate @hide */ - enableAlignments : true, /** - * @cfg {Boolean} enableLists Enable the bullet and numbered list buttons. Not available in Safari. (defaults to true) + * @cfg {String} inputType @hide */ - enableLists : true, /** - * @cfg {Boolean} enableSourceEdit Enable the switch to source edit button. Not available in Safari. (defaults to true) + * @cfg {String} invalidClass @hide */ - enableSourceEdit : true, /** - * @cfg {Boolean} enableLinks Enable the create link button. Not available in Safari. (defaults to true) + * @cfg {String} invalidText @hide */ - enableLinks : true, /** - * @cfg {Boolean} enableFont Enable font selection. Not available in Safari. (defaults to true) + * @cfg {String} msgFx @hide */ - enableFont : true, /** - * @cfg {String} createLinkText The default text for the create link prompt + * @cfg {String} validateOnBlur @hide */ - createLinkText : 'Please enter the URL for the link:', /** - * @cfg {String} defaultLinkValue The default value for the create link prompt (defaults to http:/ /) + * @cfg {Boolean} allowDomMove @hide */ - defaultLinkValue : 'http:/'+'/', /** - * @cfg {Array} fontFamilies An array of available font families + * @cfg {String} applyTo @hide */ - fontFamilies : [ - 'Arial', - 'Courier New', - 'Tahoma', - 'Times New Roman', - 'Verdana' - ], - defaultFont: 'tahoma', /** - * @cfg {String} defaultValue A default value to be put into the editor to resolve focus issues (defaults to (Non-breaking space) in Opera and IE6, (Zero-width space) in all other browsers). + * @cfg {String} autoHeight @hide */ - defaultValue: (Ext.isOpera || Ext.isIE6) ? ' ' : '', - - // private properties - actionMode: 'wrap', - validationEvent : false, - deferHeight: true, - initialized : false, - activated : false, - sourceEditMode : false, - onFocus : Ext.emptyFn, - iframePad:3, - hideMode:'offsets', - defaultAutoCreate : { - tag: "textarea", - style:"width:500px;height:300px;", - autocomplete: "off" - }, - - // private - initComponent : function(){ - this.addEvents( - /** - * @event initialize - * Fires when the editor is fully initialized (including the iframe) - * @param {HtmlEditor} this - */ - 'initialize', - /** - * @event activate - * Fires when the editor is first receives the focus. Any insertion must wait - * until after this event. - * @param {HtmlEditor} this - */ - 'activate', - /** - * @event beforesync - * Fires before the textarea is updated with content from the editor iframe. Return false - * to cancel the sync. - * @param {HtmlEditor} this - * @param {String} html - */ - 'beforesync', - /** - * @event beforepush - * Fires before the iframe editor is updated with content from the textarea. Return false - * to cancel the push. - * @param {HtmlEditor} this - * @param {String} html - */ - 'beforepush', - /** - * @event sync - * Fires when the textarea is updated with content from the editor iframe. - * @param {HtmlEditor} this - * @param {String} html - */ - 'sync', - /** - * @event push - * Fires when the iframe editor is updated with content from the textarea. - * @param {HtmlEditor} this - * @param {String} html - */ - 'push', - /** - * @event editmodechange - * Fires when the editor switches edit modes - * @param {HtmlEditor} this - * @param {Boolean} sourceEdit True if source edit, false if standard editing. - */ - 'editmodechange' - ) - }, - - // private - createFontOptions : function(){ - var buf = [], fs = this.fontFamilies, ff, lc; - for(var i = 0, len = fs.length; i< len; i++){ - ff = fs[i]; - lc = ff.toLowerCase(); - buf.push( - '' - ); - } - return buf.join(''); - }, - - /* - * Protected method that will not generally be called directly. It - * is called when the editor creates its toolbar. Override this method if you need to - * add custom toolbar buttons. - * @param {HtmlEditor} editor + /** + * @cfg {String} autoWidth @hide */ - createToolbar : function(editor){ - var items = []; - var tipsEnabled = Ext.QuickTips && Ext.QuickTips.isEnabled(); - - - function btn(id, toggle, handler){ - return { - itemId : id, - cls : 'x-btn-icon', - iconCls: 'x-edit-'+id, - enableToggle:toggle !== false, - scope: editor, - handler:handler||editor.relayBtnCmd, - clickEvent:'mousedown', - tooltip: tipsEnabled ? editor.buttonTips[id] || undefined : undefined, - overflowText: editor.buttonTips[id].title || undefined, - tabIndex:-1 - }; - } - - - if(this.enableFont && !Ext.isSafari2){ - var fontSelectItem = new Ext.Toolbar.Item({ - autoEl: { - tag:'select', - cls:'x-font-select', - html: this.createFontOptions() - } - }); - - items.push( - fontSelectItem, - '-' - ); - } - - if(this.enableFormat){ - items.push( - btn('bold'), - btn('italic'), - btn('underline') - ); - } - - if(this.enableFontSize){ - items.push( - '-', - btn('increasefontsize', false, this.adjustFont), - btn('decreasefontsize', false, this.adjustFont) - ); - } - - if(this.enableColors){ - items.push( - '-', { - itemId:'forecolor', - cls:'x-btn-icon', - iconCls: 'x-edit-forecolor', - clickEvent:'mousedown', - tooltip: tipsEnabled ? editor.buttonTips.forecolor || undefined : undefined, - tabIndex:-1, - menu : new Ext.menu.ColorMenu({ - allowReselect: true, - focus: Ext.emptyFn, - value:'000000', - plain:true, - listeners: { - scope: this, - select: function(cp, color){ - this.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color); - this.deferFocus(); - } - }, - clickEvent:'mousedown' - }) - }, { - itemId:'backcolor', - cls:'x-btn-icon', - iconCls: 'x-edit-backcolor', - clickEvent:'mousedown', - tooltip: tipsEnabled ? editor.buttonTips.backcolor || undefined : undefined, - tabIndex:-1, - menu : new Ext.menu.ColorMenu({ - focus: Ext.emptyFn, - value:'FFFFFF', - plain:true, - allowReselect: true, - listeners: { - scope: this, - select: function(cp, color){ - if(Ext.isGecko){ - this.execCmd('useCSS', false); - this.execCmd('hilitecolor', color); - this.execCmd('useCSS', true); - this.deferFocus(); - }else{ - this.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color); - this.deferFocus(); - } - } - }, - clickEvent:'mousedown' - }) - } - ); - } - - if(this.enableAlignments){ - items.push( - '-', - btn('justifyleft'), - btn('justifycenter'), - btn('justifyright') - ); - } - - if(!Ext.isSafari2){ - if(this.enableLinks){ - items.push( - '-', - btn('createlink', false, this.createLink) - ); - } - - if(this.enableLists){ - items.push( - '-', - btn('insertorderedlist'), - btn('insertunorderedlist') - ); - } - if(this.enableSourceEdit){ - items.push( - '-', - btn('sourceedit', true, function(btn){ - this.toggleSourceEdit(!this.sourceEditMode); - }) - ); - } - } - - // build the toolbar - var tb = new Ext.Toolbar({ - renderTo: this.wrap.dom.firstChild, - items: items - }); - - if (fontSelectItem) { - this.fontSelect = fontSelectItem.el; - - this.mon(this.fontSelect, 'change', function(){ - var font = this.fontSelect.dom.value; - this.relayCmd('fontname', font); - this.deferFocus(); - }, this); - } - - - // stop form submits - this.mon(tb.el, 'click', function(e){ - e.preventDefault(); - }); - - this.tb = tb; - }, - - onDisable: function(){ - this.wrap.mask(); - Ext.form.HtmlEditor.superclass.onDisable.call(this); - }, + /** + * @cfg {String} cls @hide + */ + /** + * @cfg {String} disabled @hide + */ + /** + * @cfg {String} disabledClass @hide + */ + /** + * @cfg {String} msgTarget @hide + */ + /** + * @cfg {String} readOnly @hide + */ + /** + * @cfg {String} style @hide + */ + /** + * @cfg {String} validationDelay @hide + */ + /** + * @cfg {String} validationEvent @hide + */ + /** + * @cfg {String} tabIndex @hide + */ + /** + * @property disabled + * @hide + */ + /** + * @method applyToMarkup + * @hide + */ + /** + * @method disable + * @hide + */ + /** + * @method enable + * @hide + */ + /** + * @method validate + * @hide + */ + /** + * @event valid + * @hide + */ + /** + * @method setDisabled + * @hide + */ + /** + * @cfg keys + * @hide + */ +}); +Ext.reg('htmleditor', Ext.form.HtmlEditor);/** + * @class Ext.form.TimeField + * @extends Ext.form.ComboBox + * Provides a time input field with a time dropdown and automatic time validation. Example usage: + * +new Ext.form.TimeField({ + minValue: '9:00 AM', + maxValue: '6:00 PM', + increment: 30 +}); + + * @constructor + * Create a new TimeField + * @param {Object} config + * @xtype timefield + */ +Ext.form.TimeField = Ext.extend(Ext.form.ComboBox, { + /** + * @cfg {Date/String} minValue + * The minimum allowed time. Can be either a Javascript date object with a valid time value or a string + * time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to undefined). + */ + minValue : undefined, + /** + * @cfg {Date/String} maxValue + * The maximum allowed time. Can be either a Javascript date object with a valid time value or a string + * time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to undefined). + */ + maxValue : undefined, + /** + * @cfg {String} minText + * The error text to display when the date in the cell is before minValue (defaults to + * 'The time in this field must be equal to or after {0}'). + */ + minText : "The time in this field must be equal to or after {0}", + /** + * @cfg {String} maxText + * The error text to display when the time is after maxValue (defaults to + * 'The time in this field must be equal to or before {0}'). + */ + maxText : "The time in this field must be equal to or before {0}", + /** + * @cfg {String} invalidText + * The error text to display when the time in the field is invalid (defaults to + * '{value} is not a valid time'). + */ + invalidText : "{0} is not a valid time", + /** + * @cfg {String} format + * The default time format string which can be overriden for localization support. The format must be + * valid according to {@link Date#parseDate} (defaults to 'g:i A', e.g., '3:15 PM'). For 24-hour time + * format try 'H:i' instead. + */ + format : "g:i A", + /** + * @cfg {String} altFormats + * Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined + * format (defaults to 'g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A'). + */ + altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A", + /** + * @cfg {Number} increment + * The number of minutes between each time value in the list (defaults to 15). + */ + increment: 15, - onEnable: function(){ - this.wrap.unmask(); - Ext.form.HtmlEditor.superclass.onEnable.call(this); - }, + // private override + mode: 'local', + // private override + triggerAction: 'all', + // private override + typeAhead: false, - setReadOnly: function(readOnly){ + // private - This is the date to use when generating time values in the absence of either minValue + // or maxValue. Using the current date causes DST issues on DST boundary dates, so this is an + // arbitrary "safe" date that can be any date aside from DST boundary dates. + initDate: '1/1/2008', - Ext.form.HtmlEditor.superclass.setReadOnly.call(this, readOnly); - if(this.initialized){ - this.setDesignMode(!readOnly); - var bd = this.getEditorBody(); - if(bd){ - bd.style.cursor = this.readOnly ? 'default' : 'text'; - } - this.disableItems(readOnly); - } + initDateFormat: 'j/n/Y', + + // private + initComponent : function(){ + if(Ext.isDefined(this.minValue)){ + this.setMinValue(this.minValue, true); + } + if(Ext.isDefined(this.maxValue)){ + this.setMaxValue(this.maxValue, true); + } + if(!this.store){ + this.generateStore(true); + } + Ext.form.TimeField.superclass.initComponent.call(this); }, /** - * Protected method that will not generally be called directly. It - * is called when the editor initializes the iframe with HTML contents. Override this method if you - * want to change the initialization markup of the iframe (e.g. to add stylesheets). - * - * Note: IE8-Standards has unwanted scroller behavior, so the default meta tag forces IE7 compatibility + * Replaces any existing {@link #minValue} with the new time and refreshes the store. + * @param {Date/String} value The minimum time that can be selected */ - getDocMarkup : function(){ - return ''; + setMinValue: function(value, /* private */ initial){ + this.setLimit(value, true, initial); + return this; }, - // private - getEditorBody : function(){ - var doc = this.getDoc(); - return doc.body || doc.documentElement; + /** + * Replaces any existing {@link #maxValue} with the new time and refreshes the store. + * @param {Date/String} value The maximum time that can be selected + */ + setMaxValue: function(value, /* private */ initial){ + this.setLimit(value, false, initial); + return this; }, // private - getDoc : function(){ - return Ext.isIE ? this.getWin().document : (this.iframe.contentDocument || this.getWin().document); - }, + generateStore: function(initial){ + var min = this.minValue || new Date(this.initDate).clearTime(), + max = this.maxValue || new Date(this.initDate).clearTime().add('mi', (24 * 60) - 1), + times = []; - // private - getWin : function(){ - return Ext.isIE ? this.iframe.contentWindow : window.frames[this.iframe.name]; + while(min <= max){ + times.push(min.dateFormat(this.format)); + min = min.add('mi', this.increment); + } + this.bindStore(times, initial); }, // private - onRender : function(ct, position){ - Ext.form.HtmlEditor.superclass.onRender.call(this, ct, position); - this.el.dom.style.border = '0 none'; - this.el.dom.setAttribute('tabIndex', -1); - this.el.addClass('x-hidden'); - if(Ext.isIE){ // fix IE 1px bogus margin - this.el.applyStyles('margin-top:-1px;margin-bottom:-1px;') + setLimit: function(value, isMin, initial){ + var d; + if(Ext.isString(value)){ + d = this.parseDate(value); + }else if(Ext.isDate(value)){ + d = value; } - this.wrap = this.el.wrap({ - cls:'x-html-editor-wrap', cn:{cls:'x-html-editor-tb'} - }); - - this.createToolbar(this); - - this.disableItems(true); - - this.tb.doLayout(); - - this.createIFrame(); - - if(!this.width){ - var sz = this.el.getSize(); - this.setSize(sz.width, this.height || sz.height); + if(d){ + var val = new Date(this.initDate).clearTime(); + val.setHours(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()); + this[isMin ? 'minValue' : 'maxValue'] = val; + if(!initial){ + this.generateStore(); + } } - this.resizeEl = this.positionEl = this.wrap; }, - createIFrame: function(){ - var iframe = document.createElement('iframe'); - iframe.name = Ext.id(); - iframe.frameBorder = '0'; - iframe.style.overflow = 'auto'; - - this.wrap.dom.appendChild(iframe); - this.iframe = iframe; + // inherited docs + getValue : function(){ + var v = Ext.form.TimeField.superclass.getValue.call(this); + return this.formatDate(this.parseDate(v)) || ''; + }, - this.monitorTask = Ext.TaskMgr.start({ - run: this.checkDesignMode, - scope: this, - interval:100 - }); + // inherited docs + setValue : function(value){ + return Ext.form.TimeField.superclass.setValue.call(this, this.formatDate(this.parseDate(value))); }, - initFrame : function(){ - Ext.TaskMgr.stop(this.monitorTask); - var doc = this.getDoc(); - this.win = this.getWin(); + // private overrides + validateValue : Ext.form.DateField.prototype.validateValue, - doc.open(); - doc.write(this.getDocMarkup()); - doc.close(); + formatDate : Ext.form.DateField.prototype.formatDate, - var task = { // must defer to wait for browser to be ready - run : function(){ - var doc = this.getDoc(); - if(doc.body || doc.readyState == 'complete'){ - Ext.TaskMgr.stop(task); - this.setDesignMode(true); - this.initEditor.defer(10, this); - } - }, - interval : 10, - duration:10000, - scope: this - }; - Ext.TaskMgr.start(task); - }, + parseDate: function(value) { + if (!value || Ext.isDate(value)) { + return value; + } + var id = this.initDate + ' ', + idf = this.initDateFormat + ' ', + v = Date.parseDate(id + value, idf + this.format), // *** handle DST. note: this.format is a TIME-only format + af = this.altFormats; - checkDesignMode : function(){ - if(this.wrap && this.wrap.dom.offsetWidth){ - var doc = this.getDoc(); - if(!doc){ - return; + if (!v && af) { + if (!this.altFormatsArray) { + this.altFormatsArray = af.split("|"); } - if(!doc.editorInitialized || this.getDesignMode() != 'on'){ - this.initFrame(); + for (var i = 0, afa = this.altFormatsArray, len = afa.length; i < len && !v; i++) { + v = Date.parseDate(id + value, idf + afa[i]); } } + + return v; + } +}); +Ext.reg('timefield', Ext.form.TimeField);/** + * @class Ext.form.SliderField + * @extends Ext.form.Field + * Wraps a {@link Ext.Slider Slider} so it can be used as a form field. + * @constructor + * Creates a new SliderField + * @param {Object} config Configuration options. Note that you can pass in any slider configuration options, as well as + * as any field configuration options. + * @xtype sliderfield + */ +Ext.form.SliderField = Ext.extend(Ext.form.Field, { + + /** + * @cfg {Boolean} useTips + * True to use an Ext.slider.Tip to display tips for the value. Defaults to true. + */ + useTips : true, + + /** + * @cfg {Function} tipText + * A function used to display custom text for the slider tip. Defaults to null, which will + * use the default on the plugin. + */ + tipText : null, + + // private override + actionMode: 'wrap', + + /** + * Initialize the component. + * @private + */ + initComponent : function() { + var cfg = Ext.copyTo({ + id: this.id + '-slider' + }, this.initialConfig, ['vertical', 'minValue', 'maxValue', 'decimalPrecision', 'keyIncrement', 'increment', 'clickToChange', 'animate']); + + // only can use it if it exists. + if (this.useTips) { + var plug = this.tipText ? {getText: this.tipText} : {}; + cfg.plugins = [new Ext.slider.Tip(plug)]; + } + this.slider = new Ext.Slider(cfg); + Ext.form.SliderField.superclass.initComponent.call(this); + }, + + /** + * Set up the hidden field + * @param {Object} ct The container to render to. + * @param {Object} position The position in the container to render to. + * @private + */ + onRender : function(ct, position){ + this.autoCreate = { + id: this.id, + name: this.name, + type: 'hidden', + tag: 'input' + }; + Ext.form.SliderField.superclass.onRender.call(this, ct, position); + this.wrap = this.el.wrap({cls: 'x-form-field-wrap'}); + this.slider.render(this.wrap); }, - - /* private - * set current design mode. To enable, mode can be true or 'on', off otherwise - */ - setDesignMode : function(mode){ - var doc ; - if(doc = this.getDoc()){ - if(this.readOnly){ - mode = false; - } - doc.designMode = (/on|true/i).test(String(mode).toLowerCase()) ?'on':'off'; - } - - }, - - // private - getDesignMode : function(){ - var doc = this.getDoc(); - if(!doc){ return ''; } - return String(doc.designMode).toLowerCase(); - - }, - - disableItems: function(disabled){ - if(this.fontSelect){ - this.fontSelect.dom.disabled = disabled; + + /** + * Ensure that the slider size is set automatically when the field resizes. + * @param {Object} w The width + * @param {Object} h The height + * @param {Object} aw The adjusted width + * @param {Object} ah The adjusted height + * @private + */ + onResize : function(w, h, aw, ah){ + Ext.form.SliderField.superclass.onResize.call(this, w, h, aw, ah); + this.slider.setSize(w, h); + }, + + /** + * Initialize any events for this class. + * @private + */ + initEvents : function(){ + Ext.form.SliderField.superclass.initEvents.call(this); + this.slider.on('change', this.onChange, this); + }, + + /** + * Utility method to set the value of the field when the slider changes. + * @param {Object} slider The slider object. + * @param {Object} v The new value. + * @private + */ + onChange : function(slider, v){ + this.setValue(v, undefined, true); + }, + + /** + * Enable the slider when the field is enabled. + * @private + */ + onEnable : function(){ + Ext.form.SliderField.superclass.onEnable.call(this); + this.slider.enable(); + }, + + /** + * Disable the slider when the field is disabled. + * @private + */ + onDisable : function(){ + Ext.form.SliderField.superclass.onDisable.call(this); + this.slider.disable(); + }, + + /** + * Ensure the slider is destroyed when the field is destroyed. + * @private + */ + beforeDestroy : function(){ + Ext.destroy(this.slider); + Ext.form.SliderField.superclass.beforeDestroy.call(this); + }, + + /** + * If a side icon is shown, do alignment to the slider + * @private + */ + alignErrorIcon : function(){ + this.errorIcon.alignTo(this.slider.el, 'tl-tr', [2, 0]); + }, + + /** + * Sets the minimum field value. + * @param {Number} v The new minimum value. + * @return {Ext.form.SliderField} this + */ + setMinValue : function(v){ + this.slider.setMinValue(v); + return this; + }, + + /** + * Sets the maximum field value. + * @param {Number} v The new maximum value. + * @return {Ext.form.SliderField} this + */ + setMaxValue : function(v){ + this.slider.setMaxValue(v); + return this; + }, + + /** + * Sets the value for this field. + * @param {Number} v The new value. + * @param {Boolean} animate (optional) Whether to animate the transition. If not specified, it will default to the animate config. + * @return {Ext.form.SliderField} this + */ + setValue : function(v, animate, /* private */ silent){ + // silent is used if the setValue method is invoked by the slider + // which means we don't need to set the value on the slider. + if(!silent){ + this.slider.setValue(v, animate); } - this.tb.items.each(function(item){ - if(item.getItemId() != 'sourceedit'){ - item.setDisabled(disabled); - } - }); + return Ext.form.SliderField.superclass.setValue.call(this, this.slider.getValue()); }, + + /** + * Gets the current value for this field. + * @return {Number} The current value. + */ + getValue : function(){ + return this.slider.getValue(); + } +}); + +Ext.reg('sliderfield', Ext.form.SliderField);/** + * @class Ext.form.Label + * @extends Ext.BoxComponent + * Basic Label field. + * @constructor + * Creates a new Label + * @param {Ext.Element/String/Object} config The configuration options. If an element is passed, it is set as the internal + * element and its id used as the component id. If a string is passed, it is assumed to be the id of an existing element + * and is used as the component id. Otherwise, it is assumed to be a standard config object and is applied to the component. + * @xtype label + */ +Ext.form.Label = Ext.extend(Ext.BoxComponent, { + /** + * @cfg {String} text The plain text to display within the label (defaults to ''). If you need to include HTML + * tags within the label's innerHTML, use the {@link #html} config instead. + */ + /** + * @cfg {String} forId The id of the input element to which this label will be bound via the standard HTML 'for' + * attribute. If not specified, the attribute will not be added to the label. + */ + /** + * @cfg {String} html An HTML fragment that will be used as the label's innerHTML (defaults to ''). + * Note that if {@link #text} is specified it will take precedence and this value will be ignored. + */ // private - onResize : function(w, h){ - Ext.form.HtmlEditor.superclass.onResize.apply(this, arguments); - if(this.el && this.iframe){ - if(Ext.isNumber(w)){ - var aw = w - this.wrap.getFrameWidth('lr'); - this.el.setWidth(aw); - this.tb.setWidth(aw); - this.iframe.style.width = Math.max(aw, 0) + 'px'; - } - if(Ext.isNumber(h)){ - var ah = h - this.wrap.getFrameWidth('tb') - this.tb.el.getHeight(); - this.el.setHeight(ah); - this.iframe.style.height = Math.max(ah, 0) + 'px'; - var bd = this.getEditorBody(); - if(bd){ - bd.style.height = Math.max((ah - (this.iframePad*2)), 0) + 'px'; - } + onRender : function(ct, position){ + if(!this.el){ + this.el = document.createElement('label'); + this.el.id = this.getId(); + this.el.innerHTML = this.text ? Ext.util.Format.htmlEncode(this.text) : (this.html || ''); + if(this.forId){ + this.el.setAttribute('for', this.forId); } } + Ext.form.Label.superclass.onRender.call(this, ct, position); }, /** - * Toggles the editor between standard and source edit mode. - * @param {Boolean} sourceEdit (optional) True for source edit, false for standard + * Updates the label's innerHTML with the specified string. + * @param {String} text The new label text + * @param {Boolean} encode (optional) False to skip HTML-encoding the text when rendering it + * to the label (defaults to true which encodes the value). This might be useful if you want to include + * tags in the label's innerHTML rather than rendering them as string literals per the default logic. + * @return {Label} this */ - toggleSourceEdit : function(sourceEditMode){ - if(sourceEditMode === undefined){ - sourceEditMode = !this.sourceEditMode; + setText : function(t, encode){ + var e = encode === false; + this[!e ? 'text' : 'html'] = t; + delete this[e ? 'text' : 'html']; + if(this.rendered){ + this.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(t) : t; } - this.sourceEditMode = sourceEditMode === true; - var btn = this.tb.getComponent('sourceedit'); + return this; + } +}); - if(btn.pressed !== this.sourceEditMode){ - btn.toggle(this.sourceEditMode); - if(!btn.xtbHidden){ - return; - } +Ext.reg('label', Ext.form.Label);/** + * @class Ext.form.Action + * The subclasses of this class provide actions to perform upon {@link Ext.form.BasicForm Form}s. + * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when + * the Form needs to perform an action such as submit or load. The Configuration options + * listed for this class are set through the Form's action methods: {@link Ext.form.BasicForm#submit submit}, + * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction} + * The instance of Action which performed the action is passed to the success + * and failure callbacks of the Form's action methods ({@link Ext.form.BasicForm#submit submit}, + * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction}), + * and to the {@link Ext.form.BasicForm#actioncomplete actioncomplete} and + * {@link Ext.form.BasicForm#actionfailed actionfailed} event handlers. + */ +Ext.form.Action = function(form, options){ + this.form = form; + this.options = options || {}; +}; + +/** + * Failure type returned when client side validation of the Form fails + * thus aborting a submit action. Client side validation is performed unless + * {@link #clientValidation} is explicitly set to false. + * @type {String} + * @static + */ +Ext.form.Action.CLIENT_INVALID = 'client'; +/** + * Failure type returned when server side processing fails and the {@link #result}'s + * success property is set to false. + * In the case of a form submission, field-specific error messages may be returned in the + * {@link #result}'s errors property. + * @type {String} + * @static + */ +Ext.form.Action.SERVER_INVALID = 'server'; +/** + * Failure type returned when a communication error happens when attempting + * to send a request to the remote server. The {@link #response} may be examined to + * provide further information. + * @type {String} + * @static + */ +Ext.form.Action.CONNECT_FAILURE = 'connect'; +/** + * Failure type returned when the response's success + * property is set to false, or no field values are returned in the response's + * data property. + * @type {String} + * @static + */ +Ext.form.Action.LOAD_FAILURE = 'load'; + +Ext.form.Action.prototype = { +/** + * @cfg {String} url The URL that the Action is to invoke. + */ +/** + * @cfg {Boolean} reset When set to true, causes the Form to be + * {@link Ext.form.BasicForm.reset reset} on Action success. If specified, this happens + * before the {@link #success} callback is called and before the Form's + * {@link Ext.form.BasicForm.actioncomplete actioncomplete} event fires. + */ +/** + * @cfg {String} method The HTTP method to use to access the requested URL. Defaults to the + * {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method. + */ +/** + * @cfg {Mixed} params Extra parameter values to pass. These are added to the Form's + * {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's + * input fields. + * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. + */ +/** + * @cfg {Number} timeout The number of seconds to wait for a server response before + * failing with the {@link #failureType} as {@link #Action.CONNECT_FAILURE}. If not specified, + * defaults to the configured {@link Ext.form.BasicForm#timeout timeout} of the + * {@link Ext.form.BasicForm form}. + */ +/** + * @cfg {Function} success The function to call when a valid success return packet is recieved. + * The function is passed the following parameters: + * form : Ext.form.BasicFormThe form that requested the action + * action : Ext.form.ActionThe Action class. The {@link #result} + * property of this object may be examined to perform custom postprocessing. + * + */ +/** + * @cfg {Function} failure The function to call when a failure packet was recieved, or when an + * error ocurred in the Ajax communication. + * The function is passed the following parameters: + * form : Ext.form.BasicFormThe form that requested the action + * action : Ext.form.ActionThe Action class. If an Ajax + * error ocurred, the failure type will be in {@link #failureType}. The {@link #result} + * property of this object may be examined to perform custom postprocessing. + * + */ +/** + * @cfg {Object} scope The scope in which to call the callback functions (The this reference + * for the callback functions). + */ +/** + * @cfg {String} waitMsg The message to be displayed by a call to {@link Ext.MessageBox#wait} + * during the time the action is being processed. + */ +/** + * @cfg {String} waitTitle The title to be displayed by a call to {@link Ext.MessageBox#wait} + * during the time the action is being processed. + */ + +/** + * @cfg {Boolean} submitEmptyText If set to true, the emptyText value will be sent with the form + * when it is submitted. Defaults to true. + */ + +/** + * The type of action this Action instance performs. + * Currently only "submit" and "load" are supported. + * @type {String} + */ + type : 'default', +/** + * The type of failure detected will be one of these: {@link #CLIENT_INVALID}, + * {@link #SERVER_INVALID}, {@link #CONNECT_FAILURE}, or {@link #LOAD_FAILURE}. Usage: + * +var fp = new Ext.form.FormPanel({ +... +buttons: [{ + text: 'Save', + formBind: true, + handler: function(){ + if(fp.getForm().isValid()){ + fp.getForm().submit({ + url: 'form-submit.php', + waitMsg: 'Submitting your data...', + success: function(form, action){ + // server responded with success = true + var result = action.{@link #result}; + }, + failure: function(form, action){ + if (action.{@link #failureType} === Ext.form.Action.{@link #CONNECT_FAILURE}) { + Ext.Msg.alert('Error', + 'Status:'+action.{@link #response}.status+': '+ + action.{@link #response}.statusText); + } + if (action.failureType === Ext.form.Action.{@link #SERVER_INVALID}){ + // server responded with success = false + Ext.Msg.alert('Invalid', action.{@link #result}.errormsg); + } + } + }); } - if(this.sourceEditMode){ - this.disableItems(true); - this.syncValue(); - this.iframe.className = 'x-hidden'; - this.el.removeClass('x-hidden'); - this.el.dom.removeAttribute('tabIndex'); - this.el.focus(); - }else{ - if(this.initialized){ - this.disableItems(this.readOnly); - } - this.pushValue(); - this.iframe.className = ''; - this.el.addClass('x-hidden'); - this.el.dom.setAttribute('tabIndex', -1); - this.deferFocus(); + } +},{ + text: 'Reset', + handler: function(){ + fp.getForm().reset(); + } +}] + * + * @property failureType + * @type {String} + */ + /** + * The XMLHttpRequest object used to perform the action. + * @property response + * @type {Object} + */ + /** + * The decoded response object containing a boolean success property and + * other, action-specific properties. + * @property result + * @type {Object} + */ + + // interface method + run : function(options){ + + }, + + // interface method + success : function(response){ + + }, + + // interface method + handleResponse : function(response){ + + }, + + // default connection failure + failure : function(response){ + this.response = response; + this.failureType = Ext.form.Action.CONNECT_FAILURE; + this.form.afterAction(this, false); + }, + + // private + // shared code among all Actions to validate that there was a response + // with either responseText or responseXml + processResponse : function(response){ + this.response = response; + if(!response.responseText && !response.responseXML){ + return true; } - var lastSize = this.lastSize; - if(lastSize){ - delete this.lastSize; - this.setSize(lastSize); + this.result = this.handleResponse(response); + return this.result; + }, + + // utility functions used internally + getUrl : function(appendParams){ + var url = this.options.url || this.form.url || this.form.el.dom.action; + if(appendParams){ + var p = this.getParams(); + if(p){ + url = Ext.urlAppend(url, p); + } } - this.fireEvent('editmodechange', this, this.sourceEditMode); + return url; }, - // private used internally - createLink : function(){ - var url = prompt(this.createLinkText, this.defaultLinkValue); - if(url && url != 'http:/'+'/'){ - this.relayCmd('createlink', url); + // private + getMethod : function(){ + return (this.options.method || this.form.method || this.form.el.dom.method || 'POST').toUpperCase(); + }, + + // private + getParams : function(){ + var bp = this.form.baseParams; + var p = this.options.params; + if(p){ + if(typeof p == "object"){ + p = Ext.urlEncode(Ext.applyIf(p, bp)); + }else if(typeof p == 'string' && bp){ + p += '&' + Ext.urlEncode(bp); + } + }else if(bp){ + p = Ext.urlEncode(bp); } + return p; }, // private - initEvents : function(){ - this.originalValue = this.getValue(); - }, + createCallback : function(opts){ + var opts = opts || {}; + return { + success: this.success, + failure: this.failure, + scope: this, + timeout: (opts.timeout*1000) || (this.form.timeout*1000), + upload: this.form.fileUpload ? this.success : undefined + }; + } +}; + +/** + * @class Ext.form.Action.Submit + * @extends Ext.form.Action + * A class which handles submission of data from {@link Ext.form.BasicForm Form}s + * and processes the returned response. + * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when + * {@link Ext.form.BasicForm#submit submit}ting. + * Response Packet Criteria + * A response packet may contain: + * + * success property : Boolean + * The success property is required. + * errors property : Object + * The errors property, + * which is optional, contains error messages for invalid fields. + * + * JSON Packets + * By default, response packets are assumed to be JSON, so a typical response + * packet may look like this: +{ + success: false, + errors: { + clientCode: "Client not found", + portOfLoading: "This field must not be null" + } +} + * Other data may be placed into the response for processing by the {@link Ext.form.BasicForm}'s callback + * or event handler methods. The object decoded from this JSON is available in the + * {@link Ext.form.Action#result result} property. + * Alternatively, if an {@link #errorReader} is specified as an {@link Ext.data.XmlReader XmlReader}: + errorReader: new Ext.data.XmlReader({ + record : 'field', + success: '@success' + }, [ + 'id', 'msg' + ] + ) + + * then the results may be sent back in XML format: +<?xml version="1.0" encoding="UTF-8"?> +<message success="false"> +<errors> + <field> + <id>clientCode</id> + <msg><![CDATA[Code not found. <br /><i>This is a test validation message from the server </i>]]></msg> + </field> + <field> + <id>portOfLoading</id> + <msg><![CDATA[Port not found. <br /><i>This is a test validation message from the server </i>]]></msg> + </field> +</errors> +</message> + + * Other elements may be placed into the response XML for processing by the {@link Ext.form.BasicForm}'s callback + * or event handler methods. The XML document is available in the {@link #errorReader}'s {@link Ext.data.XmlReader#xmlData xmlData} property. + */ +Ext.form.Action.Submit = function(form, options){ + Ext.form.Action.Submit.superclass.constructor.call(this, form, options); +}; +Ext.extend(Ext.form.Action.Submit, Ext.form.Action, { /** - * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide - * @method + * @cfg {Ext.data.DataReader} errorReader Optional. JSON is interpreted with + * no need for an errorReader. + * A Reader which reads a single record from the returned data. The DataReader's + * success property specifies how submission success is determined. The Record's + * data provides the error messages to apply to any invalid form Fields. */ - markInvalid : Ext.emptyFn, - /** - * Overridden and disabled. The editor element does not support standard valid/invalid marking. @hide - * @method + * @cfg {boolean} clientValidation Determines whether a Form's fields are validated + * in a final call to {@link Ext.form.BasicForm#isValid isValid} prior to submission. + * Pass false in the Form's submit options to prevent this. If not defined, pre-submission field validation + * is performed. */ - clearInvalid : Ext.emptyFn, + type : 'submit', - // docs inherit from Field - setValue : function(v){ - Ext.form.HtmlEditor.superclass.setValue.call(this, v); - this.pushValue(); - return this; + // private + run : function(){ + var o = this.options, + method = this.getMethod(), + isGet = method == 'GET'; + if(o.clientValidation === false || this.form.isValid()){ + if (o.submitEmptyText === false) { + var fields = this.form.items, + emptyFields = []; + fields.each(function(f) { + if (f.el.getValue() == f.emptyText) { + emptyFields.push(f); + f.el.dom.value = ""; + } + }); + } + Ext.Ajax.request(Ext.apply(this.createCallback(o), { + form:this.form.el.dom, + url:this.getUrl(isGet), + method: method, + headers: o.headers, + params:!isGet ? this.getParams() : null, + isUpload: this.form.fileUpload + })); + if (o.submitEmptyText === false) { + Ext.each(emptyFields, function(f) { + if (f.applyEmptyText) { + f.applyEmptyText(); + } + }); + } + }else if (o.clientValidation !== false){ // client validation failed + this.failureType = Ext.form.Action.CLIENT_INVALID; + this.form.afterAction(this, false); + } }, - /** - * Protected method that will not generally be called directly. If you need/want - * custom HTML cleanup, this is the method you should override. - * @param {String} html The HTML to be cleaned - * @return {String} The cleaned HTML - */ - cleanHtml: function(html) { - html = String(html); - if(Ext.isWebKit){ // strip safari nonsense - html = html.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi, ''); + // private + success : function(response){ + var result = this.processResponse(response); + if(result === true || result.success){ + this.form.afterAction(this, true); + return; } - - /* - * Neat little hack. Strips out all the non-digit characters from the default - * value and compares it to the character code of the first character in the string - * because it can cause encoding issues when posted to the server. - */ - if(html.charCodeAt(0) == this.defaultValue.replace(/\D/g, '')){ - html = html.substring(1); + if(result.errors){ + this.form.markInvalid(result.errors); } - return html; + this.failureType = Ext.form.Action.SERVER_INVALID; + this.form.afterAction(this, false); }, - /** - * Protected method that will not generally be called directly. Syncs the contents - * of the editor iframe with the textarea. - */ - syncValue : function(){ - if(this.initialized){ - var bd = this.getEditorBody(); - var html = bd.innerHTML; - if(Ext.isWebKit){ - var bs = bd.getAttribute('style'); // Safari puts text-align styles on the body element! - var m = bs.match(/text-align:(.*?);/i); - if(m && m[1]){ - html = '' + html + ''; + // private + handleResponse : function(response){ + if(this.form.errorReader){ + var rs = this.form.errorReader.read(response); + var errors = []; + if(rs.records){ + for(var i = 0, len = rs.records.length; i < len; i++) { + var r = rs.records[i]; + errors[i] = r.data; } } - html = this.cleanHtml(html); - if(this.fireEvent('beforesync', this, html) !== false){ - this.el.dom.value = html; - this.fireEvent('sync', this, html); + if(errors.length < 1){ + errors = null; } + return { + success : rs.success, + errors : errors + }; } - }, + return Ext.decode(response.responseText); + } +}); - //docs inherit from Field - getValue : function() { - this[this.sourceEditMode ? 'pushValue' : 'syncValue'](); - return Ext.form.HtmlEditor.superclass.getValue.call(this); - }, - /** - * Protected method that will not generally be called directly. Pushes the value of the textarea - * into the iframe editor. - */ - pushValue : function(){ - if(this.initialized){ - var v = this.el.dom.value; - if(!this.activated && v.length < 1){ - v = this.defaultValue; - } - if(this.fireEvent('beforepush', this, v) !== false){ - this.getEditorBody().innerHTML = v; - if(Ext.isGecko){ - // Gecko hack, see: https://bugzilla.mozilla.org/show_bug.cgi?id=232791#c8 - this.setDesignMode(false); //toggle off first - - } - this.setDesignMode(true); - this.fireEvent('push', this, v); - } - - } +/** + * @class Ext.form.Action.Load + * @extends Ext.form.Action + * A class which handles loading of data from a server into the Fields of an {@link Ext.form.BasicForm}. + * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when + * {@link Ext.form.BasicForm#load load}ing. + * Response Packet Criteria + * A response packet must contain: + * + * success property : Boolean + * data property : Object + * The data property contains the values of Fields to load. + * The individual value object for each Field is passed to the Field's + * {@link Ext.form.Field#setValue setValue} method. + * + * JSON Packets + * By default, response packets are assumed to be JSON, so for the following form load call: +var myFormPanel = new Ext.form.FormPanel({ + title: 'Client and routing info', + items: [{ + fieldLabel: 'Client', + name: 'clientName' + }, { + fieldLabel: 'Port of loading', + name: 'portOfLoading' + }, { + fieldLabel: 'Port of discharge', + name: 'portOfDischarge' + }] +}); +myFormPanel.{@link Ext.form.FormPanel#getForm getForm}().{@link Ext.form.BasicForm#load load}({ + url: '/getRoutingInfo.php', + params: { + consignmentRef: myConsignmentRef }, + failure: function(form, action) { + Ext.Msg.alert("Load failed", action.result.errorMessage); + } +}); + + * a success response packet may look like this: +{ + success: true, + data: { + clientName: "Fred. Olsen Lines", + portOfLoading: "FXT", + portOfDischarge: "OSL" + } +} + * while a failure response packet may look like this: +{ + success: false, + errorMessage: "Consignment reference not found" +} + * Other data may be placed into the response for processing the {@link Ext.form.BasicForm Form}'s + * callback or event handler methods. The object decoded from this JSON is available in the + * {@link Ext.form.Action#result result} property. + */ +Ext.form.Action.Load = function(form, options){ + Ext.form.Action.Load.superclass.constructor.call(this, form, options); + this.reader = this.form.reader; +}; +Ext.extend(Ext.form.Action.Load, Ext.form.Action, { // private - deferFocus : function(){ - this.focus.defer(10, this); + type : 'load', + + // private + run : function(){ + Ext.Ajax.request(Ext.apply( + this.createCallback(this.options), { + method:this.getMethod(), + url:this.getUrl(false), + headers: this.options.headers, + params:this.getParams() + })); }, - // docs inherit from Field - focus : function(){ - if(this.win && !this.sourceEditMode){ - this.win.focus(); - }else{ - this.el.focus(); + // private + success : function(response){ + var result = this.processResponse(response); + if(result === true || !result.success || !result.data){ + this.failureType = Ext.form.Action.LOAD_FAILURE; + this.form.afterAction(this, false); + return; } + this.form.clearInvalid(); + this.form.setValues(result.data); + this.form.afterAction(this, true); }, // private - initEditor : function(){ - //Destroying the component during/before initEditor can cause issues. - try{ - var dbody = this.getEditorBody(), - ss = this.el.getStyles('font-size', 'font-family', 'background-image', 'background-repeat'), - doc, - fn; - - ss['background-attachment'] = 'fixed'; // w3c - dbody.bgProperties = 'fixed'; // ie + handleResponse : function(response){ + if(this.form.reader){ + var rs = this.form.reader.read(response); + var data = rs.records && rs.records[0] ? rs.records[0].data : null; + return { + success : rs.success, + data : data + }; + } + return Ext.decode(response.responseText); + } +}); - Ext.DomHelper.applyStyles(dbody, ss); - doc = this.getDoc(); - if(doc){ - try{ - Ext.EventManager.removeAll(doc); - }catch(e){} - } +/** + * @class Ext.form.Action.DirectLoad + * @extends Ext.form.Action.Load + * Provides Ext.direct support for loading form data. + * This example illustrates usage of Ext.Direct to load a form through Ext.Direct. + * +var myFormPanel = new Ext.form.FormPanel({ + // configs for FormPanel + title: 'Basic Information', + renderTo: document.body, + width: 300, height: 160, + padding: 10, - /* - * We need to use createDelegate here, because when using buffer, the delayed task is added - * as a property to the function. When the listener is removed, the task is deleted from the function. - * Since onEditorEvent is shared on the prototype, if we have multiple html editors, the first time one of the editors - * is destroyed, it causes the fn to be deleted from the prototype, which causes errors. Essentially, we're just anonymizing the function. - */ - fn = this.onEditorEvent.createDelegate(this); - Ext.EventManager.on(doc, { - mousedown: fn, - dblclick: fn, - click: fn, - keyup: fn, - buffer:100 - }); + // configs apply to child items + defaults: {anchor: '100%'}, + defaultType: 'textfield', + items: [{ + fieldLabel: 'Name', + name: 'name' + },{ + fieldLabel: 'Email', + name: 'email' + },{ + fieldLabel: 'Company', + name: 'company' + }], - if(Ext.isGecko){ - Ext.EventManager.on(doc, 'keypress', this.applyCommand, this); - } - if(Ext.isIE || Ext.isWebKit || Ext.isOpera){ - Ext.EventManager.on(doc, 'keydown', this.fixKeys, this); - } - doc.editorInitialized = true; - this.initialized = true; - this.pushValue(); - this.setReadOnly(this.readOnly); - this.fireEvent('initialize', this); - }catch(e){} + // configs for BasicForm + api: { + // The server-side method to call for load() requests + load: Profile.getBasicInfo, + // The server-side must mark the submit handler as a 'formHandler' + submit: Profile.updateBasicInfo }, + // specify the order for the passed params + paramOrder: ['uid', 'foo'] +}); - // private - onDestroy : function(){ - if(this.monitorTask){ - Ext.TaskMgr.stop(this.monitorTask); - } - if(this.rendered){ - Ext.destroy(this.tb); - var doc = this.getDoc(); - if(doc){ - try{ - Ext.EventManager.removeAll(doc); - for (var prop in doc){ - delete doc[prop]; - } - }catch(e){} - } - if(this.wrap){ - this.wrap.dom.innerHTML = ''; - this.wrap.remove(); +// load the form +myFormPanel.getForm().load({ + // pass 2 arguments to server side getBasicInfo method (len=2) + params: { + foo: 'bar', + uid: 34 + } +}); + * + * The data packet sent to the server will resemble something like: + * +[ + { + "action":"Profile","method":"getBasicInfo","type":"rpc","tid":2, + "data":[34,"bar"] // note the order of the params + } +] + * + * The form will process a data packet returned by the server that is similar + * to the following format: + * +[ + { + "action":"Profile","method":"getBasicInfo","type":"rpc","tid":2, + "result":{ + "success":true, + "data":{ + "name":"Fred Flintstone", + "company":"Slate Rock and Gravel", + "email":"fred.flintstone@slaterg.com" } } - - if(this.el){ - this.el.removeAllListeners(); - this.el.remove(); - } - this.purgeListeners(); + } +] + * + */ +Ext.form.Action.DirectLoad = Ext.extend(Ext.form.Action.Load, { + constructor: function(form, opts) { + Ext.form.Action.DirectLoad.superclass.constructor.call(this, form, opts); }, + type : 'directload', - // private - onFirstFocus : function(){ - this.activated = true; - this.disableItems(this.readOnly); - if(Ext.isGecko){ // prevent silly gecko errors - this.win.focus(); - var s = this.win.getSelection(); - if(!s.focusNode || s.focusNode.nodeType != 3){ - var r = s.getRangeAt(0); - r.selectNodeContents(this.getEditorBody()); - r.collapse(true); - this.deferFocus(); - } - try{ - this.execCmd('useCSS', true); - this.execCmd('styleWithCSS', false); - }catch(e){} - } - this.fireEvent('activate', this); + run : function(){ + var args = this.getParams(); + args.push(this.success, this); + this.form.api.load.apply(window, args); }, - // private - adjustFont: function(btn){ - var adjust = btn.getItemId() == 'increasefontsize' ? 1 : -1, - doc = this.getDoc(), - v = parseInt(doc.queryCommandValue('FontSize') || 2, 10); - if((Ext.isSafari && !Ext.isSafari2) || Ext.isChrome || Ext.isAir){ - // Safari 3 values - // 1 = 10px, 2 = 13px, 3 = 16px, 4 = 18px, 5 = 24px, 6 = 32px - if(v <= 10){ - v = 1 + adjust; - }else if(v <= 13){ - v = 2 + adjust; - }else if(v <= 16){ - v = 3 + adjust; - }else if(v <= 18){ - v = 4 + adjust; - }else if(v <= 24){ - v = 5 + adjust; - }else { - v = 6 + adjust; - } - v = v.constrain(1, 6); - }else{ - if(Ext.isSafari){ // safari - adjust *= 2; + getParams : function() { + var buf = [], o = {}; + var bp = this.form.baseParams; + var p = this.options.params; + Ext.apply(o, p, bp); + var paramOrder = this.form.paramOrder; + if(paramOrder){ + for(var i = 0, len = paramOrder.length; i < len; i++){ + buf.push(o[paramOrder[i]]); } - v = Math.max(1, v+adjust) + (Ext.isSafari ? 'px' : 0); + }else if(this.form.paramsAsHash){ + buf.push(o); } - this.execCmd('FontSize', v); + return buf; }, - - // private - onEditorEvent : function(e){ - this.updateToolbar(); + // Direct actions have already been processed and therefore + // we can directly set the result; Direct Actions do not have + // a this.response property. + processResponse : function(result) { + this.result = result; + return result; }, - - /** - * Protected method that will not generally be called directly. It triggers - * a toolbar update by reading the markup state of the current selection in the editor. - */ - updateToolbar: function(){ - - if(this.readOnly){ - return; + success : function(response, trans){ + if(trans.type == Ext.Direct.exceptions.SERVER){ + response = {}; } + Ext.form.Action.DirectLoad.superclass.success.call(this, response); + } +}); - if(!this.activated){ - this.onFirstFocus(); - return; +/** + * @class Ext.form.Action.DirectSubmit + * @extends Ext.form.Action.Submit + * Provides Ext.direct support for submitting form data. + * This example illustrates usage of Ext.Direct to submit a form through Ext.Direct. + * +var myFormPanel = new Ext.form.FormPanel({ + // configs for FormPanel + title: 'Basic Information', + renderTo: document.body, + width: 300, height: 160, + padding: 10, + buttons:[{ + text: 'Submit', + handler: function(){ + myFormPanel.getForm().submit({ + params: { + foo: 'bar', + uid: 34 + } + }); } + }], - var btns = this.tb.items.map, - doc = this.getDoc(); + // configs apply to child items + defaults: {anchor: '100%'}, + defaultType: 'textfield', + items: [{ + fieldLabel: 'Name', + name: 'name' + },{ + fieldLabel: 'Email', + name: 'email' + },{ + fieldLabel: 'Company', + name: 'company' + }], - if(this.enableFont && !Ext.isSafari2){ - var name = (doc.queryCommandValue('FontName')||this.defaultFont).toLowerCase(); - if(name != this.fontSelect.dom.value){ - this.fontSelect.dom.value = name; - } - } - if(this.enableFormat){ - btns.bold.toggle(doc.queryCommandState('bold')); - btns.italic.toggle(doc.queryCommandState('italic')); - btns.underline.toggle(doc.queryCommandState('underline')); - } - if(this.enableAlignments){ - btns.justifyleft.toggle(doc.queryCommandState('justifyleft')); - btns.justifycenter.toggle(doc.queryCommandState('justifycenter')); - btns.justifyright.toggle(doc.queryCommandState('justifyright')); + // configs for BasicForm + api: { + // The server-side method to call for load() requests + load: Profile.getBasicInfo, + // The server-side must mark the submit handler as a 'formHandler' + submit: Profile.updateBasicInfo + }, + // specify the order for the passed params + paramOrder: ['uid', 'foo'] +}); + * + * The data packet sent to the server will resemble something like: + * +{ + "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":"6", + "result":{ + "success":true, + "id":{ + "extAction":"Profile","extMethod":"updateBasicInfo", + "extType":"rpc","extTID":"6","extUpload":"false", + "name":"Aaron Conran","email":"aaron@extjs.com","company":"Ext JS, LLC" } - if(!Ext.isSafari2 && this.enableLists){ - btns.insertorderedlist.toggle(doc.queryCommandState('insertorderedlist')); - btns.insertunorderedlist.toggle(doc.queryCommandState('insertunorderedlist')); + } +} + * + * The form will process a data packet returned by the server that is similar + * to the following: + * +// sample success packet (batched requests) +[ + { + "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":3, + "result":{ + "success":true } + } +] - Ext.menu.MenuMgr.hideAll(); - - this.syncValue(); +// sample failure packet (one request) +{ + "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":"6", + "result":{ + "errors":{ + "email":"already taken" + }, + "success":false, + "foo":"bar" + } +} + * + * Also see the discussion in {@link Ext.form.Action.DirectLoad}. + */ +Ext.form.Action.DirectSubmit = Ext.extend(Ext.form.Action.Submit, { + constructor : function(form, opts) { + Ext.form.Action.DirectSubmit.superclass.constructor.call(this, form, opts); }, - - // private - relayBtnCmd : function(btn){ - this.relayCmd(btn.getItemId()); + type : 'directsubmit', + // override of Submit + run : function(){ + var o = this.options; + if(o.clientValidation === false || this.form.isValid()){ + // tag on any additional params to be posted in the + // form scope + this.success.params = this.getParams(); + this.form.api.submit(this.form.el.dom, this.success, this); + }else if (o.clientValidation !== false){ // client validation failed + this.failureType = Ext.form.Action.CLIENT_INVALID; + this.form.afterAction(this, false); + } }, - /** - * Executes a Midas editor command on the editor document and performs necessary focus and - * toolbar updates. This should only be called after the editor is initialized. - * @param {String} cmd The Midas command - * @param {String/Boolean} value (optional) The value to pass to the command (defaults to null) - */ - relayCmd : function(cmd, value){ - (function(){ - this.focus(); - this.execCmd(cmd, value); - this.updateToolbar(); - }).defer(10, this); + getParams : function() { + var o = {}; + var bp = this.form.baseParams; + var p = this.options.params; + Ext.apply(o, p, bp); + return o; }, - - /** - * Executes a Midas editor command directly on the editor document. - * For visual commands, you should use {@link #relayCmd} instead. - * This should only be called after the editor is initialized. - * @param {String} cmd The Midas command - * @param {String/Boolean} value (optional) The value to pass to the command (defaults to null) - */ - execCmd : function(cmd, value){ - var doc = this.getDoc(); - doc.execCommand(cmd, false, value === undefined ? null : value); - this.syncValue(); + // Direct actions have already been processed and therefore + // we can directly set the result; Direct Actions do not have + // a this.response property. + processResponse : function(result) { + this.result = result; + return result; }, - // private - applyCommand : function(e){ - if(e.ctrlKey){ - var c = e.getCharCode(), cmd; - if(c > 0){ - c = String.fromCharCode(c); - switch(c){ - case 'b': - cmd = 'bold'; - break; - case 'i': - cmd = 'italic'; - break; - case 'u': - cmd = 'underline'; - break; - } - if(cmd){ - this.win.focus(); - this.execCmd(cmd); - this.deferFocus(); - e.preventDefault(); - } - } + success : function(response, trans){ + if(trans.type == Ext.Direct.exceptions.SERVER){ + response = {}; } - }, + Ext.form.Action.DirectSubmit.superclass.success.call(this, response); + } +}); - /** - * Inserts the passed text at the current cursor position. Note: the editor must be initialized and activated - * to insert text. - * @param {String} text - */ - insertAtCursor : function(text){ - if(!this.activated){ - return; - } - if(Ext.isIE){ - this.win.focus(); - var doc = this.getDoc(), - r = doc.selection.createRange(); - if(r){ - r.pasteHTML(text); - this.syncValue(); - this.deferFocus(); - } - }else{ - this.win.focus(); - this.execCmd('InsertHTML', text); - this.deferFocus(); - } +Ext.form.Action.ACTION_TYPES = { + 'load' : Ext.form.Action.Load, + 'submit' : Ext.form.Action.Submit, + 'directload' : Ext.form.Action.DirectLoad, + 'directsubmit' : Ext.form.Action.DirectSubmit +}; +/** + * @class Ext.form.VTypes + * This is a singleton object which contains a set of commonly used field validation functions. + * The validations provided are basic and intended to be easily customizable and extended. + * To add custom VTypes specify the {@link Ext.form.TextField#vtype vtype} validation + * test function, and optionally specify any corresponding error text to display and any keystroke + * filtering mask to apply. For example: + * +// custom Vtype for vtype:'time' +var timeTest = /^([1-9]|1[0-9]):([0-5][0-9])(\s[a|p]m)$/i; +Ext.apply(Ext.form.VTypes, { + // vtype validation function + time: function(val, field) { + return timeTest.test(val); }, - - // private - fixKeys : function(){ // load time branching for fastest keydown performance - if(Ext.isIE){ - return function(e){ - var k = e.getKey(), - doc = this.getDoc(), - r; - if(k == e.TAB){ - e.stopEvent(); - r = doc.selection.createRange(); - if(r){ - r.collapse(true); - r.pasteHTML('    '); - this.deferFocus(); - } - }else if(k == e.ENTER){ - r = doc.selection.createRange(); - if(r){ - var target = r.parentElement(); - if(!target || target.tagName.toLowerCase() != 'li'){ - e.stopEvent(); - r.pasteHTML(' '); - r.collapse(false); - r.select(); - } - } - } - }; - }else if(Ext.isOpera){ - return function(e){ - var k = e.getKey(); - if(k == e.TAB){ - e.stopEvent(); - this.win.focus(); - this.execCmd('InsertHTML','    '); - this.deferFocus(); - } - }; - }else if(Ext.isWebKit){ - return function(e){ - var k = e.getKey(); - if(k == e.TAB){ - e.stopEvent(); - this.execCmd('InsertText','\t'); - this.deferFocus(); - }else if(k == e.ENTER){ - e.stopEvent(); - this.execCmd('InsertHtml',' '); - this.deferFocus(); - } - }; - } - }(), - - /** - * Returns the editor's toolbar. This is only available after the editor has been rendered. - * @return {Ext.Toolbar} - */ - getToolbar : function(){ - return this.tb; + // vtype Text property: The error text to display when the validation function returns false + timeText: 'Not a valid time. Must be in the format "12:34 PM".', + // vtype Mask property: The keystroke filter mask + timeMask: /[\d\s:amp]/i +}); + * + * Another example: + * +// custom Vtype for vtype:'IPAddress' +Ext.apply(Ext.form.VTypes, { + IPAddress: function(v) { + return /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(v); }, + IPAddressText: 'Must be a numeric IP address', + IPAddressMask: /[\d\.]/i +}); + * + * @singleton + */ +Ext.form.VTypes = function(){ + // closure these in so they are only created once. + var alpha = /^[a-zA-Z_]+$/, + alphanum = /^[a-zA-Z0-9_]+$/, + email = /^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,6}$/, + url = /(((^https?)|(^ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i; - /** - * Object collection of toolbar tooltips for the buttons in the editor. The key - * is the command id associated with that button and the value is a valid QuickTips object. - * For example: - -{ - bold : { - title: 'Bold (Ctrl+B)', - text: 'Make the selected text bold.', - cls: 'x-html-editor-tip' - }, - italic : { - title: 'Italic (Ctrl+I)', - text: 'Make the selected text italic.', - cls: 'x-html-editor-tip' - }, - ... - - * @type Object - */ - buttonTips : { - bold : { - title: 'Bold (Ctrl+B)', - text: 'Make the selected text bold.', - cls: 'x-html-editor-tip' - }, - italic : { - title: 'Italic (Ctrl+I)', - text: 'Make the selected text italic.', - cls: 'x-html-editor-tip' - }, - underline : { - title: 'Underline (Ctrl+U)', - text: 'Underline the selected text.', - cls: 'x-html-editor-tip' - }, - increasefontsize : { - title: 'Grow Text', - text: 'Increase the font size.', - cls: 'x-html-editor-tip' - }, - decreasefontsize : { - title: 'Shrink Text', - text: 'Decrease the font size.', - cls: 'x-html-editor-tip' - }, - backcolor : { - title: 'Text Highlight Color', - text: 'Change the background color of the selected text.', - cls: 'x-html-editor-tip' - }, - forecolor : { - title: 'Font Color', - text: 'Change the color of the selected text.', - cls: 'x-html-editor-tip' - }, - justifyleft : { - title: 'Align Text Left', - text: 'Align text to the left.', - cls: 'x-html-editor-tip' - }, - justifycenter : { - title: 'Center Text', - text: 'Center text in the editor.', - cls: 'x-html-editor-tip' + // All these messages and functions are configurable + return { + /** + * The function used to validate email addresses. Note that this is a very basic validation -- complete + * validation per the email RFC specifications is very complex and beyond the scope of this class, although + * this function can be overridden if a more comprehensive validation scheme is desired. See the validation + * section of the Wikipedia article on email addresses + * for additional information. This implementation is intended to validate the following emails: + * 'barney@example.de', 'barney.rubble@example.com', 'barney-rubble@example.coop', 'barney+rubble@example.com' + * . + * @param {String} value The email address + * @return {Boolean} true if the RegExp test passed, and false if not. + */ + 'email' : function(v){ + return email.test(v); }, - justifyright : { - title: 'Align Text Right', - text: 'Align text to the right.', - cls: 'x-html-editor-tip' + /** + * The error text to display when the email validation function returns false. Defaults to: + * 'This field should be an e-mail address in the format "user@example.com"' + * @type String + */ + 'emailText' : 'This field should be an e-mail address in the format "user@example.com"', + /** + * The keystroke filter mask to be applied on email input. See the {@link #email} method for + * information about more complex email validation. Defaults to: + * /[a-z0-9_\.\-@]/i + * @type RegExp + */ + 'emailMask' : /[a-z0-9_\.\-@]/i, + + /** + * The function used to validate URLs + * @param {String} value The URL + * @return {Boolean} true if the RegExp test passed, and false if not. + */ + 'url' : function(v){ + return url.test(v); }, - insertunorderedlist : { - title: 'Bullet List', - text: 'Start a bulleted list.', - cls: 'x-html-editor-tip' + /** + * The error text to display when the url validation function returns false. Defaults to: + * 'This field should be a URL in the format "http:/'+'/www.example.com"' + * @type String + */ + 'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"', + + /** + * The function used to validate alpha values + * @param {String} value The value + * @return {Boolean} true if the RegExp test passed, and false if not. + */ + 'alpha' : function(v){ + return alpha.test(v); }, - insertorderedlist : { - title: 'Numbered List', - text: 'Start a numbered list.', - cls: 'x-html-editor-tip' + /** + * The error text to display when the alpha validation function returns false. Defaults to: + * 'This field should only contain letters and _' + * @type String + */ + 'alphaText' : 'This field should only contain letters and _', + /** + * The keystroke filter mask to be applied on alpha input. Defaults to: + * /[a-z_]/i + * @type RegExp + */ + 'alphaMask' : /[a-z_]/i, + + /** + * The function used to validate alphanumeric values + * @param {String} value The value + * @return {Boolean} true if the RegExp test passed, and false if not. + */ + 'alphanum' : function(v){ + return alphanum.test(v); }, - createlink : { - title: 'Hyperlink', - text: 'Make the selected text a hyperlink.', - cls: 'x-html-editor-tip' + /** + * The error text to display when the alphanumeric validation function returns false. Defaults to: + * 'This field should only contain letters, numbers and _' + * @type String + */ + 'alphanumText' : 'This field should only contain letters, numbers and _', + /** + * The keystroke filter mask to be applied on alphanumeric input. Defaults to: + * /[a-z0-9_]/i + * @type RegExp + */ + 'alphanumMask' : /[a-z0-9_]/i + }; +}();/** + * @class Ext.grid.GridPanel + * @extends Ext.Panel + * This class represents the primary interface of a component based grid control to represent data + * in a tabular format of rows and columns. The GridPanel is composed of the following: + * + * {@link Ext.data.Store Store} : The Model holding the data records (rows) + * + * {@link Ext.grid.ColumnModel Column model} : Column makeup + * + * {@link Ext.grid.GridView View} : Encapsulates the user interface + * + * {@link Ext.grid.AbstractSelectionModel selection model} : Selection behavior + * + * + * Example usage: + * +var grid = new Ext.grid.GridPanel({ + {@link #store}: new {@link Ext.data.Store}({ + {@link Ext.data.Store#autoDestroy autoDestroy}: true, + {@link Ext.data.Store#reader reader}: reader, + {@link Ext.data.Store#data data}: xg.dummyData + }), + {@link #colModel}: new {@link Ext.grid.ColumnModel}({ + {@link Ext.grid.ColumnModel#defaults defaults}: { + width: 120, + sortable: true }, - sourceedit : { - title: 'Source Edit', - text: 'Switch to source editing mode.', - cls: 'x-html-editor-tip' - } - } + {@link Ext.grid.ColumnModel#columns columns}: [ + {id: 'company', header: 'Company', width: 200, sortable: true, dataIndex: 'company'}, + {header: 'Price', renderer: Ext.util.Format.usMoney, dataIndex: 'price'}, + {header: 'Change', dataIndex: 'change'}, + {header: '% Change', dataIndex: 'pctChange'}, + // instead of specifying renderer: Ext.util.Format.dateRenderer('m/d/Y') use xtype + { + header: 'Last Updated', width: 135, dataIndex: 'lastChange', + xtype: 'datecolumn', format: 'M d, Y' + } + ], + }), + {@link #viewConfig}: { + {@link Ext.grid.GridView#forceFit forceFit}: true, - // hide stuff that is not compatible - /** - * @event blur - * @hide - */ - /** - * @event change - * @hide - */ - /** - * @event focus - * @hide - */ - /** - * @event specialkey - * @hide - */ - /** - * @cfg {String} fieldClass @hide - */ - /** - * @cfg {String} focusClass @hide - */ - /** - * @cfg {String} autoCreate @hide - */ +// Return CSS class to apply to rows depending upon data values + {@link Ext.grid.GridView#getRowClass getRowClass}: function(record, index) { + var c = record.{@link Ext.data.Record#get get}('change'); + if (c < 0) { + return 'price-fall'; + } else if (c > 0) { + return 'price-rise'; + } + } + }, + {@link #sm}: new Ext.grid.RowSelectionModel({singleSelect:true}), + width: 600, + height: 300, + frame: true, + title: 'Framed with Row Selection and Horizontal Scrolling', + iconCls: 'icon-grid' +}); + * + * Notes: + * + * Although this class inherits many configuration options from base classes, some of them + * (such as autoScroll, autoWidth, layout, items, etc) are not used by this class, and will + * have no effect. + * A grid requires a width in which to scroll its columns, and a height in which to + * scroll its rows. These dimensions can either be set explicitly through the + * {@link Ext.BoxComponent#height height} and {@link Ext.BoxComponent#width width} + * configuration options or implicitly set by using the grid as a child item of a + * {@link Ext.Container Container} which will have a {@link Ext.Container#layout layout manager} + * provide the sizing of its child items (for example the Container of the Grid may specify + * {@link Ext.Container#layout layout}:'fit'). + * To access the data in a Grid, it is necessary to use the data model encapsulated + * by the {@link #store Store}. See the {@link #cellclick} event for more details. + * + * @constructor + * @param {Object} config The config object + * @xtype grid + */ +Ext.grid.GridPanel = Ext.extend(Ext.Panel, { /** - * @cfg {String} inputType @hide + * @cfg {String} autoExpandColumn + * The {@link Ext.grid.Column#id id} of a {@link Ext.grid.Column column} in + * this grid that should expand to fill unused space. This value specified here can not + * be 0. + * Note: If the Grid's {@link Ext.grid.GridView view} is configured with + * {@link Ext.grid.GridView#forceFit forceFit}=true the autoExpandColumn + * is ignored. See {@link Ext.grid.Column}.{@link Ext.grid.Column#width width} + * for additional details. + * See {@link #autoExpandMax} and {@link #autoExpandMin} also. */ + autoExpandColumn : false, /** - * @cfg {String} invalidClass @hide + * @cfg {Number} autoExpandMax The maximum width the {@link #autoExpandColumn} + * can have (if enabled). Defaults to 1000. */ + autoExpandMax : 1000, /** - * @cfg {String} invalidText @hide + * @cfg {Number} autoExpandMin The minimum width the {@link #autoExpandColumn} + * can have (if enabled). Defaults to 50. */ + autoExpandMin : 50, /** - * @cfg {String} msgFx @hide + * @cfg {Boolean} columnLines true to add css for column separation lines. + * Default is false. */ + columnLines : false, /** - * @cfg {String} validateOnBlur @hide + * @cfg {Object} cm Shorthand for {@link #colModel}. */ /** - * @cfg {Boolean} allowDomMove @hide + * @cfg {Object} colModel The {@link Ext.grid.ColumnModel} to use when rendering the grid (required). */ /** - * @cfg {String} applyTo @hide + * @cfg {Array} columns An array of {@link Ext.grid.Column columns} to auto create a + * {@link Ext.grid.ColumnModel}. The ColumnModel may be explicitly created via the + * {@link #colModel} configuration property. */ /** - * @cfg {String} autoHeight @hide + * @cfg {String} ddGroup The DD group this GridPanel belongs to. Defaults to 'GridDD' if not specified. */ /** - * @cfg {String} autoWidth @hide + * @cfg {String} ddText + * Configures the text in the drag proxy. Defaults to: + * + * ddText : '{0} selected row{1}' + * + * {0} is replaced with the number of selected rows. */ + ddText : '{0} selected row{1}', /** - * @cfg {String} cls @hide + * @cfg {Boolean} deferRowRender Defaults to true to enable deferred row rendering. + * This allows the GridPanel to be initially rendered empty, with the expensive update of the row + * structure deferred so that layouts with GridPanels appear more quickly. */ + deferRowRender : true, /** - * @cfg {String} disabled @hide + * @cfg {Boolean} disableSelection true to disable selections in the grid. Defaults to false. + * Ignored if a {@link #selModel SelectionModel} is specified. */ /** - * @cfg {String} disabledClass @hide + * @cfg {Boolean} enableColumnResize false to turn off column resizing for the whole grid. Defaults to true. */ /** - * @cfg {String} msgTarget @hide + * @cfg {Boolean} enableColumnHide + * Defaults to true to enable {@link Ext.grid.Column#hidden hiding of columns} + * with the {@link #enableHdMenu header menu}. */ + enableColumnHide : true, /** - * @cfg {String} readOnly @hide + * @cfg {Boolean} enableColumnMove Defaults to true to enable drag and drop reorder of columns. false + * to turn off column reordering via drag drop. */ + enableColumnMove : true, /** - * @cfg {String} style @hide + * @cfg {Boolean} enableDragDrop Enables dragging of the selected rows of the GridPanel. Defaults to false. + * Setting this to true causes this GridPanel's {@link #getView GridView} to + * create an instance of {@link Ext.grid.GridDragZone}. Note: this is available only after + * the Grid has been rendered as the GridView's {@link Ext.grid.GridView#dragZone dragZone} + * property. + * A cooperating {@link Ext.dd.DropZone DropZone} must be created who's implementations of + * {@link Ext.dd.DropZone#onNodeEnter onNodeEnter}, {@link Ext.dd.DropZone#onNodeOver onNodeOver}, + * {@link Ext.dd.DropZone#onNodeOut onNodeOut} and {@link Ext.dd.DropZone#onNodeDrop onNodeDrop} are able + * to process the {@link Ext.grid.GridDragZone#getDragData data} which is provided. */ + enableDragDrop : false, /** - * @cfg {String} validationDelay @hide + * @cfg {Boolean} enableHdMenu Defaults to true to enable the drop down button for menu in the headers. */ + enableHdMenu : true, /** - * @cfg {String} validationEvent @hide + * @cfg {Boolean} hideHeaders True to hide the grid's header. Defaults to false. */ /** - * @cfg {String} tabIndex @hide + * @cfg {Object} loadMask An {@link Ext.LoadMask} config or true to mask the grid while + * loading. Defaults to false. */ + loadMask : false, /** - * @property disabled - * @hide + * @cfg {Number} maxHeight Sets the maximum height of the grid - ignored if autoHeight is not on. */ /** - * @method applyToMarkup - * @hide + * @cfg {Number} minColumnWidth The minimum width a column can be resized to. Defaults to 25. */ + minColumnWidth : 25, /** - * @method disable - * @hide + * @cfg {Object} sm Shorthand for {@link #selModel}. */ /** - * @method enable - * @hide + * @cfg {Object} selModel Any subclass of {@link Ext.grid.AbstractSelectionModel} that will provide + * the selection model for the grid (defaults to {@link Ext.grid.RowSelectionModel} if not specified). */ /** - * @method validate - * @hide + * @cfg {Ext.data.Store} store The {@link Ext.data.Store} the grid should use as its data source (required). */ /** - * @event valid - * @hide + * @cfg {Boolean} stripeRows true to stripe the rows. Default is false. + * This causes the CSS class x-grid3-row-alt to be added to alternate rows of + * the grid. A default CSS rule is provided which sets a background colour, but you can override this + * with a rule which either overrides the background-color style using the '!important' + * modifier, or which uses a CSS selector of higher specificity. */ + stripeRows : false, /** - * @method setDisabled - * @hide + * @cfg {Boolean} trackMouseOver True to highlight rows when the mouse is over. Default is true + * for GridPanel, but false for EditorGridPanel. */ + trackMouseOver : true, /** - * @cfg keys - * @hide + * @cfg {Array} stateEvents + * An array of events that, when fired, should trigger this component to save its state. + * Defaults to: + * stateEvents: ['columnmove', 'columnresize', 'sortchange', 'groupchange'] + * + * These can be any types of events supported by this component, including browser or + * custom events (e.g., ['click', 'customerchange']). + * See {@link Ext.Component#stateful} for an explanation of saving and restoring + * Component state. */ -}); -Ext.reg('htmleditor', Ext.form.HtmlEditor);/** - * @class Ext.form.TimeField - * @extends Ext.form.ComboBox - * Provides a time input field with a time dropdown and automatic time validation. Example usage: - * -new Ext.form.TimeField({ - minValue: '9:00 AM', - maxValue: '6:00 PM', - increment: 30 -}); - - * @constructor - * Create a new TimeField - * @param {Object} config - * @xtype timefield - */ -Ext.form.TimeField = Ext.extend(Ext.form.ComboBox, { - /** - * @cfg {Date/String} minValue - * The minimum allowed time. Can be either a Javascript date object with a valid time value or a string - * time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to undefined). - */ - minValue : undefined, - /** - * @cfg {Date/String} maxValue - * The maximum allowed time. Can be either a Javascript date object with a valid time value or a string - * time in a valid format -- see {@link #format} and {@link #altFormats} (defaults to undefined). - */ - maxValue : undefined, - /** - * @cfg {String} minText - * The error text to display when the date in the cell is before minValue (defaults to - * 'The time in this field must be equal to or after {0}'). - */ - minText : "The time in this field must be equal to or after {0}", - /** - * @cfg {String} maxText - * The error text to display when the time is after maxValue (defaults to - * 'The time in this field must be equal to or before {0}'). - */ - maxText : "The time in this field must be equal to or before {0}", - /** - * @cfg {String} invalidText - * The error text to display when the time in the field is invalid (defaults to - * '{value} is not a valid time'). - */ - invalidText : "{0} is not a valid time", - /** - * @cfg {String} format - * The default time format string which can be overriden for localization support. The format must be - * valid according to {@link Date#parseDate} (defaults to 'g:i A', e.g., '3:15 PM'). For 24-hour time - * format try 'H:i' instead. - */ - format : "g:i A", - /** - * @cfg {String} altFormats - * Multiple date formats separated by "|" to try when parsing a user input value and it doesn't match the defined - * format (defaults to 'g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H'). - */ - altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H", - /** - * @cfg {Number} increment - * The number of minutes between each time value in the list (defaults to 15). - */ - increment: 15, - - // private override - mode: 'local', - // private override - triggerAction: 'all', - // private override - typeAhead: false, - - // private - This is the date to use when generating time values in the absence of either minValue - // or maxValue. Using the current date causes DST issues on DST boundary dates, so this is an - // arbitrary "safe" date that can be any date aside from DST boundary dates. - initDate: '1/1/2008', - - // private - initComponent : function(){ - if(Ext.isDefined(this.minValue)){ - this.setMinValue(this.minValue, true); - } - if(Ext.isDefined(this.maxValue)){ - this.setMaxValue(this.maxValue, true); - } - if(!this.store){ - this.generateStore(true); - } - Ext.form.TimeField.superclass.initComponent.call(this); - }, - - /** - * Replaces any existing {@link #minValue} with the new time and refreshes the store. - * @param {Date/String} value The minimum time that can be selected - */ - setMinValue: function(value, /* private */ initial){ - this.setLimit(value, true, initial); - return this; - }, - - /** - * Replaces any existing {@link #maxValue} with the new time and refreshes the store. - * @param {Date/String} value The maximum time that can be selected - */ - setMaxValue: function(value, /* private */ initial){ - this.setLimit(value, false, initial); - return this; - }, - - // private - generateStore: function(initial){ - var min = this.minValue || new Date(this.initDate).clearTime(), - max = this.maxValue || new Date(this.initDate).clearTime().add('mi', (24 * 60) - 1), - times = []; - - while(min <= max){ - times.push(min.dateFormat(this.format)); - min = min.add('mi', this.increment); - } - this.bindStore(times, initial); - }, - - // private - setLimit: function(value, isMin, initial){ - var d; - if(Ext.isString(value)){ - d = this.parseDate(value); - }else if(Ext.isDate(value)){ - d = value; - } - if(d){ - var val = new Date(this.initDate).clearTime(); - val.setHours(d.getHours(), d.getMinutes(), isMin ? 0 : 59, 0); - this[isMin ? 'minValue' : 'maxValue'] = val; - if(!initial){ - this.generateStore(); - } - } - }, - - // inherited docs - getValue : function(){ - var v = Ext.form.TimeField.superclass.getValue.call(this); - return this.formatDate(this.parseDate(v)) || ''; - }, - - // inherited docs - setValue : function(value){ - return Ext.form.TimeField.superclass.setValue.call(this, this.formatDate(this.parseDate(value))); - }, - - // private overrides - validateValue : Ext.form.DateField.prototype.validateValue, - parseDate : Ext.form.DateField.prototype.parseDate, - formatDate : Ext.form.DateField.prototype.formatDate, - - // private - beforeBlur : function(){ - var v = this.parseDate(this.getRawValue()); - if(v){ - this.setValue(v.dateFormat(this.format)); - } - Ext.form.TimeField.superclass.beforeBlur.call(this); - } - - /** - * @cfg {Boolean} grow @hide - */ - /** - * @cfg {Number} growMin @hide - */ - /** - * @cfg {Number} growMax @hide - */ - /** - * @hide - * @method autoSize - */ -}); -Ext.reg('timefield', Ext.form.TimeField);/** - * @class Ext.form.Label - * @extends Ext.BoxComponent - * Basic Label field. - * @constructor - * Creates a new Label - * @param {Ext.Element/String/Object} config The configuration options. If an element is passed, it is set as the internal - * element and its id used as the component id. If a string is passed, it is assumed to be the id of an existing element - * and is used as the component id. Otherwise, it is assumed to be a standard config object and is applied to the component. - * @xtype label - */ -Ext.form.Label = Ext.extend(Ext.BoxComponent, { + stateEvents : ['columnmove', 'columnresize', 'sortchange', 'groupchange'], /** - * @cfg {String} text The plain text to display within the label (defaults to ''). If you need to include HTML - * tags within the label's innerHTML, use the {@link #html} config instead. + * @cfg {Object} view The {@link Ext.grid.GridView} used by the grid. This can be set + * before a call to {@link Ext.Component#render render()}. */ + view : null, + /** - * @cfg {String} forId The id of the input element to which this label will be bound via the standard HTML 'for' - * attribute. If not specified, the attribute will not be added to the label. + * @cfg {Array} bubbleEvents + * An array of events that, when fired, should be bubbled to any parent container. + * See {@link Ext.util.Observable#enableBubble}. + * Defaults to []. */ + bubbleEvents: [], + /** - * @cfg {String} html An HTML fragment that will be used as the label's innerHTML (defaults to ''). - * Note that if {@link #text} is specified it will take precedence and this value will be ignored. + * @cfg {Object} viewConfig A config object that will be applied to the grid's UI view. Any of + * the config options available for {@link Ext.grid.GridView} can be specified here. This option + * is ignored if {@link #view} is specified. */ // private - onRender : function(ct, position){ - if(!this.el){ - this.el = document.createElement('label'); - this.el.id = this.getId(); - this.el.innerHTML = this.text ? Ext.util.Format.htmlEncode(this.text) : (this.html || ''); - if(this.forId){ - this.el.setAttribute('for', this.forId); - } + rendered : false, + // private + viewReady : false, + + // private + initComponent : function(){ + Ext.grid.GridPanel.superclass.initComponent.call(this); + + if(this.columnLines){ + this.cls = (this.cls || '') + ' x-grid-with-col-lines'; } - Ext.form.Label.superclass.onRender.call(this, ct, position); - }, + // override any provided value since it isn't valid + // and is causing too many bug reports ;) + this.autoScroll = false; + this.autoWidth = false; - /** - * Updates the label's innerHTML with the specified string. - * @param {String} text The new label text - * @param {Boolean} encode (optional) False to skip HTML-encoding the text when rendering it - * to the label (defaults to true which encodes the value). This might be useful if you want to include - * tags in the label's innerHTML rather than rendering them as string literals per the default logic. - * @return {Label} this - */ - setText : function(t, encode){ - var e = encode === false; - this[!e ? 'text' : 'html'] = t; - delete this[e ? 'text' : 'html']; - if(this.rendered){ - this.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(t) : t; + if(Ext.isArray(this.columns)){ + this.colModel = new Ext.grid.ColumnModel(this.columns); + delete this.columns; } - return this; - } -}); -Ext.reg('label', Ext.form.Label);/** - * @class Ext.form.Action - * The subclasses of this class provide actions to perform upon {@link Ext.form.BasicForm Form}s. - * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when - * the Form needs to perform an action such as submit or load. The Configuration options - * listed for this class are set through the Form's action methods: {@link Ext.form.BasicForm#submit submit}, - * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction} - * The instance of Action which performed the action is passed to the success - * and failure callbacks of the Form's action methods ({@link Ext.form.BasicForm#submit submit}, - * {@link Ext.form.BasicForm#load load} and {@link Ext.form.BasicForm#doAction doAction}), - * and to the {@link Ext.form.BasicForm#actioncomplete actioncomplete} and - * {@link Ext.form.BasicForm#actionfailed actionfailed} event handlers. - */ -Ext.form.Action = function(form, options){ - this.form = form; - this.options = options || {}; -}; + // check and correct shorthanded configs + if(this.ds){ + this.store = this.ds; + delete this.ds; + } + if(this.cm){ + this.colModel = this.cm; + delete this.cm; + } + if(this.sm){ + this.selModel = this.sm; + delete this.sm; + } + this.store = Ext.StoreMgr.lookup(this.store); -/** - * Failure type returned when client side validation of the Form fails - * thus aborting a submit action. Client side validation is performed unless - * {@link #clientValidation} is explicitly set to false. - * @type {String} - * @static - */ -Ext.form.Action.CLIENT_INVALID = 'client'; -/** - * Failure type returned when server side processing fails and the {@link #result}'s - * success property is set to false. - * In the case of a form submission, field-specific error messages may be returned in the - * {@link #result}'s errors property. - * @type {String} - * @static - */ -Ext.form.Action.SERVER_INVALID = 'server'; -/** - * Failure type returned when a communication error happens when attempting - * to send a request to the remote server. The {@link #response} may be examined to - * provide further information. - * @type {String} - * @static - */ -Ext.form.Action.CONNECT_FAILURE = 'connect'; -/** - * Failure type returned when the response's success - * property is set to false, or no field values are returned in the response's - * data property. - * @type {String} - * @static - */ -Ext.form.Action.LOAD_FAILURE = 'load'; + this.addEvents( + // raw events + /** + * @event click + * The raw click event for the entire grid. + * @param {Ext.EventObject} e + */ + 'click', + /** + * @event dblclick + * The raw dblclick event for the entire grid. + * @param {Ext.EventObject} e + */ + 'dblclick', + /** + * @event contextmenu + * The raw contextmenu event for the entire grid. + * @param {Ext.EventObject} e + */ + 'contextmenu', + /** + * @event mousedown + * The raw mousedown event for the entire grid. + * @param {Ext.EventObject} e + */ + 'mousedown', + /** + * @event mouseup + * The raw mouseup event for the entire grid. + * @param {Ext.EventObject} e + */ + 'mouseup', + /** + * @event mouseover + * The raw mouseover event for the entire grid. + * @param {Ext.EventObject} e + */ + 'mouseover', + /** + * @event mouseout + * The raw mouseout event for the entire grid. + * @param {Ext.EventObject} e + */ + 'mouseout', + /** + * @event keypress + * The raw keypress event for the entire grid. + * @param {Ext.EventObject} e + */ + 'keypress', + /** + * @event keydown + * The raw keydown event for the entire grid. + * @param {Ext.EventObject} e + */ + 'keydown', -Ext.form.Action.prototype = { -/** - * @cfg {String} url The URL that the Action is to invoke. - */ -/** - * @cfg {Boolean} reset When set to true, causes the Form to be - * {@link Ext.form.BasicForm.reset reset} on Action success. If specified, this happens - * before the {@link #success} callback is called and before the Form's - * {@link Ext.form.BasicForm.actioncomplete actioncomplete} event fires. - */ -/** - * @cfg {String} method The HTTP method to use to access the requested URL. Defaults to the - * {@link Ext.form.BasicForm}'s method, or if that is not specified, the underlying DOM form's method. - */ -/** - * @cfg {Mixed} params Extra parameter values to pass. These are added to the Form's - * {@link Ext.form.BasicForm#baseParams} and passed to the specified URL along with the Form's - * input fields. - * Parameters are encoded as standard HTTP parameters using {@link Ext#urlEncode}. - */ -/** - * @cfg {Number} timeout The number of seconds to wait for a server response before - * failing with the {@link #failureType} as {@link #Action.CONNECT_FAILURE}. If not specified, - * defaults to the configured {@link Ext.form.BasicForm#timeout timeout} of the - * {@link Ext.form.BasicForm form}. - */ -/** - * @cfg {Function} success The function to call when a valid success return packet is recieved. - * The function is passed the following parameters: - * form : Ext.form.BasicFormThe form that requested the action - * action : Ext.form.ActionThe Action class. The {@link #result} - * property of this object may be examined to perform custom postprocessing. - * - */ -/** - * @cfg {Function} failure The function to call when a failure packet was recieved, or when an - * error ocurred in the Ajax communication. - * The function is passed the following parameters: - * form : Ext.form.BasicFormThe form that requested the action - * action : Ext.form.ActionThe Action class. If an Ajax - * error ocurred, the failure type will be in {@link #failureType}. The {@link #result} - * property of this object may be examined to perform custom postprocessing. - * - */ -/** - * @cfg {Object} scope The scope in which to call the callback functions (The this reference - * for the callback functions). - */ -/** - * @cfg {String} waitMsg The message to be displayed by a call to {@link Ext.MessageBox#wait} - * during the time the action is being processed. - */ -/** - * @cfg {String} waitTitle The title to be displayed by a call to {@link Ext.MessageBox#wait} - * during the time the action is being processed. - */ + // custom events + /** + * @event cellmousedown + * Fires before a cell is clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'cellmousedown', + /** + * @event rowmousedown + * Fires before a row is clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowmousedown', + /** + * @event headermousedown + * Fires before a header is clicked + * @param {Grid} this + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'headermousedown', -/** - * The type of action this Action instance performs. - * Currently only "submit" and "load" are supported. - * @type {String} - */ - type : 'default', -/** - * The type of failure detected will be one of these: {@link #CLIENT_INVALID}, - * {@link #SERVER_INVALID}, {@link #CONNECT_FAILURE}, or {@link #LOAD_FAILURE}. Usage: - * -var fp = new Ext.form.FormPanel({ -... -buttons: [{ - text: 'Save', - formBind: true, - handler: function(){ - if(fp.getForm().isValid()){ - fp.getForm().submit({ - url: 'form-submit.php', - waitMsg: 'Submitting your data...', - success: function(form, action){ - // server responded with success = true - var result = action.{@link #result}; - }, - failure: function(form, action){ - if (action.{@link #failureType} === Ext.form.Action.{@link #CONNECT_FAILURE}) { - Ext.Msg.alert('Error', - 'Status:'+action.{@link #response}.status+': '+ - action.{@link #response}.statusText); - } - if (action.failureType === Ext.form.Action.{@link #SERVER_INVALID}){ - // server responded with success = false - Ext.Msg.alert('Invalid', action.{@link #result}.errormsg); - } - } - }); - } - } -},{ - text: 'Reset', - handler: function(){ - fp.getForm().reset(); - } -}] - * - * @property failureType - * @type {String} - */ - /** - * The XMLHttpRequest object used to perform the action. - * @property response - * @type {Object} - */ - /** - * The decoded response object containing a boolean success property and - * other, action-specific properties. - * @property result - * @type {Object} - */ + /** + * @event groupmousedown + * Fires before a group header is clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. + * @param {Grid} this + * @param {String} groupField + * @param {String} groupValue + * @param {Ext.EventObject} e + */ + 'groupmousedown', - // interface method - run : function(options){ + /** + * @event rowbodymousedown + * Fires before the row body is clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowbodymousedown', - }, + /** + * @event containermousedown + * Fires before the container is clicked. The container consists of any part of the grid body that is not covered by a row. + * @param {Grid} this + * @param {Ext.EventObject} e + */ + 'containermousedown', - // interface method - success : function(response){ + /** + * @event cellclick + * Fires when a cell is clicked. + * The data for the cell is drawn from the {@link Ext.data.Record Record} + * for this row. To access the data in the listener function use the + * following technique: + * +function(grid, rowIndex, columnIndex, e) { + var record = grid.getStore().getAt(rowIndex); // Get the Record + var fieldName = grid.getColumnModel().getDataIndex(columnIndex); // Get field name + var data = record.get(fieldName); +} + + * @param {Grid} this + * @param {Number} rowIndex + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'cellclick', + /** + * @event celldblclick + * Fires when a cell is double clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'celldblclick', + /** + * @event rowclick + * Fires when a row is clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowclick', + /** + * @event rowdblclick + * Fires when a row is double clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowdblclick', + /** + * @event headerclick + * Fires when a header is clicked + * @param {Grid} this + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'headerclick', + /** + * @event headerdblclick + * Fires when a header cell is double clicked + * @param {Grid} this + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'headerdblclick', + /** + * @event groupclick + * Fires when group header is clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. + * @param {Grid} this + * @param {String} groupField + * @param {String} groupValue + * @param {Ext.EventObject} e + */ + 'groupclick', + /** + * @event groupdblclick + * Fires when group header is double clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. + * @param {Grid} this + * @param {String} groupField + * @param {String} groupValue + * @param {Ext.EventObject} e + */ + 'groupdblclick', + /** + * @event containerclick + * Fires when the container is clicked. The container consists of any part of the grid body that is not covered by a row. + * @param {Grid} this + * @param {Ext.EventObject} e + */ + 'containerclick', + /** + * @event containerdblclick + * Fires when the container is double clicked. The container consists of any part of the grid body that is not covered by a row. + * @param {Grid} this + * @param {Ext.EventObject} e + */ + 'containerdblclick', + + /** + * @event rowbodyclick + * Fires when the row body is clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowbodyclick', + /** + * @event rowbodydblclick + * Fires when the row body is double clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowbodydblclick', + /** + * @event rowcontextmenu + * Fires when a row is right clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowcontextmenu', + /** + * @event cellcontextmenu + * Fires when a cell is right clicked + * @param {Grid} this + * @param {Number} rowIndex + * @param {Number} cellIndex + * @param {Ext.EventObject} e + */ + 'cellcontextmenu', + /** + * @event headercontextmenu + * Fires when a header is right clicked + * @param {Grid} this + * @param {Number} columnIndex + * @param {Ext.EventObject} e + */ + 'headercontextmenu', + /** + * @event groupcontextmenu + * Fires when group header is right clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. + * @param {Grid} this + * @param {String} groupField + * @param {String} groupValue + * @param {Ext.EventObject} e + */ + 'groupcontextmenu', + /** + * @event containercontextmenu + * Fires when the container is right clicked. The container consists of any part of the grid body that is not covered by a row. + * @param {Grid} this + * @param {Ext.EventObject} e + */ + 'containercontextmenu', + /** + * @event rowbodycontextmenu + * Fires when the row body is right clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. + * @param {Grid} this + * @param {Number} rowIndex + * @param {Ext.EventObject} e + */ + 'rowbodycontextmenu', + /** + * @event bodyscroll + * Fires when the body element is scrolled + * @param {Number} scrollLeft + * @param {Number} scrollTop + */ + 'bodyscroll', + /** + * @event columnresize + * Fires when the user resizes a column + * @param {Number} columnIndex + * @param {Number} newSize + */ + 'columnresize', + /** + * @event columnmove + * Fires when the user moves a column + * @param {Number} oldIndex + * @param {Number} newIndex + */ + 'columnmove', + /** + * @event sortchange + * Fires when the grid's store sort changes + * @param {Grid} this + * @param {Object} sortInfo An object with the keys field and direction + */ + 'sortchange', + /** + * @event groupchange + * Fires when the grid's grouping changes (only applies for grids with a {@link Ext.grid.GroupingView GroupingView}) + * @param {Grid} this + * @param {String} groupField A string with the grouping field, null if the store is not grouped. + */ + 'groupchange', + /** + * @event reconfigure + * Fires when the grid is reconfigured with a new store and/or column model. + * @param {Grid} this + * @param {Ext.data.Store} store The new store + * @param {Ext.grid.ColumnModel} colModel The new column model + */ + 'reconfigure', + /** + * @event viewready + * Fires when the grid view is available (use this for selecting a default row). + * @param {Grid} this + */ + 'viewready' + ); }, - // interface method - handleResponse : function(response){ + // private + onRender : function(ct, position){ + Ext.grid.GridPanel.superclass.onRender.apply(this, arguments); - }, + var c = this.getGridEl(); - // default connection failure - failure : function(response){ - this.response = response; - this.failureType = Ext.form.Action.CONNECT_FAILURE; - this.form.afterAction(this, false); + this.el.addClass('x-grid-panel'); + + this.mon(c, { + scope: this, + mousedown: this.onMouseDown, + click: this.onClick, + dblclick: this.onDblClick, + contextmenu: this.onContextMenu + }); + + this.relayEvents(c, ['mousedown','mouseup','mouseover','mouseout','keypress', 'keydown']); + + var view = this.getView(); + view.init(this); + view.render(); + this.getSelectionModel().init(this); }, // private - // shared code among all Actions to validate that there was a response - // with either responseText or responseXml - processResponse : function(response){ - this.response = response; - if(!response.responseText && !response.responseXML){ - return true; + initEvents : function(){ + Ext.grid.GridPanel.superclass.initEvents.call(this); + + if(this.loadMask){ + this.loadMask = new Ext.LoadMask(this.bwrap, + Ext.apply({store:this.store}, this.loadMask)); } - this.result = this.handleResponse(response); - return this.result; }, - // utility functions used internally - getUrl : function(appendParams){ - var url = this.options.url || this.form.url || this.form.el.dom.action; - if(appendParams){ - var p = this.getParams(); - if(p){ - url = Ext.urlAppend(url, p); + initStateEvents : function(){ + Ext.grid.GridPanel.superclass.initStateEvents.call(this); + this.mon(this.colModel, 'hiddenchange', this.saveState, this, {delay: 100}); + }, + + applyState : function(state){ + var cm = this.colModel, + cs = state.columns, + store = this.store, + s, + c, + oldIndex; + + if(cs){ + for(var i = 0, len = cs.length; i < len; i++){ + s = cs[i]; + c = cm.getColumnById(s.id); + if(c){ + c.hidden = s.hidden; + c.width = s.width; + oldIndex = cm.getIndexById(s.id); + if(oldIndex != i){ + cm.moveColumn(oldIndex, i); + } + } } } - return url; - }, + if(store){ + s = state.sort; + if(s){ + store[store.remoteSort ? 'setDefaultSort' : 'sort'](s.field, s.direction); + } + s = state.group; + if(store.groupBy){ + if(s){ + store.groupBy(s); + }else{ + store.clearGrouping(); + } + } - // private - getMethod : function(){ - return (this.options.method || this.form.method || this.form.el.dom.method || 'POST').toUpperCase(); + } + var o = Ext.apply({}, state); + delete o.columns; + delete o.sort; + Ext.grid.GridPanel.superclass.applyState.call(this, o); }, - // private - getParams : function(){ - var bp = this.form.baseParams; - var p = this.options.params; - if(p){ - if(typeof p == "object"){ - p = Ext.urlEncode(Ext.applyIf(p, bp)); - }else if(typeof p == 'string' && bp){ - p += '&' + Ext.urlEncode(bp); + getState : function(){ + var o = {columns: []}, + store = this.store, + ss, + gs; + + for(var i = 0, c; (c = this.colModel.config[i]); i++){ + o.columns[i] = { + id: c.id, + width: c.width + }; + if(c.hidden){ + o.columns[i].hidden = true; } - }else if(bp){ - p = Ext.urlEncode(bp); } - return p; + if(store){ + ss = store.getSortState(); + if(ss){ + o.sort = ss; + } + if(store.getGroupState){ + gs = store.getGroupState(); + if(gs){ + o.group = gs; + } + } + } + return o; }, // private - createCallback : function(opts){ - var opts = opts || {}; - return { - success: this.success, - failure: this.failure, - scope: this, - timeout: (opts.timeout*1000) || (this.form.timeout*1000), - upload: this.form.fileUpload ? this.success : undefined - }; - } -}; - -/** - * @class Ext.form.Action.Submit - * @extends Ext.form.Action - * A class which handles submission of data from {@link Ext.form.BasicForm Form}s - * and processes the returned response. - * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when - * {@link Ext.form.BasicForm#submit submit}ting. - * Response Packet Criteria - * A response packet may contain: - * - * success property : Boolean - * The success property is required. - * errors property : Object - * The errors property, - * which is optional, contains error messages for invalid fields. - * - * JSON Packets - * By default, response packets are assumed to be JSON, so a typical response - * packet may look like this: -{ - success: false, - errors: { - clientCode: "Client not found", - portOfLoading: "This field must not be null" - } -} - * Other data may be placed into the response for processing by the {@link Ext.form.BasicForm}'s callback - * or event handler methods. The object decoded from this JSON is available in the - * {@link Ext.form.Action#result result} property. - * Alternatively, if an {@link #errorReader} is specified as an {@link Ext.data.XmlReader XmlReader}: - errorReader: new Ext.data.XmlReader({ - record : 'field', - success: '@success' - }, [ - 'id', 'msg' - ] - ) - - * then the results may be sent back in XML format: -<?xml version="1.0" encoding="UTF-8"?> -<message success="false"> -<errors> - <field> - <id>clientCode</id> - <msg><![CDATA[Code not found. <br /><i>This is a test validation message from the server </i>]]></msg> - </field> - <field> - <id>portOfLoading</id> - <msg><![CDATA[Port not found. <br /><i>This is a test validation message from the server </i>]]></msg> - </field> -</errors> -</message> - - * Other elements may be placed into the response XML for processing by the {@link Ext.form.BasicForm}'s callback - * or event handler methods. The XML document is available in the {@link #errorReader}'s {@link Ext.data.XmlReader#xmlData xmlData} property. - */ -Ext.form.Action.Submit = function(form, options){ - Ext.form.Action.Submit.superclass.constructor.call(this, form, options); -}; + afterRender : function(){ + Ext.grid.GridPanel.superclass.afterRender.call(this); + var v = this.view; + this.on('bodyresize', v.layout, v); + v.layout(); + if(this.deferRowRender){ + if (!this.deferRowRenderTask){ + this.deferRowRenderTask = new Ext.util.DelayedTask(v.afterRender, this.view); + } + this.deferRowRenderTask.delay(10); + }else{ + v.afterRender(); + } + this.viewReady = true; + }, -Ext.extend(Ext.form.Action.Submit, Ext.form.Action, { - /** - * @cfg {Ext.data.DataReader} errorReader Optional. JSON is interpreted with - * no need for an errorReader. - * A Reader which reads a single record from the returned data. The DataReader's - * success property specifies how submission success is determined. The Record's - * data provides the error messages to apply to any invalid form Fields. - */ /** - * @cfg {boolean} clientValidation Determines whether a Form's fields are validated - * in a final call to {@link Ext.form.BasicForm#isValid isValid} prior to submission. - * Pass false in the Form's submit options to prevent this. If not defined, pre-submission field validation - * is performed. + * Reconfigures the grid to use a different Store and Column Model + * and fires the 'reconfigure' event. The View will be bound to the new + * objects and refreshed. + * Be aware that upon reconfiguring a GridPanel, certain existing settings may become + * invalidated. For example the configured {@link #autoExpandColumn} may no longer exist in the + * new ColumnModel. Also, an existing {@link Ext.PagingToolbar PagingToolbar} will still be bound + * to the old Store, and will need rebinding. Any {@link #plugins} might also need reconfiguring + * with the new data. + * @param {Ext.data.Store} store The new {@link Ext.data.Store} object + * @param {Ext.grid.ColumnModel} colModel The new {@link Ext.grid.ColumnModel} object */ - type : 'submit', - - // private - run : function(){ - var o = this.options; - var method = this.getMethod(); - var isGet = method == 'GET'; - if(o.clientValidation === false || this.form.isValid()){ - Ext.Ajax.request(Ext.apply(this.createCallback(o), { - form:this.form.el.dom, - url:this.getUrl(isGet), - method: method, - headers: o.headers, - params:!isGet ? this.getParams() : null, - isUpload: this.form.fileUpload - })); - }else if (o.clientValidation !== false){ // client validation failed - this.failureType = Ext.form.Action.CLIENT_INVALID; - this.form.afterAction(this, false); + reconfigure : function(store, colModel){ + var rendered = this.rendered; + if(rendered){ + if(this.loadMask){ + this.loadMask.destroy(); + this.loadMask = new Ext.LoadMask(this.bwrap, + Ext.apply({}, {store:store}, this.initialConfig.loadMask)); + } + } + if(this.view){ + this.view.initData(store, colModel); } + this.store = store; + this.colModel = colModel; + if(rendered){ + this.view.refresh(true); + } + this.fireEvent('reconfigure', this, store, colModel); }, // private - success : function(response){ - var result = this.processResponse(response); - if(result === true || result.success){ - this.form.afterAction(this, true); - return; + onDestroy : function(){ + if (this.deferRowRenderTask && this.deferRowRenderTask.cancel){ + this.deferRowRenderTask.cancel(); } - if(result.errors){ - this.form.markInvalid(result.errors); + if(this.rendered){ + Ext.destroy(this.view, this.loadMask); + }else if(this.store && this.store.autoDestroy){ + this.store.destroy(); } - this.failureType = Ext.form.Action.SERVER_INVALID; - this.form.afterAction(this, false); + Ext.destroy(this.colModel, this.selModel); + this.store = this.selModel = this.colModel = this.view = this.loadMask = null; + Ext.grid.GridPanel.superclass.onDestroy.call(this); }, // private - handleResponse : function(response){ - if(this.form.errorReader){ - var rs = this.form.errorReader.read(response); - var errors = []; - if(rs.records){ - for(var i = 0, len = rs.records.length; i < len; i++) { - var r = rs.records[i]; - errors[i] = r.data; - } - } - if(errors.length < 1){ - errors = null; - } - return { - success : rs.success, - errors : errors - }; - } - return Ext.decode(response.responseText); - } -}); - - -/** - * @class Ext.form.Action.Load - * @extends Ext.form.Action - * A class which handles loading of data from a server into the Fields of an {@link Ext.form.BasicForm}. - * Instances of this class are only created by a {@link Ext.form.BasicForm Form} when - * {@link Ext.form.BasicForm#load load}ing. - * Response Packet Criteria - * A response packet must contain: - * - * success property : Boolean - * data property : Object - * The data property contains the values of Fields to load. - * The individual value object for each Field is passed to the Field's - * {@link Ext.form.Field#setValue setValue} method. - * - * JSON Packets - * By default, response packets are assumed to be JSON, so for the following form load call: -var myFormPanel = new Ext.form.FormPanel({ - title: 'Client and routing info', - items: [{ - fieldLabel: 'Client', - name: 'clientName' - }, { - fieldLabel: 'Port of loading', - name: 'portOfLoading' - }, { - fieldLabel: 'Port of discharge', - name: 'portOfDischarge' - }] -}); -myFormPanel.{@link Ext.form.FormPanel#getForm getForm}().{@link Ext.form.BasicForm#load load}({ - url: '/getRoutingInfo.php', - params: { - consignmentRef: myConsignmentRef + processEvent : function(name, e){ + this.view.processEvent(name, e); }, - failure: function(form, action) { - Ext.Msg.alert("Load failed", action.result.errorMessage); - } -}); - - * a success response packet may look like this: -{ - success: true, - data: { - clientName: "Fred. Olsen Lines", - portOfLoading: "FXT", - portOfDischarge: "OSL" - } -} - * while a failure response packet may look like this: -{ - success: false, - errorMessage: "Consignment reference not found" -} - * Other data may be placed into the response for processing the {@link Ext.form.BasicForm Form}'s - * callback or event handler methods. The object decoded from this JSON is available in the - * {@link Ext.form.Action#result result} property. - */ -Ext.form.Action.Load = function(form, options){ - Ext.form.Action.Load.superclass.constructor.call(this, form, options); - this.reader = this.form.reader; -}; -Ext.extend(Ext.form.Action.Load, Ext.form.Action, { // private - type : 'load', + onClick : function(e){ + this.processEvent('click', e); + }, // private - run : function(){ - Ext.Ajax.request(Ext.apply( - this.createCallback(this.options), { - method:this.getMethod(), - url:this.getUrl(false), - headers: this.options.headers, - params:this.getParams() - })); + onMouseDown : function(e){ + this.processEvent('mousedown', e); }, // private - success : function(response){ - var result = this.processResponse(response); - if(result === true || !result.success || !result.data){ - this.failureType = Ext.form.Action.LOAD_FAILURE; - this.form.afterAction(this, false); - return; - } - this.form.clearInvalid(); - this.form.setValues(result.data); - this.form.afterAction(this, true); + onContextMenu : function(e, t){ + this.processEvent('contextmenu', e); }, // private - handleResponse : function(response){ - if(this.form.reader){ - var rs = this.form.reader.read(response); - var data = rs.records && rs.records[0] ? rs.records[0].data : null; - return { - success : rs.success, - data : data - }; - } - return Ext.decode(response.responseText); - } -}); - - - -/** - * @class Ext.form.Action.DirectLoad - * @extends Ext.form.Action.Load - * Provides Ext.direct support for loading form data. - * This example illustrates usage of Ext.Direct to load a form through Ext.Direct. - * -var myFormPanel = new Ext.form.FormPanel({ - // configs for FormPanel - title: 'Basic Information', - renderTo: document.body, - width: 300, height: 160, - padding: 10, - - // configs apply to child items - defaults: {anchor: '100%'}, - defaultType: 'textfield', - items: [{ - fieldLabel: 'Name', - name: 'name' - },{ - fieldLabel: 'Email', - name: 'email' - },{ - fieldLabel: 'Company', - name: 'company' - }], - - // configs for BasicForm - api: { - // The server-side method to call for load() requests - load: Profile.getBasicInfo, - // The server-side must mark the submit handler as a 'formHandler' - submit: Profile.updateBasicInfo + onDblClick : function(e){ + this.processEvent('dblclick', e); }, - // specify the order for the passed params - paramOrder: ['uid', 'foo'] -}); -// load the form -myFormPanel.getForm().load({ - // pass 2 arguments to server side getBasicInfo method (len=2) - params: { - foo: 'bar', - uid: 34 - } -}); - * - * The data packet sent to the server will resemble something like: - * -[ - { - "action":"Profile","method":"getBasicInfo","type":"rpc","tid":2, - "data":[34,"bar"] // note the order of the params - } -] - * - * The form will process a data packet returned by the server that is similar - * to the following format: - * -[ - { - "action":"Profile","method":"getBasicInfo","type":"rpc","tid":2, - "result":{ - "success":true, - "data":{ - "name":"Fred Flintstone", - "company":"Slate Rock and Gravel", - "email":"fred.flintstone@slaterg.com" + // private + walkCells : function(row, col, step, fn, scope){ + var cm = this.colModel, + clen = cm.getColumnCount(), + ds = this.store, + rlen = ds.getCount(), + first = true; + + if(step < 0){ + if(col < 0){ + row--; + first = false; + } + while(row >= 0){ + if(!first){ + col = clen-1; + } + first = false; + while(col >= 0){ + if(fn.call(scope || this, row, col, cm) === true){ + return [row, col]; + } + col--; + } + row--; + } + } else { + if(col >= clen){ + row++; + first = false; + } + while(row < rlen){ + if(!first){ + col = 0; + } + first = false; + while(col < clen){ + if(fn.call(scope || this, row, col, cm) === true){ + return [row, col]; + } + col++; + } + row++; } } - } -] - * - */ -Ext.form.Action.DirectLoad = Ext.extend(Ext.form.Action.Load, { - constructor: function(form, opts) { - Ext.form.Action.DirectLoad.superclass.constructor.call(this, form, opts); + return null; }, - type : 'directload', - run : function(){ - var args = this.getParams(); - args.push(this.success, this); - this.form.api.load.apply(window, args); + /** + * Returns the grid's underlying element. + * @return {Element} The element + */ + getGridEl : function(){ + return this.body; }, - getParams : function() { - var buf = [], o = {}; - var bp = this.form.baseParams; - var p = this.options.params; - Ext.apply(o, p, bp); - var paramOrder = this.form.paramOrder; - if(paramOrder){ - for(var i = 0, len = paramOrder.length; i < len; i++){ - buf.push(o[paramOrder[i]]); - } - }else if(this.form.paramsAsHash){ - buf.push(o); - } - return buf; - }, - // Direct actions have already been processed and therefore - // we can directly set the result; Direct Actions do not have - // a this.response property. - processResponse : function(result) { - this.result = result; - return result; - }, - - success : function(response, trans){ - if(trans.type == Ext.Direct.exceptions.SERVER){ - response = {}; - } - Ext.form.Action.DirectLoad.superclass.success.call(this, response); - } -}); + // private for compatibility, overridden by editor grid + stopEditing : Ext.emptyFn, -/** - * @class Ext.form.Action.DirectSubmit - * @extends Ext.form.Action.Submit - * Provides Ext.direct support for submitting form data. - * This example illustrates usage of Ext.Direct to submit a form through Ext.Direct. - * -var myFormPanel = new Ext.form.FormPanel({ - // configs for FormPanel - title: 'Basic Information', - renderTo: document.body, - width: 300, height: 160, - padding: 10, - buttons:[{ - text: 'Submit', - handler: function(){ - myFormPanel.getForm().submit({ - params: { - foo: 'bar', - uid: 34 - } - }); + /** + * Returns the grid's selection model configured by the {@link #selModel} + * configuration option. If no selection model was configured, this will create + * and return a {@link Ext.grid.RowSelectionModel RowSelectionModel}. + * @return {SelectionModel} + */ + getSelectionModel : function(){ + if(!this.selModel){ + this.selModel = new Ext.grid.RowSelectionModel( + this.disableSelection ? {selectRow: Ext.emptyFn} : null); } - }], - - // configs apply to child items - defaults: {anchor: '100%'}, - defaultType: 'textfield', - items: [{ - fieldLabel: 'Name', - name: 'name' - },{ - fieldLabel: 'Email', - name: 'email' - },{ - fieldLabel: 'Company', - name: 'company' - }], - - // configs for BasicForm - api: { - // The server-side method to call for load() requests - load: Profile.getBasicInfo, - // The server-side must mark the submit handler as a 'formHandler' - submit: Profile.updateBasicInfo + return this.selModel; }, - // specify the order for the passed params - paramOrder: ['uid', 'foo'] -}); - * - * The data packet sent to the server will resemble something like: - * -{ - "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":"6", - "result":{ - "success":true, - "id":{ - "extAction":"Profile","extMethod":"updateBasicInfo", - "extType":"rpc","extTID":"6","extUpload":"false", - "name":"Aaron Conran","email":"aaron@extjs.com","company":"Ext JS, LLC" - } - } -} - * - * The form will process a data packet returned by the server that is similar - * to the following: - * -// sample success packet (batched requests) -[ - { - "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":3, - "result":{ - "success":true - } - } -] -// sample failure packet (one request) -{ - "action":"Profile","method":"updateBasicInfo","type":"rpc","tid":"6", - "result":{ - "errors":{ - "email":"already taken" - }, - "success":false, - "foo":"bar" - } -} - * - * Also see the discussion in {@link Ext.form.Action.DirectLoad}. - */ -Ext.form.Action.DirectSubmit = Ext.extend(Ext.form.Action.Submit, { - constructor : function(form, opts) { - Ext.form.Action.DirectSubmit.superclass.constructor.call(this, form, opts); - }, - type : 'directsubmit', - // override of Submit - run : function(){ - var o = this.options; - if(o.clientValidation === false || this.form.isValid()){ - // tag on any additional params to be posted in the - // form scope - this.success.params = this.getParams(); - this.form.api.submit(this.form.el.dom, this.success, this); - }else if (o.clientValidation !== false){ // client validation failed - this.failureType = Ext.form.Action.CLIENT_INVALID; - this.form.afterAction(this, false); - } + /** + * Returns the grid's data store. + * @return {Ext.data.Store} The store + */ + getStore : function(){ + return this.store; }, - getParams : function() { - var o = {}; - var bp = this.form.baseParams; - var p = this.options.params; - Ext.apply(o, p, bp); - return o; - }, - // Direct actions have already been processed and therefore - // we can directly set the result; Direct Actions do not have - // a this.response property. - processResponse : function(result) { - this.result = result; - return result; + /** + * Returns the grid's ColumnModel. + * @return {Ext.grid.ColumnModel} The column model + */ + getColumnModel : function(){ + return this.colModel; }, - - success : function(response, trans){ - if(trans.type == Ext.Direct.exceptions.SERVER){ - response = {}; + + /** + * Returns the grid's GridView object. + * @return {Ext.grid.GridView} The grid view + */ + getView : function(){ + if(!this.view){ + this.view = new Ext.grid.GridView(this.viewConfig); } - Ext.form.Action.DirectSubmit.superclass.success.call(this, response); + return this.view; + }, + /** + * Called to get grid's drag proxy text, by default returns this.ddText. + * @return {String} The text + */ + getDragDropText : function(){ + var count = this.selModel.getCount(); + return String.format(this.ddText, count, count == 1 ? '' : 's'); } -}); -Ext.form.Action.ACTION_TYPES = { - 'load' : Ext.form.Action.Load, - 'submit' : Ext.form.Action.Submit, - 'directload' : Ext.form.Action.DirectLoad, - 'directsubmit' : Ext.form.Action.DirectSubmit -}; -/** - * @class Ext.form.VTypes - * This is a singleton object which contains a set of commonly used field validation functions. - * The validations provided are basic and intended to be easily customizable and extended. - * To add custom VTypes specify the {@link Ext.form.TextField#vtype vtype} validation - * test function, and optionally specify any corresponding error text to display and any keystroke - * filtering mask to apply. For example: - * -// custom Vtype for vtype:'time' -var timeTest = /^([1-9]|1[0-9]):([0-5][0-9])(\s[a|p]m)$/i; -Ext.apply(Ext.form.VTypes, { - // vtype validation function - time: function(val, field) { - return timeTest.test(val); - }, - // vtype Text property: The error text to display when the validation function returns false - timeText: 'Not a valid time. Must be in the format "12:34 PM".', - // vtype Mask property: The keystroke filter mask - timeMask: /[\d\s:amp]/i -}); - * - * Another example: - * -// custom Vtype for vtype:'IPAddress' -Ext.apply(Ext.form.VTypes, { - IPAddress: function(v) { - return /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(v); - }, - IPAddressText: 'Must be a numeric IP address', - IPAddressMask: /[\d\.]/i -}); - * - * @singleton - */ -Ext.form.VTypes = function(){ - // closure these in so they are only created once. - var alpha = /^[a-zA-Z_]+$/, - alphanum = /^[a-zA-Z0-9_]+$/, - email = /^(\w+)([\-+.][\w]+)*@(\w[\-\w]*\.){1,5}([A-Za-z]){2,6}$/, - url = /(((^https?)|(^ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i; + /** + * @cfg {String/Number} activeItem + * @hide + */ + /** + * @cfg {Boolean} autoDestroy + * @hide + */ + /** + * @cfg {Object/String/Function} autoLoad + * @hide + */ + /** + * @cfg {Boolean} autoWidth + * @hide + */ + /** + * @cfg {Boolean/Number} bufferResize + * @hide + */ + /** + * @cfg {String} defaultType + * @hide + */ + /** + * @cfg {Object} defaults + * @hide + */ + /** + * @cfg {Boolean} hideBorders + * @hide + */ + /** + * @cfg {Mixed} items + * @hide + */ + /** + * @cfg {String} layout + * @hide + */ + /** + * @cfg {Object} layoutConfig + * @hide + */ + /** + * @cfg {Boolean} monitorResize + * @hide + */ + /** + * @property items + * @hide + */ + /** + * @method add + * @hide + */ + /** + * @method cascade + * @hide + */ + /** + * @method doLayout + * @hide + */ + /** + * @method find + * @hide + */ + /** + * @method findBy + * @hide + */ + /** + * @method findById + * @hide + */ + /** + * @method findByType + * @hide + */ + /** + * @method getComponent + * @hide + */ + /** + * @method getLayout + * @hide + */ + /** + * @method getUpdater + * @hide + */ + /** + * @method insert + * @hide + */ + /** + * @method load + * @hide + */ + /** + * @method remove + * @hide + */ + /** + * @event add + * @hide + */ + /** + * @event afterlayout + * @hide + */ + /** + * @event beforeadd + * @hide + */ + /** + * @event beforeremove + * @hide + */ + /** + * @event remove + * @hide + */ - // All these messages and functions are configurable - return { - /** - * The function used to validate email addresses. Note that this is a very basic validation -- complete - * validation per the email RFC specifications is very complex and beyond the scope of this class, although - * this function can be overridden if a more comprehensive validation scheme is desired. See the validation - * section of the Wikipedia article on email addresses - * for additional information. This implementation is intended to validate the following emails: - * 'barney@example.de', 'barney.rubble@example.com', 'barney-rubble@example.coop', 'barney+rubble@example.com' - * . - * @param {String} value The email address - * @return {Boolean} true if the RegExp test passed, and false if not. - */ - 'email' : function(v){ - return email.test(v); - }, - /** - * The error text to display when the email validation function returns false. Defaults to: - * 'This field should be an e-mail address in the format "user@example.com"' - * @type String - */ - 'emailText' : 'This field should be an e-mail address in the format "user@example.com"', - /** - * The keystroke filter mask to be applied on email input. See the {@link #email} method for - * information about more complex email validation. Defaults to: - * /[a-z0-9_\.\-@]/i - * @type RegExp - */ - 'emailMask' : /[a-z0-9_\.\-@]/i, - /** - * The function used to validate URLs - * @param {String} value The URL - * @return {Boolean} true if the RegExp test passed, and false if not. - */ - 'url' : function(v){ - return url.test(v); - }, - /** - * The error text to display when the url validation function returns false. Defaults to: - * 'This field should be a URL in the format "http:/'+'/www.example.com"' - * @type String - */ - 'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"', - - /** - * The function used to validate alpha values - * @param {String} value The value - * @return {Boolean} true if the RegExp test passed, and false if not. - */ - 'alpha' : function(v){ - return alpha.test(v); - }, - /** - * The error text to display when the alpha validation function returns false. Defaults to: - * 'This field should only contain letters and _' - * @type String - */ - 'alphaText' : 'This field should only contain letters and _', - /** - * The keystroke filter mask to be applied on alpha input. Defaults to: - * /[a-z_]/i - * @type RegExp - */ - 'alphaMask' : /[a-z_]/i, - /** - * The function used to validate alphanumeric values - * @param {String} value The value - * @return {Boolean} true if the RegExp test passed, and false if not. - */ - 'alphanum' : function(v){ - return alphanum.test(v); - }, - /** - * The error text to display when the alphanumeric validation function returns false. Defaults to: - * 'This field should only contain letters, numbers and _' - * @type String - */ - 'alphanumText' : 'This field should only contain letters, numbers and _', - /** - * The keystroke filter mask to be applied on alphanumeric input. Defaults to: - * /[a-z0-9_]/i - * @type RegExp - */ - 'alphanumMask' : /[a-z0-9_]/i - }; -}();/** - * @class Ext.grid.GridPanel - * @extends Ext.Panel - * This class represents the primary interface of a component based grid control to represent data - * in a tabular format of rows and columns. The GridPanel is composed of the following: - * - * {@link Ext.data.Store Store} : The Model holding the data records (rows) - * - * {@link Ext.grid.ColumnModel Column model} : Column makeup - * - * {@link Ext.grid.GridView View} : Encapsulates the user interface - * - * {@link Ext.grid.AbstractSelectionModel selection model} : Selection behavior - * - * - * Example usage: - * -var grid = new Ext.grid.GridPanel({ - {@link #store}: new {@link Ext.data.Store}({ - {@link Ext.data.Store#autoDestroy autoDestroy}: true, - {@link Ext.data.Store#reader reader}: reader, - {@link Ext.data.Store#data data}: xg.dummyData - }), - {@link #colModel}: new {@link Ext.grid.ColumnModel}({ - {@link Ext.grid.ColumnModel#defaults defaults}: { - width: 120, - sortable: true - }, - {@link Ext.grid.ColumnModel#columns columns}: [ - {id: 'company', header: 'Company', width: 200, sortable: true, dataIndex: 'company'}, - {header: 'Price', renderer: Ext.util.Format.usMoney, dataIndex: 'price'}, - {header: 'Change', dataIndex: 'change'}, - {header: '% Change', dataIndex: 'pctChange'}, - // instead of specifying renderer: Ext.util.Format.dateRenderer('m/d/Y') use xtype - { - header: 'Last Updated', width: 135, dataIndex: 'lastChange', - xtype: 'datecolumn', format: 'M d, Y' - } - ], - }), - {@link #viewConfig}: { - {@link Ext.grid.GridView#forceFit forceFit}: true, - -// Return CSS class to apply to rows depending upon data values - {@link Ext.grid.GridView#getRowClass getRowClass}: function(record, index) { - var c = record.{@link Ext.data.Record#get get}('change'); - if (c < 0) { - return 'price-fall'; - } else if (c > 0) { - return 'price-rise'; - } - } - }, - {@link #sm}: new Ext.grid.RowSelectionModel({singleSelect:true}), - width: 600, - height: 300, - frame: true, - title: 'Framed with Row Selection and Horizontal Scrolling', - iconCls: 'icon-grid' -}); - * - * Notes: - * - * Although this class inherits many configuration options from base classes, some of them - * (such as autoScroll, autoWidth, layout, items, etc) are not used by this class, and will - * have no effect. - * A grid requires a width in which to scroll its columns, and a height in which to - * scroll its rows. These dimensions can either be set explicitly through the - * {@link Ext.BoxComponent#height height} and {@link Ext.BoxComponent#width width} - * configuration options or implicitly set by using the grid as a child item of a - * {@link Ext.Container Container} which will have a {@link Ext.Container#layout layout manager} - * provide the sizing of its child items (for example the Container of the Grid may specify - * {@link Ext.Container#layout layout}:'fit'). - * To access the data in a Grid, it is necessary to use the data model encapsulated - * by the {@link #store Store}. See the {@link #cellclick} event for more details. - * - * @constructor - * @param {Object} config The config object - * @xtype grid - */ -Ext.grid.GridPanel = Ext.extend(Ext.Panel, { - /** - * @cfg {String} autoExpandColumn - * The {@link Ext.grid.Column#id id} of a {@link Ext.grid.Column column} in - * this grid that should expand to fill unused space. This value specified here can not - * be 0. - * Note: If the Grid's {@link Ext.grid.GridView view} is configured with - * {@link Ext.grid.GridView#forceFit forceFit}=true the autoExpandColumn - * is ignored. See {@link Ext.grid.Column}.{@link Ext.grid.Column#width width} - * for additional details. - * See {@link #autoExpandMax} and {@link #autoExpandMin} also. - */ - autoExpandColumn : false, - /** - * @cfg {Number} autoExpandMax The maximum width the {@link #autoExpandColumn} - * can have (if enabled). Defaults to 1000. - */ - autoExpandMax : 1000, - /** - * @cfg {Number} autoExpandMin The minimum width the {@link #autoExpandColumn} - * can have (if enabled). Defaults to 50. - */ - autoExpandMin : 50, - /** - * @cfg {Boolean} columnLines true to add css for column separation lines. - * Default is false. - */ - columnLines : false, - /** - * @cfg {Object} cm Shorthand for {@link #colModel}. - */ - /** - * @cfg {Object} colModel The {@link Ext.grid.ColumnModel} to use when rendering the grid (required). - */ - /** - * @cfg {Array} columns An array of {@link Ext.grid.Column columns} to auto create a - * {@link Ext.grid.ColumnModel}. The ColumnModel may be explicitly created via the - * {@link #colModel} configuration property. - */ - /** - * @cfg {String} ddGroup The DD group this GridPanel belongs to. Defaults to 'GridDD' if not specified. - */ - /** - * @cfg {String} ddText - * Configures the text in the drag proxy. Defaults to: - * - * ddText : '{0} selected row{1}' - * - * {0} is replaced with the number of selected rows. - */ - ddText : '{0} selected row{1}', - /** - * @cfg {Boolean} deferRowRender Defaults to true to enable deferred row rendering. - * This allows the GridPanel to be initially rendered empty, with the expensive update of the row - * structure deferred so that layouts with GridPanels appear more quickly. - */ - deferRowRender : true, - /** - * @cfg {Boolean} disableSelection true to disable selections in the grid. Defaults to false. - * Ignored if a {@link #selModel SelectionModel} is specified. - */ - /** - * @cfg {Boolean} enableColumnResize false to turn off column resizing for the whole grid. Defaults to true. - */ - /** - * @cfg {Boolean} enableColumnHide - * Defaults to true to enable {@link Ext.grid.Column#hidden hiding of columns} - * with the {@link #enableHdMenu header menu}. - */ - enableColumnHide : true, - /** - * @cfg {Boolean} enableColumnMove Defaults to true to enable drag and drop reorder of columns. false - * to turn off column reordering via drag drop. - */ - enableColumnMove : true, - /** - * @cfg {Boolean} enableDragDrop Enables dragging of the selected rows of the GridPanel. Defaults to false. - * Setting this to true causes this GridPanel's {@link #getView GridView} to - * create an instance of {@link Ext.grid.GridDragZone}. Note: this is available only after - * the Grid has been rendered as the GridView's {@link Ext.grid.GridView#dragZone dragZone} - * property. - * A cooperating {@link Ext.dd.DropZone DropZone} must be created who's implementations of - * {@link Ext.dd.DropZone#onNodeEnter onNodeEnter}, {@link Ext.dd.DropZone#onNodeOver onNodeOver}, - * {@link Ext.dd.DropZone#onNodeOut onNodeOut} and {@link Ext.dd.DropZone#onNodeDrop onNodeDrop} are able - * to process the {@link Ext.grid.GridDragZone#getDragData data} which is provided. - */ - enableDragDrop : false, - /** - * @cfg {Boolean} enableHdMenu Defaults to true to enable the drop down button for menu in the headers. - */ - enableHdMenu : true, - /** - * @cfg {Boolean} hideHeaders True to hide the grid's header. Defaults to false. - */ - /** - * @cfg {Object} loadMask An {@link Ext.LoadMask} config or true to mask the grid while - * loading. Defaults to false. - */ - loadMask : false, - /** - * @cfg {Number} maxHeight Sets the maximum height of the grid - ignored if autoHeight is not on. - */ - /** - * @cfg {Number} minColumnWidth The minimum width a column can be resized to. Defaults to 25. - */ - minColumnWidth : 25, - /** - * @cfg {Object} sm Shorthand for {@link #selModel}. - */ - /** - * @cfg {Object} selModel Any subclass of {@link Ext.grid.AbstractSelectionModel} that will provide - * the selection model for the grid (defaults to {@link Ext.grid.RowSelectionModel} if not specified). - */ - /** - * @cfg {Ext.data.Store} store The {@link Ext.data.Store} the grid should use as its data source (required). - */ - /** - * @cfg {Boolean} stripeRows true to stripe the rows. Default is false. - * This causes the CSS class x-grid3-row-alt to be added to alternate rows of - * the grid. A default CSS rule is provided which sets a background colour, but you can override this - * with a rule which either overrides the background-color style using the '!important' - * modifier, or which uses a CSS selector of higher specificity. - */ - stripeRows : false, - /** - * @cfg {Boolean} trackMouseOver True to highlight rows when the mouse is over. Default is true - * for GridPanel, but false for EditorGridPanel. - */ - trackMouseOver : true, - /** - * @cfg {Array} stateEvents - * An array of events that, when fired, should trigger this component to save its state. - * Defaults to: - * stateEvents: ['columnmove', 'columnresize', 'sortchange', 'groupchange'] - * - * These can be any types of events supported by this component, including browser or - * custom events (e.g., ['click', 'customerchange']). - * See {@link Ext.Component#stateful} for an explanation of saving and restoring - * Component state. - */ - stateEvents : ['columnmove', 'columnresize', 'sortchange', 'groupchange'], - /** - * @cfg {Object} view The {@link Ext.grid.GridView} used by the grid. This can be set - * before a call to {@link Ext.Component#render render()}. - */ - view : null, - - /** - * @cfg {Array} bubbleEvents - * An array of events that, when fired, should be bubbled to any parent container. - * See {@link Ext.util.Observable#enableBubble}. - * Defaults to []. - */ - bubbleEvents: [], - - /** - * @cfg {Object} viewConfig A config object that will be applied to the grid's UI view. Any of - * the config options available for {@link Ext.grid.GridView} can be specified here. This option - * is ignored if {@link #view} is specified. - */ - - // private - rendered : false, - // private - viewReady : false, - - // private - initComponent : function(){ - Ext.grid.GridPanel.superclass.initComponent.call(this); - - if(this.columnLines){ - this.cls = (this.cls || '') + ' x-grid-with-col-lines'; - } - // override any provided value since it isn't valid - // and is causing too many bug reports ;) - this.autoScroll = false; - this.autoWidth = false; - - if(Ext.isArray(this.columns)){ - this.colModel = new Ext.grid.ColumnModel(this.columns); - delete this.columns; - } - - // check and correct shorthanded configs - if(this.ds){ - this.store = this.ds; - delete this.ds; - } - if(this.cm){ - this.colModel = this.cm; - delete this.cm; - } - if(this.sm){ - this.selModel = this.sm; - delete this.sm; - } - this.store = Ext.StoreMgr.lookup(this.store); - - this.addEvents( - // raw events - /** - * @event click - * The raw click event for the entire grid. - * @param {Ext.EventObject} e - */ - 'click', - /** - * @event dblclick - * The raw dblclick event for the entire grid. - * @param {Ext.EventObject} e - */ - 'dblclick', - /** - * @event contextmenu - * The raw contextmenu event for the entire grid. - * @param {Ext.EventObject} e - */ - 'contextmenu', - /** - * @event mousedown - * The raw mousedown event for the entire grid. - * @param {Ext.EventObject} e - */ - 'mousedown', - /** - * @event mouseup - * The raw mouseup event for the entire grid. - * @param {Ext.EventObject} e - */ - 'mouseup', - /** - * @event mouseover - * The raw mouseover event for the entire grid. - * @param {Ext.EventObject} e - */ - 'mouseover', - /** - * @event mouseout - * The raw mouseout event for the entire grid. - * @param {Ext.EventObject} e - */ - 'mouseout', - /** - * @event keypress - * The raw keypress event for the entire grid. - * @param {Ext.EventObject} e - */ - 'keypress', - /** - * @event keydown - * The raw keydown event for the entire grid. - * @param {Ext.EventObject} e - */ - 'keydown', - - // custom events - /** - * @event cellmousedown - * Fires before a cell is clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'cellmousedown', - /** - * @event rowmousedown - * Fires before a row is clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowmousedown', - /** - * @event headermousedown - * Fires before a header is clicked - * @param {Grid} this - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'headermousedown', - - /** - * @event groupmousedown - * Fires before a group header is clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. - * @param {Grid} this - * @param {String} groupField - * @param {String} groupValue - * @param {Ext.EventObject} e - */ - 'groupmousedown', - - /** - * @event rowbodymousedown - * Fires before the row body is clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowbodymousedown', - - /** - * @event containermousedown - * Fires before the container is clicked. The container consists of any part of the grid body that is not covered by a row. - * @param {Grid} this - * @param {Ext.EventObject} e - */ - 'containermousedown', - - /** - * @event cellclick - * Fires when a cell is clicked. - * The data for the cell is drawn from the {@link Ext.data.Record Record} - * for this row. To access the data in the listener function use the - * following technique: - * -function(grid, rowIndex, columnIndex, e) { - var record = grid.getStore().getAt(rowIndex); // Get the Record - var fieldName = grid.getColumnModel().getDataIndex(columnIndex); // Get field name - var data = record.get(fieldName); -} - - * @param {Grid} this - * @param {Number} rowIndex - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'cellclick', - /** - * @event celldblclick - * Fires when a cell is double clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'celldblclick', - /** - * @event rowclick - * Fires when a row is clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowclick', - /** - * @event rowdblclick - * Fires when a row is double clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowdblclick', - /** - * @event headerclick - * Fires when a header is clicked - * @param {Grid} this - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'headerclick', - /** - * @event headerdblclick - * Fires when a header cell is double clicked - * @param {Grid} this - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'headerdblclick', - /** - * @event groupclick - * Fires when group header is clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. - * @param {Grid} this - * @param {String} groupField - * @param {String} groupValue - * @param {Ext.EventObject} e - */ - 'groupclick', - /** - * @event groupdblclick - * Fires when group header is double clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. - * @param {Grid} this - * @param {String} groupField - * @param {String} groupValue - * @param {Ext.EventObject} e - */ - 'groupdblclick', - /** - * @event containerclick - * Fires when the container is clicked. The container consists of any part of the grid body that is not covered by a row. - * @param {Grid} this - * @param {Ext.EventObject} e - */ - 'containerclick', - /** - * @event containerdblclick - * Fires when the container is double clicked. The container consists of any part of the grid body that is not covered by a row. - * @param {Grid} this - * @param {Ext.EventObject} e - */ - 'containerdblclick', - - /** - * @event rowbodyclick - * Fires when the row body is clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowbodyclick', - /** - * @event rowbodydblclick - * Fires when the row body is double clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowbodydblclick', - - /** - * @event rowcontextmenu - * Fires when a row is right clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowcontextmenu', - /** - * @event cellcontextmenu - * Fires when a cell is right clicked - * @param {Grid} this - * @param {Number} rowIndex - * @param {Number} cellIndex - * @param {Ext.EventObject} e - */ - 'cellcontextmenu', - /** - * @event headercontextmenu - * Fires when a header is right clicked - * @param {Grid} this - * @param {Number} columnIndex - * @param {Ext.EventObject} e - */ - 'headercontextmenu', - /** - * @event groupcontextmenu - * Fires when group header is right clicked. Only applies for grids with a {@link Ext.grid.GroupingView GroupingView}. - * @param {Grid} this - * @param {String} groupField - * @param {String} groupValue - * @param {Ext.EventObject} e - */ - 'groupcontextmenu', - /** - * @event containercontextmenu - * Fires when the container is right clicked. The container consists of any part of the grid body that is not covered by a row. - * @param {Grid} this - * @param {Ext.EventObject} e - */ - 'containercontextmenu', - /** - * @event rowbodycontextmenu - * Fires when the row body is right clicked. Only applies for grids with {@link Ext.grid.GridView#enableRowBody enableRowBody} configured. - * @param {Grid} this - * @param {Number} rowIndex - * @param {Ext.EventObject} e - */ - 'rowbodycontextmenu', - /** - * @event bodyscroll - * Fires when the body element is scrolled - * @param {Number} scrollLeft - * @param {Number} scrollTop - */ - 'bodyscroll', - /** - * @event columnresize - * Fires when the user resizes a column - * @param {Number} columnIndex - * @param {Number} newSize - */ - 'columnresize', - /** - * @event columnmove - * Fires when the user moves a column - * @param {Number} oldIndex - * @param {Number} newIndex - */ - 'columnmove', - /** - * @event sortchange - * Fires when the grid's store sort changes - * @param {Grid} this - * @param {Object} sortInfo An object with the keys field and direction - */ - 'sortchange', - /** - * @event groupchange - * Fires when the grid's grouping changes (only applies for grids with a {@link Ext.grid.GroupingView GroupingView}) - * @param {Grid} this - * @param {String} groupField A string with the grouping field, null if the store is not grouped. - */ - 'groupchange', - /** - * @event reconfigure - * Fires when the grid is reconfigured with a new store and/or column model. - * @param {Grid} this - * @param {Ext.data.Store} store The new store - * @param {Ext.grid.ColumnModel} colModel The new column model - */ - 'reconfigure', - /** - * @event viewready - * Fires when the grid view is available (use this for selecting a default row). - * @param {Grid} this - */ - 'viewready' - ); - }, - - // private - onRender : function(ct, position){ - Ext.grid.GridPanel.superclass.onRender.apply(this, arguments); - - var c = this.getGridEl(); - - this.el.addClass('x-grid-panel'); - - this.mon(c, { - scope: this, - mousedown: this.onMouseDown, - click: this.onClick, - dblclick: this.onDblClick, - contextmenu: this.onContextMenu - }); - - this.relayEvents(c, ['mousedown','mouseup','mouseover','mouseout','keypress', 'keydown']); - - var view = this.getView(); - view.init(this); - view.render(); - this.getSelectionModel().init(this); - }, - - // private - initEvents : function(){ - Ext.grid.GridPanel.superclass.initEvents.call(this); - - if(this.loadMask){ - this.loadMask = new Ext.LoadMask(this.bwrap, - Ext.apply({store:this.store}, this.loadMask)); - } - }, - - initStateEvents : function(){ - Ext.grid.GridPanel.superclass.initStateEvents.call(this); - this.mon(this.colModel, 'hiddenchange', this.saveState, this, {delay: 100}); - }, - - applyState : function(state){ - var cm = this.colModel, - cs = state.columns, - store = this.store, - s, - c, - oldIndex; - - if(cs){ - for(var i = 0, len = cs.length; i < len; i++){ - s = cs[i]; - c = cm.getColumnById(s.id); - if(c){ - c.hidden = s.hidden; - c.width = s.width; - oldIndex = cm.getIndexById(s.id); - if(oldIndex != i){ - cm.moveColumn(oldIndex, i); - } - } - } - } - if(store){ - s = state.sort; - if(s){ - store[store.remoteSort ? 'setDefaultSort' : 'sort'](s.field, s.direction); - } - s = state.group; - if(store.groupBy){ - if(s){ - store.groupBy(s); - }else{ - store.clearGrouping(); - } - } - - } - var o = Ext.apply({}, state); - delete o.columns; - delete o.sort; - Ext.grid.GridPanel.superclass.applyState.call(this, o); - }, - - getState : function(){ - var o = {columns: []}, - store = this.store, - ss, - gs; - - for(var i = 0, c; (c = this.colModel.config[i]); i++){ - o.columns[i] = { - id: c.id, - width: c.width - }; - if(c.hidden){ - o.columns[i].hidden = true; - } - } - if(store){ - ss = store.getSortState(); - if(ss){ - o.sort = ss; - } - if(store.getGroupState){ - gs = store.getGroupState(); - if(gs){ - o.group = gs; - } - } - } - return o; - }, - - // private - afterRender : function(){ - Ext.grid.GridPanel.superclass.afterRender.call(this); - var v = this.view; - this.on('bodyresize', v.layout, v); - v.layout(); - if(this.deferRowRender){ - v.afterRender.defer(10, this.view); - }else{ - v.afterRender(); - } - this.viewReady = true; - }, - - /** - * Reconfigures the grid to use a different Store and Column Model - * and fires the 'reconfigure' event. The View will be bound to the new - * objects and refreshed. - * Be aware that upon reconfiguring a GridPanel, certain existing settings may become - * invalidated. For example the configured {@link #autoExpandColumn} may no longer exist in the - * new ColumnModel. Also, an existing {@link Ext.PagingToolbar PagingToolbar} will still be bound - * to the old Store, and will need rebinding. Any {@link #plugins} might also need reconfiguring - * with the new data. - * @param {Ext.data.Store} store The new {@link Ext.data.Store} object - * @param {Ext.grid.ColumnModel} colModel The new {@link Ext.grid.ColumnModel} object - */ - reconfigure : function(store, colModel){ - var rendered = this.rendered; - if(rendered){ - if(this.loadMask){ - this.loadMask.destroy(); - this.loadMask = new Ext.LoadMask(this.bwrap, - Ext.apply({}, {store:store}, this.initialConfig.loadMask)); - } - } - if(this.view){ - this.view.initData(store, colModel); - } - this.store = store; - this.colModel = colModel; - if(rendered){ - this.view.refresh(true); - } - this.fireEvent('reconfigure', this, store, colModel); - }, - - // private - onDestroy : function(){ - if(this.rendered){ - Ext.destroy(this.view, this.loadMask); - }else if(this.store && this.store.autoDestroy){ - this.store.destroy(); - } - Ext.destroy(this.colModel, this.selModel); - this.store = this.selModel = this.colModel = this.view = this.loadMask = null; - Ext.grid.GridPanel.superclass.onDestroy.call(this); - }, - - // private - processEvent : function(name, e){ - this.fireEvent(name, e); - var t = e.getTarget(), - v = this.view, - header = v.findHeaderIndex(t); - - if(header !== false){ - this.fireEvent('header' + name, this, header, e); - }else{ - var row = v.findRowIndex(t), - cell, - body; - if(row !== false){ - this.fireEvent('row' + name, this, row, e); - cell = v.findCellIndex(t); - body = v.findRowBody(t); - if(cell !== false){ - this.fireEvent('cell' + name, this, row, cell, e); - } - if(body){ - this.fireEvent('rowbody' + name, this, row, e); - } - }else{ - this.fireEvent('container' + name, this, e); - } - } - this.view.processEvent(name, e); - }, - - // private - onClick : function(e){ - this.processEvent('click', e); - }, - - // private - onMouseDown : function(e){ - this.processEvent('mousedown', e); - }, - - // private - onContextMenu : function(e, t){ - this.processEvent('contextmenu', e); - }, - - // private - onDblClick : function(e){ - this.processEvent('dblclick', e); - }, - - // private - walkCells : function(row, col, step, fn, scope){ - var cm = this.colModel, - clen = cm.getColumnCount(), - ds = this.store, - rlen = ds.getCount(), - first = true; - if(step < 0){ - if(col < 0){ - row--; - first = false; - } - while(row >= 0){ - if(!first){ - col = clen-1; - } - first = false; - while(col >= 0){ - if(fn.call(scope || this, row, col, cm) === true){ - return [row, col]; - } - col--; - } - row--; - } - } else { - if(col >= clen){ - row++; - first = false; - } - while(row < rlen){ - if(!first){ - col = 0; - } - first = false; - while(col < clen){ - if(fn.call(scope || this, row, col, cm) === true){ - return [row, col]; - } - col++; - } - row++; - } - } - return null; - }, - - // private - onResize : function(){ - Ext.grid.GridPanel.superclass.onResize.apply(this, arguments); - if(this.viewReady){ - this.view.layout(); - } - }, - - /** - * Returns the grid's underlying element. - * @return {Element} The element - */ - getGridEl : function(){ - return this.body; - }, - - // private for compatibility, overridden by editor grid - stopEditing : Ext.emptyFn, - - /** - * Returns the grid's selection model configured by the {@link #selModel} - * configuration option. If no selection model was configured, this will create - * and return a {@link Ext.grid.RowSelectionModel RowSelectionModel}. - * @return {SelectionModel} - */ - getSelectionModel : function(){ - if(!this.selModel){ - this.selModel = new Ext.grid.RowSelectionModel( - this.disableSelection ? {selectRow: Ext.emptyFn} : null); - } - return this.selModel; - }, - - /** - * Returns the grid's data store. - * @return {Ext.data.Store} The store - */ - getStore : function(){ - return this.store; - }, - - /** - * Returns the grid's ColumnModel. - * @return {Ext.grid.ColumnModel} The column model - */ - getColumnModel : function(){ - return this.colModel; - }, - - /** - * Returns the grid's GridView object. - * @return {Ext.grid.GridView} The grid view - */ - getView : function(){ - if(!this.view){ - this.view = new Ext.grid.GridView(this.viewConfig); - } - return this.view; - }, - /** - * Called to get grid's drag proxy text, by default returns this.ddText. - * @return {String} The text - */ - getDragDropText : function(){ - var count = this.selModel.getCount(); - return String.format(this.ddText, count, count == 1 ? '' : 's'); - } - - /** - * @cfg {String/Number} activeItem - * @hide - */ - /** - * @cfg {Boolean} autoDestroy - * @hide - */ - /** - * @cfg {Object/String/Function} autoLoad - * @hide - */ - /** - * @cfg {Boolean} autoWidth - * @hide - */ - /** - * @cfg {Boolean/Number} bufferResize - * @hide - */ - /** - * @cfg {String} defaultType - * @hide - */ - /** - * @cfg {Object} defaults - * @hide - */ - /** - * @cfg {Boolean} hideBorders - * @hide - */ - /** - * @cfg {Mixed} items - * @hide - */ - /** - * @cfg {String} layout - * @hide - */ - /** - * @cfg {Object} layoutConfig - * @hide - */ - /** - * @cfg {Boolean} monitorResize - * @hide - */ - /** - * @property items - * @hide - */ - /** - * @method add - * @hide - */ - /** - * @method cascade - * @hide - */ - /** - * @method doLayout - * @hide - */ - /** - * @method find - * @hide - */ - /** - * @method findBy - * @hide - */ - /** - * @method findById - * @hide - */ - /** - * @method findByType - * @hide - */ - /** - * @method getComponent - * @hide - */ - /** - * @method getLayout - * @hide - */ - /** - * @method getUpdater - * @hide - */ - /** - * @method insert - * @hide - */ - /** - * @method load - * @hide - */ - /** - * @method remove - * @hide - */ - /** - * @event add - * @hide - */ - /** - * @event afterlayout - * @hide - */ - /** - * @event beforeadd - * @hide - */ - /** - * @event beforeremove - * @hide - */ - /** - * @event remove - * @hide - */ - - - - /** - * @cfg {String} allowDomMove @hide - */ - /** - * @cfg {String} autoEl @hide - */ - /** - * @cfg {String} applyTo @hide - */ - /** - * @cfg {String} autoScroll @hide - */ - /** - * @cfg {String} bodyBorder @hide - */ - /** - * @cfg {String} bodyStyle @hide - */ - /** - * @cfg {String} contentEl @hide - */ - /** - * @cfg {String} disabledClass @hide - */ - /** - * @cfg {String} elements @hide - */ - /** - * @cfg {String} html @hide - */ - /** - * @cfg {Boolean} preventBodyReset - * @hide - */ - /** - * @property disabled - * @hide - */ - /** - * @method applyToMarkup - * @hide - */ - /** - * @method enable - * @hide - */ - /** - * @method disable - * @hide - */ - /** - * @method setDisabled - * @hide - */ -}); + /** + * @cfg {String} allowDomMove @hide + */ + /** + * @cfg {String} autoEl @hide + */ + /** + * @cfg {String} applyTo @hide + */ + /** + * @cfg {String} autoScroll @hide + */ + /** + * @cfg {String} bodyBorder @hide + */ + /** + * @cfg {String} bodyStyle @hide + */ + /** + * @cfg {String} contentEl @hide + */ + /** + * @cfg {String} disabledClass @hide + */ + /** + * @cfg {String} elements @hide + */ + /** + * @cfg {String} html @hide + */ + /** + * @cfg {Boolean} preventBodyReset + * @hide + */ + /** + * @property disabled + * @hide + */ + /** + * @method applyToMarkup + * @hide + */ + /** + * @method enable + * @hide + */ + /** + * @method disable + * @hide + */ + /** + * @method setDisabled + * @hide + */ +}); Ext.reg('grid', Ext.grid.GridPanel);/** * @class Ext.grid.GridView * @extends Ext.util.Observable @@ -64955,7 +67778,7 @@ viewConfig: { } return 'x-grid3-row-collapsed'; } -}, +},* @param {Record} record The {@link Ext.data.Record} corresponding to the current row. * @param {Number} index The row index. @@ -64976,10 +67799,12 @@ viewConfig: { * @method getRowClass * @return {String} a CSS class name to add to the row. */ + /** * @cfg {Boolean} enableRowBody True to add a second TR element per row that can be used to provide a row body * that spans beneath the data row. Use the {@link #getRowClass} method's rowParams config to customize the row body. */ + /** * @cfg {String} emptyText Default text (html tags are accepted) to display in the grid body when no rows * are available (defaults to ''). This value will be used to update the {@link #mainBody}: @@ -64987,8 +67812,9 @@ viewConfig: { this.mainBody.update('<div class="x-grid-empty">' + this.emptyText + '</div>'); */ + /** - * @cfg {Boolean} headersDisabled True to disable the grid column headers (defaults to false). + * @cfg {Boolean} headersDisabled True to disable the grid column headers (defaults to false). * Use the {@link Ext.grid.ColumnModel ColumnModel} {@link Ext.grid.ColumnModel#menuDisabled menuDisabled} * config to disable the menu for individual columns. While this config is true the * following will be disabled: @@ -64996,6 +67822,7 @@ viewConfig: { * the trigger to reveal the menu. * */ + /** *
A customized implementation of a {@link Ext.dd.DragZone DragZone} which provides default implementations * of the template methods of DragZone to enable dragging of the selected rows of a GridPanel. @@ -65007,27 +67834,31 @@ viewConfig: { * @property dragZone * @type {Ext.grid.GridDragZone} */ + /** * @cfg {Boolean} deferEmptyText True to defer {@link #emptyText} being applied until the store's * first load (defaults to true). */ deferEmptyText : true, + /** * @cfg {Number} scrollOffset The amount of space to reserve for the vertical scrollbar * (defaults to undefined). If an explicit value isn't specified, this will be automatically * calculated. */ scrollOffset : undefined, + /** * @cfg {Boolean} autoFill * Defaults to false. Specify true to have the column widths re-proportioned - * when the grid is initially rendered. The + * when the grid is initially rendered. The * {@link Ext.grid.Column#width initially configured width} of each column will be adjusted * to fit the grid width and prevent horizontal scrolling. If columns are later resized (manually * or programmatically), the other columns in the grid will not be resized to fit the grid width. * See {@link #forceFit} also. */ autoFill : false, + /** * @cfg {Boolean} forceFit * Defaults to false. Specify true to have the column widths re-proportioned @@ -65037,18 +67868,22 @@ viewConfig: { * to fit the grid width. See {@link #autoFill} also. */ forceFit : false, + /** * @cfg {Array} sortClasses The CSS classes applied to a header when it is sorted. (defaults to ['sort-asc', 'sort-desc']) */ sortClasses : ['sort-asc', 'sort-desc'], + /** * @cfg {String} sortAscText The text displayed in the 'Sort Ascending' menu item (defaults to 'Sort Ascending') */ sortAscText : 'Sort Ascending', + /** * @cfg {String} sortDescText The text displayed in the 'Sort Descending' menu item (defaults to 'Sort Descending') */ sortDescText : 'Sort Descending', + /** * @cfg {String} columnsText The text displayed in the 'Columns' menu item (defaults to 'Columns') */ @@ -65085,7 +67920,7 @@ viewConfig: { * @cfg {Number} rowSelectorDepth The number of levels to search for rows in event delegation (defaults to 10) */ rowSelectorDepth : 10, - + /** * @cfg {Number} rowBodySelectorDepth The number of levels to search for row bodies in event delegation (defaults to 10) */ @@ -65099,75 +67934,75 @@ viewConfig: { * @cfg {String} rowSelector The selector used to find rows internally (defaults to 'div.x-grid3-row') */ rowSelector : 'div.x-grid3-row', - + /** * @cfg {String} rowBodySelector The selector used to find row bodies internally (defaults to 'div.x-grid3-row') */ rowBodySelector : 'div.x-grid3-row-body', - + // private firstRowCls: 'x-grid3-row-first', lastRowCls: 'x-grid3-row-last', rowClsRe: /(?:^|\s+)x-grid3-row-(first|last|alt)(?:\s+|$)/g, - + constructor : function(config){ Ext.apply(this, config); - // These events are only used internally by the grid components - this.addEvents( - /** - * @event beforerowremoved - * Internal UI Event. Fired before a row is removed. - * @param {Ext.grid.GridView} view - * @param {Number} rowIndex The index of the row to be removed. - * @param {Ext.data.Record} record The Record to be removed - */ - 'beforerowremoved', - /** - * @event beforerowsinserted - * Internal UI Event. Fired before rows are inserted. - * @param {Ext.grid.GridView} view - * @param {Number} firstRow The index of the first row to be inserted. - * @param {Number} lastRow The index of the last row to be inserted. - */ - 'beforerowsinserted', - /** - * @event beforerefresh - * Internal UI Event. Fired before the view is refreshed. - * @param {Ext.grid.GridView} view - */ - 'beforerefresh', - /** - * @event rowremoved - * Internal UI Event. Fired after a row is removed. - * @param {Ext.grid.GridView} view - * @param {Number} rowIndex The index of the row that was removed. - * @param {Ext.data.Record} record The Record that was removed - */ - 'rowremoved', - /** - * @event rowsinserted - * Internal UI Event. Fired after rows are inserted. - * @param {Ext.grid.GridView} view - * @param {Number} firstRow The index of the first inserted. - * @param {Number} lastRow The index of the last row inserted. - */ - 'rowsinserted', - /** - * @event rowupdated - * Internal UI Event. Fired after a row has been updated. - * @param {Ext.grid.GridView} view - * @param {Number} firstRow The index of the row updated. - * @param {Ext.data.record} record The Record backing the row updated. - */ - 'rowupdated', - /** - * @event refresh - * Internal UI Event. Fired after the GridView's body has been refreshed. - * @param {Ext.grid.GridView} view - */ - 'refresh' - ); - Ext.grid.GridView.superclass.constructor.call(this); + // These events are only used internally by the grid components + this.addEvents( + /** + * @event beforerowremoved + * Internal UI Event. Fired before a row is removed. + * @param {Ext.grid.GridView} view + * @param {Number} rowIndex The index of the row to be removed. + * @param {Ext.data.Record} record The Record to be removed + */ + 'beforerowremoved', + /** + * @event beforerowsinserted + * Internal UI Event. Fired before rows are inserted. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the first row to be inserted. + * @param {Number} lastRow The index of the last row to be inserted. + */ + 'beforerowsinserted', + /** + * @event beforerefresh + * Internal UI Event. Fired before the view is refreshed. + * @param {Ext.grid.GridView} view + */ + 'beforerefresh', + /** + * @event rowremoved + * Internal UI Event. Fired after a row is removed. + * @param {Ext.grid.GridView} view + * @param {Number} rowIndex The index of the row that was removed. + * @param {Ext.data.Record} record The Record that was removed + */ + 'rowremoved', + /** + * @event rowsinserted + * Internal UI Event. Fired after rows are inserted. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the first inserted. + * @param {Number} lastRow The index of the last row inserted. + */ + 'rowsinserted', + /** + * @event rowupdated + * Internal UI Event. Fired after a row has been updated. + * @param {Ext.grid.GridView} view + * @param {Number} firstRow The index of the row updated. + * @param {Ext.data.record} record The Record backing the row updated. + */ + 'rowupdated', + /** + * @event refresh + * Internal UI Event. Fired after the GridView's body has been refreshed. + * @param {Ext.grid.GridView} view + */ + 'refresh' + ); + Ext.grid.GridView.superclass.constructor.call(this); }, /* -------------------------------- UI Specific ----------------------------- */ @@ -65177,31 +68012,31 @@ viewConfig: { var ts = this.templates || {}; if(!ts.master){ ts.master = new Ext.Template( - '
', - '
', - '
{header}
', - '
{body}
', - '
', - '

', - '

', - '
' - ); + '
', + '
', + '
{header}
', + '
{body}
', + '
', + '

', + '

', + '
' + ); } if(!ts.header){ ts.header = new Ext.Template( - '', - '{cells}', - '
' - ); + '', + '{cells}', + '
' + ); } if(!ts.hcell){ ts.hcell = new Ext.Template( - '
', this.grid.enableHdMenu ? '' : '', - '{value}', - '
' - ); + '
', this.grid.enableHdMenu ? '' : '', + '{value}', + '
' + ); } if(!ts.body){ @@ -65210,11 +68045,11 @@ viewConfig: { if(!ts.row){ ts.row = new Ext.Template( - '
', - '{cells}', - (this.enableRowBody ? '' : ''), - '
{body}
' - ); + '
', + '{cells}', + (this.enableRowBody ? '' : ''), + '
{body}
' + ); } if(!ts.cell){ @@ -65360,7 +68195,7 @@ viewConfig: { var r = this.findRow(el); return r ? r.rowIndex : false; }, - + /** * Return the HtmlElement representing the grid row body which contains the passed element. * @param {HTMLElement} el The target HTMLElement @@ -65400,7 +68235,7 @@ viewConfig: { * @return {HtmlElement} The td element. */ getHeaderCell : function(index){ - return this.mainHd.dom.getElementsByTagName('td')[index]; + return this.mainHd.dom.getElementsByTagName('td')[index]; }, // manipulating elements @@ -65426,7 +68261,7 @@ viewConfig: { Ext.removeNode(this.getRow(row)); this.syncFocusEl(row); }, - + // private removeRows : function(firstRow, lastRow){ var bd = this.mainBody.dom; @@ -65461,8 +68296,8 @@ viewConfig: { // private syncScroll : function(){ - this.syncHeaderScroll(); - var mb = this.scroller.dom; + this.syncHeaderScroll(); + var mb = this.scroller.dom; this.grid.fireEvent('bodyscroll', mb.scrollLeft, mb.scrollTop); }, @@ -65482,17 +68317,20 @@ viewConfig: { // private updateAllColumnWidths : function(){ - var tw = this.getTotalWidth(), + var tw = this.getTotalWidth(), clen = this.cm.getColumnCount(), - ws = [], + ws = [], len, i; + for(i = 0; i < clen; i++){ ws[i] = this.getColumnWidth(i); } + this.innerHd.firstChild.style.width = this.getOffsetWidth(); this.innerHd.firstChild.firstChild.style.width = tw; this.mainBody.dom.style.width = tw; + for(i = 0; i < clen; i++){ var hd = this.getHeaderCell(i); hd.style.width = ws[i]; @@ -65563,75 +68401,120 @@ viewConfig: { this.layout(); }, - // private - doRender : function(cs, rs, ds, startRow, colCount, stripe){ - var ts = this.templates, ct = ts.cell, rt = ts.row, last = colCount-1; - var tstyle = 'width:'+this.getTotalWidth()+';'; + /** + * @private + * Renders all of the rows to a string buffer and returns the string. This is called internally + * by renderRows and performs the actual string building for the rows - it does not inject HTML into the DOM. + * @param {Array} columns The column data acquired from getColumnData. + * @param {Array} records The array of records to render + * @param {Ext.data.Store} store The store to render the rows from + * @param {Number} startRow The index of the first row being rendered. Sometimes we only render a subset of + * the rows so this is used to maintain logic for striping etc + * @param {Number} colCount The total number of columns in the column model + * @param {Boolean} stripe True to stripe the rows + * @return {String} A string containing the HTML for the rendered rows + */ + doRender : function(columns, records, store, startRow, colCount, stripe) { + var templates = this.templates, + cellTemplate = templates.cell, + rowTemplate = templates.row, + last = colCount - 1; + + var tstyle = 'width:' + this.getTotalWidth() + ';'; + // buffers - var buf = [], cb, c, p = {}, rp = {tstyle: tstyle}, r; - for(var j = 0, len = rs.length; j < len; j++){ - r = rs[j]; cb = []; - var rowIndex = (j+startRow); - for(var i = 0; i < colCount; i++){ - c = cs[i]; - p.id = c.id; - p.css = i === 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : ''); - p.attr = p.cellAttr = ''; - p.value = c.renderer.call(c.scope, r.data[c.name], p, r, rowIndex, i, ds); - p.style = c.style; - if(Ext.isEmpty(p.value)){ - p.value = ' '; + var rowBuffer = [], + colBuffer = [], + rowParams = {tstyle: tstyle}, + meta = {}, + column, + record; + + //build up each row's HTML + for (var j = 0, len = records.length; j < len; j++) { + record = records[j]; + colBuffer = []; + + var rowIndex = j + startRow; + + //build up each column's HTML + for (var i = 0; i < colCount; i++) { + column = columns[i]; + + meta.id = column.id; + meta.css = i === 0 ? 'x-grid3-cell-first ' : (i == last ? 'x-grid3-cell-last ' : ''); + meta.attr = meta.cellAttr = ''; + meta.style = column.style; + meta.value = column.renderer.call(column.scope, record.data[column.name], meta, record, rowIndex, i, store); + + if (Ext.isEmpty(meta.value)) { + meta.value = ' '; } - if(this.markDirty && r.dirty && Ext.isDefined(r.modified[c.name])){ - p.css += ' x-grid3-dirty-cell'; + + if (this.markDirty && record.dirty && Ext.isDefined(record.modified[column.name])) { + meta.css += ' x-grid3-dirty-cell'; } - cb[cb.length] = ct.apply(p); + + colBuffer[colBuffer.length] = cellTemplate.apply(meta); } + + //set up row striping and row dirtiness CSS classes var alt = []; - if(stripe && ((rowIndex+1) % 2 === 0)){ + + if (stripe && ((rowIndex + 1) % 2 === 0)) { alt[0] = 'x-grid3-row-alt'; } - if(r.dirty){ + + if (record.dirty) { alt[1] = ' x-grid3-dirty-row'; } - rp.cols = colCount; - if(this.getRowClass){ - alt[2] = this.getRowClass(r, rowIndex, rp, ds); + + rowParams.cols = colCount; + + if (this.getRowClass) { + alt[2] = this.getRowClass(record, rowIndex, rowParams, store); } - rp.alt = alt.join(' '); - rp.cells = cb.join(''); - buf[buf.length] = rt.apply(rp); + + rowParams.alt = alt.join(' '); + rowParams.cells = colBuffer.join(''); + + rowBuffer[rowBuffer.length] = rowTemplate.apply(rowParams); } - return buf.join(''); + + return rowBuffer.join(''); }, // private - processRows : function(startRow, skipStripe){ - if(!this.ds || this.ds.getCount() < 1){ + processRows : function(startRow, skipStripe) { + if (!this.ds || this.ds.getCount() < 1) { return; } + var rows = this.getRows(), - len = rows.length, + len = rows.length, i, r; - + skipStripe = skipStripe || !this.grid.stripeRows; - startRow = startRow || 0; - for(i = 0; i= last){ - this.fireEvent('beforerowsinserted', this, firstRow, lastRow); - this.refresh(); - this.fireEvent('rowsinserted', this, firstRow, lastRow); - }else{ - if(!isUpdate){ + if( !isUpdate && firstRow === 0 && lastRow >= last) { + this.fireEvent('beforerowsinserted', this, firstRow, lastRow); + this.refresh(); + this.fireEvent('rowsinserted', this, firstRow, lastRow); + } else { + if (!isUpdate) { this.fireEvent('beforerowsinserted', this, firstRow, lastRow); } var html = this.renderRows(firstRow, lastRow), before = this.getRow(firstRow); - if(before){ + if (before) { if(firstRow === 0){ Ext.fly(this.getRow(0)).removeClass(this.firstRowCls); } Ext.DomHelper.insertHtml('beforeBegin', before, html); - }else{ + } else { var r = this.getRow(last - 1); if(r){ Ext.fly(r).removeClass(this.lastRowCls); } Ext.DomHelper.insertHtml('beforeEnd', this.mainBody.dom, html); } - if(!isUpdate){ + if (!isUpdate) { this.fireEvent('rowsinserted', this, firstRow, lastRow); this.processRows(firstRow); - }else if(firstRow === 0 || firstRow >= last){ + } else if (firstRow === 0 || firstRow >= last) { //ensure first/last row is kept after an update. Ext.fly(this.getRow(firstRow)).addClass(firstRow === 0 ? this.firstRowCls : this.lastRowCls); } @@ -66141,20 +69065,29 @@ viewConfig: { } }, - // private + /** + * @private + * Returns an array of column configurations - one for each column + * @return {Array} Array of column config objects. This includes the column name, renderer, id style and renderer + */ getColumnData : function(){ // build a map for all the columns - var cs = [], cm = this.cm, colCount = cm.getColumnCount(); - for(var i = 0; i < colCount; i++){ + var cs = [], + cm = this.cm, + colCount = cm.getColumnCount(); + + for (var i = 0; i < colCount; i++) { var name = cm.getDataIndex(i); + cs[i] = { - name : (!Ext.isDefined(name) ? this.ds.fields.get(i).name : name), - renderer : cm.getRenderer(i), - scope: cm.getRendererScope(i), - id : cm.getColumnId(i), - style : this.getColumnStyle(i) + name : (!Ext.isDefined(name) ? this.ds.fields.get(i).name : name), + renderer: cm.getRenderer(i), + scope : cm.getRendererScope(i), + id : cm.getColumnId(i), + style : this.getColumnStyle(i) }; } + return cs; }, @@ -66226,33 +69159,46 @@ viewConfig: { this.fireEvent('refresh', this); }, - // private + /** + * @private + * Displays the configured emptyText if there are currently no rows to display + */ applyEmptyText : function(){ if(this.emptyText && !this.hasRows()){ this.mainBody.update('
' + this.emptyText + '
'); } }, - // private + /** + * @private + * Adds sorting classes to the column headers based on the bound store's sortInfo. Fires the 'sortchange' event + * if the sorting has changed since this function was last run. + */ updateHeaderSortState : function(){ var state = this.ds.getSortState(); - if(!state){ + if (!state) { return; } - if(!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)){ + + if (!this.sortState || (this.sortState.field != state.field || this.sortState.direction != state.direction)) { this.grid.fireEvent('sortchange', this.grid, state); } + this.sortState = state; + var sortColumn = this.cm.findColumnIndex(state.field); - if(sortColumn != -1){ + if (sortColumn != -1){ var sortDir = state.direction; this.updateSortIcon(sortColumn, sortDir); } }, - // private + /** + * @private + * Removes any sorting indicator classes from the column headers + */ clearHeaderSortState : function(){ - if(!this.sortState){ + if (!this.sortState) { return; } this.grid.fireEvent('sortchange', this.grid, null); @@ -66262,6 +69208,9 @@ viewConfig: { // private destroy : function(){ + if (this.scrollToTopTask && this.scrollToTopTask.cancel){ + this.scrollToTopTask.cancel(); + } if(this.colMenu){ Ext.menu.MenuMgr.unregister(this.colMenu); this.colMenu.destroy(); @@ -66353,12 +69302,12 @@ viewConfig: { if(this.autoFill){ var ct = this.grid.ownerCt; if (ct && ct.getLayout()){ - ct.on('afterlayout', function(){ + ct.on('afterlayout', function(){ this.fitColumns(true, true); - this.updateHeaders(); - }, this, {single: true}); - }else{ - this.fitColumns(true, true); + this.updateHeaders(); + }, this, {single: true}); + }else{ + this.fitColumns(true, true); } }else if(this.forceFit){ this.fitColumns(true, false); @@ -66437,7 +69386,6 @@ viewConfig: { // private onAdd : function(ds, records, index){ - this.insertRows(ds, index, index + (records.length-1)); }, @@ -66456,7 +69404,14 @@ viewConfig: { // private onLoad : function(){ - this.scrollToTop.defer(Ext.isGecko ? 1 : 0, this); + if (Ext.isGecko){ + if (!this.scrollToTopTask) { + this.scrollToTopTask = new Ext.util.DelayedTask(this.scrollToTop, this); + } + this.scrollToTopTask.delay(1); + }else{ + this.scrollToTop(); + } }, // private @@ -66577,7 +69532,7 @@ viewConfig: { // private handleHdMenuClick : function(item){ var index = this.hdCtxIndex, - cm = this.cm, + cm = this.cm, ds = this.ds, id = item.getItemId(); switch(id){ @@ -66602,7 +69557,7 @@ viewConfig: { // private isHideableColumn : function(c){ - return !c.hidden && !c.fixed; + return !c.hidden; }, // private @@ -66610,7 +69565,7 @@ viewConfig: { var cm = this.cm, colCount = cm.getColumnCount(); this.colMenu.removeAll(); for(var i = 0; i < colCount; i++){ - if(cm.config[i].fixed !== true && cm.config[i].hideable !== false){ + if(cm.config[i].hideable !== false){ this.colMenu.add(new Ext.menu.CheckItem({ itemId: 'col-'+cm.getColumnId(i), text: cm.getColumnHeader(i), @@ -66703,29 +69658,31 @@ viewConfig: { // private // This is a support class used internally by the Grid components -Ext.grid.GridView.SplitDragZone = function(grid, hd){ - this.grid = grid; - this.view = grid.getView(); - this.marker = this.view.resizeMarker; - this.proxy = this.view.resizeProxy; - Ext.grid.GridView.SplitDragZone.superclass.constructor.call(this, hd, - 'gridSplitters' + this.grid.getGridEl().id, { - dragElId : Ext.id(this.proxy.dom), resizeFrame:false - }); - this.scroll = false; - this.hw = this.view.splitHandleWidth || 5; -}; -Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, { +Ext.grid.GridView.SplitDragZone = Ext.extend(Ext.dd.DDProxy, { + + constructor: function(grid, hd){ + this.grid = grid; + this.view = grid.getView(); + this.marker = this.view.resizeMarker; + this.proxy = this.view.resizeProxy; + Ext.grid.GridView.SplitDragZone.superclass.constructor.call(this, hd, + 'gridSplitters' + this.grid.getGridEl().id, { + dragElId : Ext.id(this.proxy.dom), resizeFrame:false + }); + this.scroll = false; + this.hw = this.view.splitHandleWidth || 5; + }, b4StartDrag : function(x, y){ + this.dragHeadersDisabled = this.view.headersDisabled; this.view.headersDisabled = true; var h = this.view.mainWrap.getHeight(); this.marker.setHeight(h); this.marker.show(); this.marker.alignTo(this.view.getHeaderCell(this.cellIndex), 'tl-tl', [-2, 0]); this.proxy.setHeight(h); - var w = this.cm.getColumnWidth(this.cellIndex); - var minw = Math.max(w-this.grid.minColumnWidth, 0); + var w = this.cm.getColumnWidth(this.cellIndex), + minw = Math.max(w-this.grid.minColumnWidth, 0); this.resetConstraints(); this.setXConstraint(minw, 1000); this.setYConstraint(0, 0); @@ -66734,18 +69691,20 @@ Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, { this.startPos = x; Ext.dd.DDProxy.prototype.b4StartDrag.call(this, x, y); }, - + allowHeaderDrag : function(e){ return true; }, - handleMouseDown : function(e){ var t = this.view.findHeaderCell(e.getTarget()); if(t && this.allowHeaderDrag(e)){ - var xy = this.view.fly(t).getXY(), x = xy[0], y = xy[1]; - var exy = e.getXY(), ex = exy[0]; - var w = t.offsetWidth, adjust = false; + var xy = this.view.fly(t).getXY(), + x = xy[0], + y = xy[1]; + exy = e.getXY(), ex = exy[0], + w = t.offsetWidth, adjust = false; + if((ex - x) <= this.hw){ adjust = -1; }else if((x+w) - ex <= this.hw){ @@ -66778,12 +69737,14 @@ Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, { endDrag : function(e){ this.marker.hide(); - var v = this.view; - var endX = Math.max(this.minX, e.getPageX()); - var diff = endX - this.startPos; + var v = this.view, + endX = Math.max(this.minX, e.getPageX()), + diff = endX - this.startPos, + disabled = this.dragHeadersDisabled; + v.onColumnSplitterMoved(this.cellIndex, this.cm.getColumnWidth(this.cellIndex)+diff); setTimeout(function(){ - v.headersDisabled = false; + v.headersDisabled = disabled; }, 50); }, @@ -66791,199 +69752,205 @@ Ext.extend(Ext.grid.GridView.SplitDragZone, Ext.dd.DDProxy, { this.setDelta(0,0); } }); -// private -// This is a support class used internally by the Grid components -Ext.grid.HeaderDragZone = Ext.extend(Ext.dd.DragZone, { - maxDragWidth: 120, - - constructor : function(grid, hd, hd2){ - this.grid = grid; - this.view = grid.getView(); - this.ddGroup = "gridHeader" + this.grid.getGridEl().id; - Ext.grid.HeaderDragZone.superclass.constructor.call(this, hd); - if(hd2){ - this.setHandleElId(Ext.id(hd)); - this.setOuterHandleElId(Ext.id(hd2)); - } - this.scroll = false; - }, - - getDragData : function(e){ - var t = Ext.lib.Event.getTarget(e); - var h = this.view.findHeaderCell(t); - if(h){ - return {ddel: h.firstChild, header:h}; - } - return false; - }, - - onInitDrag : function(e){ - this.view.headersDisabled = true; - var clone = this.dragData.ddel.cloneNode(true); - clone.id = Ext.id(); - clone.style.width = Math.min(this.dragData.header.offsetWidth,this.maxDragWidth) + "px"; - this.proxy.update(clone); - return true; - }, - - afterValidDrop : function(){ - var v = this.view; - setTimeout(function(){ - v.headersDisabled = false; - }, 50); - }, - - afterInvalidDrop : function(){ - var v = this.view; - setTimeout(function(){ - v.headersDisabled = false; - }, 50); - } -}); - -// private -// This is a support class used internally by the Grid components -Ext.grid.HeaderDropZone = Ext.extend(Ext.dd.DropZone, { - proxyOffsets : [-4, -9], - fly: Ext.Element.fly, - - constructor : function(grid, hd, hd2){ - this.grid = grid; - this.view = grid.getView(); - // split the proxies so they don't interfere with mouse events - this.proxyTop = Ext.DomHelper.append(document.body, { - cls:"col-move-top", html:" " - }, true); - this.proxyBottom = Ext.DomHelper.append(document.body, { - cls:"col-move-bottom", html:" " - }, true); - this.proxyTop.hide = this.proxyBottom.hide = function(){ - this.setLeftTop(-100,-100); - this.setStyle("visibility", "hidden"); - }; - this.ddGroup = "gridHeader" + this.grid.getGridEl().id; - // temporarily disabled - //Ext.dd.ScrollManager.register(this.view.scroller.dom); - Ext.grid.HeaderDropZone.superclass.constructor.call(this, grid.getGridEl().dom); - }, - - getTargetFromEvent : function(e){ - var t = Ext.lib.Event.getTarget(e); - var cindex = this.view.findCellIndex(t); - if(cindex !== false){ - return this.view.getHeaderCell(cindex); - } - }, - - nextVisible : function(h){ - var v = this.view, cm = this.grid.colModel; - h = h.nextSibling; - while(h){ - if(!cm.isHidden(v.getCellIndex(h))){ - return h; - } - h = h.nextSibling; - } - return null; - }, - - prevVisible : function(h){ - var v = this.view, cm = this.grid.colModel; - h = h.prevSibling; - while(h){ - if(!cm.isHidden(v.getCellIndex(h))){ - return h; - } - h = h.prevSibling; - } - return null; - }, - - positionIndicator : function(h, n, e){ - var x = Ext.lib.Event.getPageX(e); - var r = Ext.lib.Dom.getRegion(n.firstChild); - var px, pt, py = r.top + this.proxyOffsets[1]; - if((r.right - x) <= (r.right-r.left)/2){ - px = r.right+this.view.borderWidth; - pt = "after"; - }else{ - px = r.left; - pt = "before"; - } - - if(this.grid.colModel.isFixed(this.view.getCellIndex(n))){ - return false; - } - - px += this.proxyOffsets[0]; - this.proxyTop.setLeftTop(px, py); - this.proxyTop.show(); - if(!this.bottomOffset){ - this.bottomOffset = this.view.mainHd.getHeight(); - } - this.proxyBottom.setLeftTop(px, py+this.proxyTop.dom.offsetHeight+this.bottomOffset); - this.proxyBottom.show(); - return pt; - }, - - onNodeEnter : function(n, dd, e, data){ - if(data.header != n){ - this.positionIndicator(data.header, n, e); - } - }, - - onNodeOver : function(n, dd, e, data){ - var result = false; - if(data.header != n){ - result = this.positionIndicator(data.header, n, e); - } - if(!result){ - this.proxyTop.hide(); - this.proxyBottom.hide(); - } - return result ? this.dropAllowed : this.dropNotAllowed; - }, - - onNodeOut : function(n, dd, e, data){ - this.proxyTop.hide(); - this.proxyBottom.hide(); - }, - - onNodeDrop : function(n, dd, e, data){ - var h = data.header; - if(h != n){ - var cm = this.grid.colModel; - var x = Ext.lib.Event.getPageX(e); - var r = Ext.lib.Dom.getRegion(n.firstChild); - var pt = (r.right - x) <= ((r.right-r.left)/2) ? "after" : "before"; - var oldIndex = this.view.getCellIndex(h); - var newIndex = this.view.getCellIndex(n); - if(pt == "after"){ - newIndex++; - } - if(oldIndex < newIndex){ - newIndex--; - } - cm.moveColumn(oldIndex, newIndex); - return true; - } - return false; - } -}); - -Ext.grid.GridView.ColumnDragZone = Ext.extend(Ext.grid.HeaderDragZone, { - - constructor : function(grid, hd){ - Ext.grid.GridView.ColumnDragZone.superclass.constructor.call(this, grid, hd, null); - this.proxy.el.addClass('x-grid3-col-dd'); - }, - - handleMouseDown : function(e){ - }, - - callHandleMouseDown : function(e){ - Ext.grid.GridView.ColumnDragZone.superclass.handleMouseDown.call(this, e); - } +// private +// This is a support class used internally by the Grid components +Ext.grid.HeaderDragZone = Ext.extend(Ext.dd.DragZone, { + maxDragWidth: 120, + + constructor : function(grid, hd, hd2){ + this.grid = grid; + this.view = grid.getView(); + this.ddGroup = "gridHeader" + this.grid.getGridEl().id; + Ext.grid.HeaderDragZone.superclass.constructor.call(this, hd); + if(hd2){ + this.setHandleElId(Ext.id(hd)); + this.setOuterHandleElId(Ext.id(hd2)); + } + this.scroll = false; + }, + + getDragData : function(e){ + var t = Ext.lib.Event.getTarget(e), + h = this.view.findHeaderCell(t); + if(h){ + return {ddel: h.firstChild, header:h}; + } + return false; + }, + + onInitDrag : function(e){ + // keep the value here so we can restore it; + this.dragHeadersDisabled = this.view.headersDisabled; + this.view.headersDisabled = true; + var clone = this.dragData.ddel.cloneNode(true); + clone.id = Ext.id(); + clone.style.width = Math.min(this.dragData.header.offsetWidth,this.maxDragWidth) + "px"; + this.proxy.update(clone); + return true; + }, + + afterValidDrop : function(){ + this.completeDrop(); + }, + + afterInvalidDrop : function(){ + this.completeDrop(); + }, + + completeDrop: function(){ + var v = this.view, + disabled = this.dragHeadersDisabled; + setTimeout(function(){ + v.headersDisabled = disabled; + }, 50); + } +}); + +// private +// This is a support class used internally by the Grid components +Ext.grid.HeaderDropZone = Ext.extend(Ext.dd.DropZone, { + proxyOffsets : [-4, -9], + fly: Ext.Element.fly, + + constructor : function(grid, hd, hd2){ + this.grid = grid; + this.view = grid.getView(); + // split the proxies so they don't interfere with mouse events + this.proxyTop = Ext.DomHelper.append(document.body, { + cls:"col-move-top", html:" " + }, true); + this.proxyBottom = Ext.DomHelper.append(document.body, { + cls:"col-move-bottom", html:" " + }, true); + this.proxyTop.hide = this.proxyBottom.hide = function(){ + this.setLeftTop(-100,-100); + this.setStyle("visibility", "hidden"); + }; + this.ddGroup = "gridHeader" + this.grid.getGridEl().id; + // temporarily disabled + //Ext.dd.ScrollManager.register(this.view.scroller.dom); + Ext.grid.HeaderDropZone.superclass.constructor.call(this, grid.getGridEl().dom); + }, + + getTargetFromEvent : function(e){ + var t = Ext.lib.Event.getTarget(e), + cindex = this.view.findCellIndex(t); + if(cindex !== false){ + return this.view.getHeaderCell(cindex); + } + }, + + nextVisible : function(h){ + var v = this.view, cm = this.grid.colModel; + h = h.nextSibling; + while(h){ + if(!cm.isHidden(v.getCellIndex(h))){ + return h; + } + h = h.nextSibling; + } + return null; + }, + + prevVisible : function(h){ + var v = this.view, cm = this.grid.colModel; + h = h.prevSibling; + while(h){ + if(!cm.isHidden(v.getCellIndex(h))){ + return h; + } + h = h.prevSibling; + } + return null; + }, + + positionIndicator : function(h, n, e){ + var x = Ext.lib.Event.getPageX(e), + r = Ext.lib.Dom.getRegion(n.firstChild), + px, + pt, + py = r.top + this.proxyOffsets[1]; + if((r.right - x) <= (r.right-r.left)/2){ + px = r.right+this.view.borderWidth; + pt = "after"; + }else{ + px = r.left; + pt = "before"; + } + + if(this.grid.colModel.isFixed(this.view.getCellIndex(n))){ + return false; + } + + px += this.proxyOffsets[0]; + this.proxyTop.setLeftTop(px, py); + this.proxyTop.show(); + if(!this.bottomOffset){ + this.bottomOffset = this.view.mainHd.getHeight(); + } + this.proxyBottom.setLeftTop(px, py+this.proxyTop.dom.offsetHeight+this.bottomOffset); + this.proxyBottom.show(); + return pt; + }, + + onNodeEnter : function(n, dd, e, data){ + if(data.header != n){ + this.positionIndicator(data.header, n, e); + } + }, + + onNodeOver : function(n, dd, e, data){ + var result = false; + if(data.header != n){ + result = this.positionIndicator(data.header, n, e); + } + if(!result){ + this.proxyTop.hide(); + this.proxyBottom.hide(); + } + return result ? this.dropAllowed : this.dropNotAllowed; + }, + + onNodeOut : function(n, dd, e, data){ + this.proxyTop.hide(); + this.proxyBottom.hide(); + }, + + onNodeDrop : function(n, dd, e, data){ + var h = data.header; + if(h != n){ + var cm = this.grid.colModel, + x = Ext.lib.Event.getPageX(e), + r = Ext.lib.Dom.getRegion(n.firstChild), + pt = (r.right - x) <= ((r.right-r.left)/2) ? "after" : "before", + oldIndex = this.view.getCellIndex(h), + newIndex = this.view.getCellIndex(n); + if(pt == "after"){ + newIndex++; + } + if(oldIndex < newIndex){ + newIndex--; + } + cm.moveColumn(oldIndex, newIndex); + return true; + } + return false; + } +}); + +Ext.grid.GridView.ColumnDragZone = Ext.extend(Ext.grid.HeaderDragZone, { + + constructor : function(grid, hd){ + Ext.grid.GridView.ColumnDragZone.superclass.constructor.call(this, grid, hd, null); + this.proxy.el.addClass('x-grid3-col-dd'); + }, + + handleMouseDown : function(e){ + }, + + callHandleMouseDown : function(e){ + Ext.grid.GridView.ColumnDragZone.superclass.handleMouseDown.call(this, e); + } });// private // This is a support class used internally by the Grid components Ext.grid.SplitDragZone = Ext.extend(Ext.dd.DDProxy, { @@ -67236,7 +70203,7 @@ Ext.grid.ColumnModel = Ext.extend(Ext.util.Observable, { * configuration options to all {@link #columns}. Configuration options specified with * individual {@link Ext.grid.Column column} configs will supersede these {@link #defaults}. */ - + constructor : function(config){ /** * An Array of {@link Ext.grid.Column Column definition} objects representing the configuration @@ -67325,7 +70292,11 @@ Ext.grid.ColumnModel = Ext.extend(Ext.util.Observable, { if(!initial){ // cleanup delete this.totalWidth; for(i = 0, len = this.config.length; i < len; i++){ - this.config[i].destroy(); + c = this.config[i]; + if(c.setEditor){ + //check here, in case we have a special column like a CheckboxSelectionModel + c.setEditor(null); + } } } @@ -67465,7 +70436,7 @@ var columns = grid.getColumnModel().getColumnsBy(function(c){ } return this.config[col].renderer; }, - + getRendererScope : function(col){ return this.config[col].scope; }, @@ -67632,7 +70603,7 @@ var grid = new Ext.grid.GridPanel({ isCellEditable : function(colIndex, rowIndex){ var c = this.config[colIndex], ed = c.editable; - + //force boolean return !!(ed || (!Ext.isDefined(ed) && c.editor)); }, @@ -67714,8 +70685,12 @@ myGrid.getColumnModel().setHidden(0, true); // hide column 0 (0 = the first colu * Destroys this column model by purging any event listeners, and removing any editors. */ destroy : function(){ + var c; for(var i = 0, len = this.config.length; i < len; i++){ - this.config[i].destroy(); + c = this.config[i]; + if(c.setEditor){ + c.setEditor(null); + } } this.purgeListeners(); } @@ -67727,56 +70702,98 @@ Ext.grid.ColumnModel.defaultRenderer = function(value){ return " "; } return value; -};/** - * @class Ext.grid.AbstractSelectionModel - * @extends Ext.util.Observable - * Abstract base class for grid SelectionModels. It provides the interface that should be - * implemented by descendant classes. This class should not be directly instantiated. - * @constructor - */ -Ext.grid.AbstractSelectionModel = Ext.extend(Ext.util.Observable, { - /** - * The GridPanel for which this SelectionModel is handling selection. Read-only. - * @type Object - * @property grid - */ - - constructor : function(){ - this.locked = false; - Ext.grid.AbstractSelectionModel.superclass.constructor.call(this); - }, - - /** @ignore Called by the grid automatically. Do not call directly. */ - init : function(grid){ - this.grid = grid; - this.initEvents(); - }, - - /** - * Locks the selections. - */ - lock : function(){ - this.locked = true; - }, - - /** - * Unlocks the selections. - */ - unlock : function(){ - this.locked = false; - }, - - /** - * Returns true if the selections are locked. - * @return {Boolean} - */ - isLocked : function(){ - return this.locked; - }, - - destroy: function(){ - this.purgeListeners(); - } +};/** + * @class Ext.grid.AbstractSelectionModel + * @extends Ext.util.Observable + * Abstract base class for grid SelectionModels. It provides the interface that should be + * implemented by descendant classes. This class should not be directly instantiated. + * @constructor + */ +Ext.grid.AbstractSelectionModel = Ext.extend(Ext.util.Observable, { + /** + * The GridPanel for which this SelectionModel is handling selection. Read-only. + * @type Object + * @property grid + */ + + constructor : function(){ + this.locked = false; + Ext.grid.AbstractSelectionModel.superclass.constructor.call(this); + }, + + /** @ignore Called by the grid automatically. Do not call directly. */ + init : function(grid){ + this.grid = grid; + if(this.lockOnInit){ + delete this.lockOnInit; + this.locked = false; + this.lock(); + } + this.initEvents(); + }, + + /** + * Locks the selections. + */ + lock : function(){ + if(!this.locked){ + this.locked = true; + // If the grid has been set, then the view is already initialized. + var g = this.grid; + if(g){ + g.getView().on({ + scope: this, + beforerefresh: this.sortUnLock, + refresh: this.sortLock + }); + }else{ + this.lockOnInit = true; + } + } + }, + + // set the lock states before and after a view refresh + sortLock : function() { + this.locked = true; + }, + + // set the lock states before and after a view refresh + sortUnLock : function() { + this.locked = false; + }, + + /** + * Unlocks the selections. + */ + unlock : function(){ + if(this.locked){ + this.locked = false; + var g = this.grid, + gv; + + // If the grid has been set, then the view is already initialized. + if(g){ + gv = g.getView(); + gv.un('beforerefresh', this.sortUnLock, this); + gv.un('refresh', this.sortLock, this); + }else{ + delete this.lockOnInit; + } + } + }, + + /** + * Returns true if the selections are locked. + * @return {Boolean} + */ + isLocked : function(){ + return this.locked; + }, + + destroy: function(){ + this.unlock(); + this.purgeListeners(); + } });/** * @class Ext.grid.RowSelectionModel * @extends Ext.grid.AbstractSelectionModel @@ -68309,427 +71326,434 @@ Ext.grid.RowSelectionModel = Ext.extend(Ext.grid.AbstractSelectionModel, { } Ext.grid.RowSelectionModel.superclass.destroy.call(this); } -});/** - * @class Ext.grid.Column - *
This class encapsulates column configuration data to be used in the initialization of a - * {@link Ext.grid.ColumnModel ColumnModel}.
- *
While subclasses are provided to render data in different ways, this class renders a passed - * data field unchanged and is usually used for textual columns.
- */ -Ext.grid.Column = Ext.extend(Object, { - /** - * @cfg {Boolean} editable Optional. Defaults to true, enabling the configured - * {@link #editor}. Set to false to initially disable editing on this column. - * The initial configuration may be dynamically altered using - * {@link Ext.grid.ColumnModel}.{@link Ext.grid.ColumnModel#setEditable setEditable()}. - */ - /** - * @cfg {String} id Optional. A name which identifies this column (defaults to the column's initial - * ordinal position.) The id is used to create a CSS class name which is applied to all - * table cells (including headers) in that column (in this context the id does not need to be - * unique). The class name takes the form of
x-grid3-td-id
- * Header cells will also receive this class name, but will also have the class
x-grid3-hd
- * So, to target header cells, use CSS selectors such as:
.x-grid3-hd-row .x-grid3-td-id
- * The {@link Ext.grid.GridPanel#autoExpandColumn} grid config option references the column via this - * unique identifier. - */ - /** - * @cfg {String} header Optional. The header text to be used as innerHTML - * (html tags are accepted) to display in the Grid view. Note: to - * have a clickable header with no text displayed use ' '. - */ - /** - * @cfg {Boolean} groupable Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option - * may be used to disable the header menu item to group by the column selected. Defaults to true, - * which enables the header menu group option. Set to false to disable (but still show) the - * group option in the header menu for the column. See also {@link #groupName}. - */ - /** - * @cfg {String} groupName Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option - * may be used to specify the text with which to prefix the group field value in the group header line. - * See also {@link #groupRenderer} and - * {@link Ext.grid.GroupingView}.{@link Ext.grid.GroupingView#showGroupName showGroupName}. - */ - /** - * @cfg {Function} groupRenderer
Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option - * may be used to specify the function used to format the grouping field value for display in the group - * {@link #groupName header}. If a groupRenderer is not specified, the configured - * {@link #renderer} will be called; if a {@link #renderer} is also not specified - * the new value of the group field will be used.
- *
The called function (either the groupRenderer or {@link #renderer}) will be - * passed the following parameters: - *
- *
v : Object
The new value of the group field.
- *
unused : undefined
Unused parameter.
- *
r : Ext.data.Record
The Record providing the data - * for the row which caused group change.
- *
rowIndex : Number
The row index of the Record which caused group change.
- *
colIndex : Number
The column index of the group field.
- *
ds : Ext.data.Store
The Store which is providing the data Model.
- *
- *
The function should return a string value.
- */ - /** - * @cfg {String} emptyGroupText Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option - * may be used to specify the text to display when there is an empty group value. Defaults to the - * {@link Ext.grid.GroupingView}.{@link Ext.grid.GroupingView#emptyGroupText emptyGroupText}. - */ - /** - * @cfg {String} dataIndex
Required. The name of the field in the - * grid's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from - * which to draw the column's value.
- */ - /** - * @cfg {Number} width - * Optional. The initial width in pixels of the column. - * The width of each column can also be affected if any of the following are configured: - *
- *
{@link Ext.grid.GridPanel}.{@link Ext.grid.GridPanel#autoExpandColumn autoExpandColumn}
- *
{@link Ext.grid.GridView}.{@link Ext.grid.GridView#forceFit forceFit} - *
- *
By specifying forceFit:true, {@link #fixed non-fixed width} columns will be - * re-proportioned (based on the relative initial widths) to fill the width of the grid so - * that no horizontal scrollbar is shown.
- *
- *
{@link Ext.grid.GridView}.{@link Ext.grid.GridView#autoFill autoFill}
- *
{@link Ext.grid.GridPanel}.{@link Ext.grid.GridPanel#minColumnWidth minColumnWidth}
- *
Note: when the width of each column is determined, a space on the right side - * is reserved for the vertical scrollbar. The - * {@link Ext.grid.GridView}.{@link Ext.grid.GridView#scrollOffset scrollOffset} - * can be modified to reduce or eliminate the reserved offset.
- */ - /** - * @cfg {Boolean} sortable Optional. true if sorting is to be allowed on this column. - * Defaults to the value of the {@link Ext.grid.ColumnModel#defaultSortable} property. - * Whether local/remote sorting is used is specified in {@link Ext.data.Store#remoteSort}. - */ - /** - * @cfg {Boolean} fixed Optional. true if the column width cannot be changed. Defaults to false. - */ - /** - * @cfg {Boolean} resizable Optional. false to disable column resizing. Defaults to true. - */ - /** - * @cfg {Boolean} menuDisabled Optional. true to disable the column menu. Defaults to false. - */ - /** - * @cfg {Boolean} hidden - * Optional. true to initially hide this column. Defaults to false. - * A hidden column {@link Ext.grid.GridPanel#enableColumnHide may be shown via the header row menu}. - * If a column is never to be shown, simply do not include this column in the Column Model at all. - */ - /** - * @cfg {String} tooltip Optional. A text string to use as the column header's tooltip. If Quicktips - * are enabled, this value will be used as the text of the quick tip, otherwise it will be set as the - * header's HTML title attribute. Defaults to ''. - */ - /** - * @cfg {Mixed} renderer - *
For an alternative to specifying a renderer see {@link #xtype}
- *
Optional. A renderer is an 'interceptor' method which can be used transform data (value, - * appearance, etc.) before it is rendered). This may be specified in either of three ways: - *
- *
A renderer function used to return HTML markup for a cell given the cell's data value.
- *
A string which references a property name of the {@link Ext.util.Format} class which - * provides a renderer function.
- *
An object specifying both the renderer function, and its execution scope (this - * reference) e.g.:
-{ - fn: this.gridRenderer, - scope: this -} -
- * If not specified, the default renderer uses the raw data value.
- *
For information about the renderer function (passed parameters, etc.), see - * {@link Ext.grid.ColumnModel#setRenderer}. An example of specifying renderer function inline:
-var companyColumn = { - header: 'Company Name', - dataIndex: 'company', - renderer: function(value, metaData, record, rowIndex, colIndex, store) { - // provide the logic depending on business rules - // name of your own choosing to manipulate the cell depending upon - // the data in the underlying Record object. - if (value == 'whatever') { - //metaData.css : String : A CSS class name to add to the TD element of the cell. - //metaData.attr : String : An html attribute definition string to apply to - // the data container element within the table - // cell (e.g. 'style="color:red;"'). - metaData.css = 'name-of-css-class-you-will-define'; - } - return value; - } -} - *
- * See also {@link #scope}. - */ - /** - * @cfg {String} xtype Optional. A String which references a predefined {@link Ext.grid.Column} subclass - * type which is preconfigured with an appropriate {@link #renderer} to be easily - * configured into a ColumnModel. The predefined {@link Ext.grid.Column} subclass types are: - *
- *
gridcolumn : {@link Ext.grid.Column} (Default)
- *
booleancolumn : {@link Ext.grid.BooleanColumn}
- *
numbercolumn : {@link Ext.grid.NumberColumn}
- *
datecolumn : {@link Ext.grid.DateColumn}
- *
templatecolumn : {@link Ext.grid.TemplateColumn}
- *
- *
Configuration properties for the specified xtype may be specified with - * the Column configuration properties, for example:
- *
-var grid = new Ext.grid.GridPanel({ - ... - columns: [{ - header: 'Last Updated', - dataIndex: 'lastChange', - width: 85, - sortable: true, - //renderer: Ext.util.Format.dateRenderer('m/d/Y'), - xtype: 'datecolumn', // use xtype instead of renderer - format: 'M/d/Y' // configuration property for {@link Ext.grid.DateColumn} - }, { - ... - }] -}); - *
- */ - /** - * @cfg {Object} scope Optional. The scope (this reference) in which to execute the - * renderer. Defaults to the Column configuration object. - */ - /** - * @cfg {String} align Optional. Set the CSS text-align property of the column. Defaults to undefined. - */ - /** - * @cfg {String} css Optional. An inline style definition string which is applied to all table cells in the column - * (excluding headers). Defaults to undefined. - */ - /** - * @cfg {Boolean} hideable Optional. Specify as false to prevent the user from hiding this column - * (defaults to true). To disallow column hiding globally for all columns in the grid, use - * {@link Ext.grid.GridPanel#enableColumnHide} instead. - */ - /** - * @cfg {Ext.form.Field} editor Optional. The {@link Ext.form.Field} to use when editing values in this column - * if editing is supported by the grid. See {@link #editable} also. - */ - - /** - * @private - * @cfg {Boolean} isColumn - * Used by ColumnModel setConfig method to avoid reprocessing a Column - * if isColumn is not set ColumnModel will recreate a new Ext.grid.Column - * Defaults to true. - */ - isColumn : true, - - constructor : function(config){ - Ext.apply(this, config); - - if(Ext.isString(this.renderer)){ - this.renderer = Ext.util.Format[this.renderer]; - }else if(Ext.isObject(this.renderer)){ - this.scope = this.renderer.scope; - this.renderer = this.renderer.fn; - } - if(!this.scope){ - this.scope = this; - } - - var ed = this.editor; - delete this.editor; - this.setEditor(ed); - }, - - /** - * Optional. A function which returns displayable data when passed the following parameters: - *
- *
value : Object
The data value for the cell.
- *
metadata : Object
An object in which you may set the following attributes:
- *
css : String
A CSS class name to add to the cell's TD element.
- *
attr : String
An HTML attribute definition string to apply to the data container - * element within the table cell (e.g. 'style="color:red;"').
- *
record : Ext.data.record
The {@link Ext.data.Record} from which the data was - * extracted.
- *
rowIndex : Number
Row index
- *
colIndex : Number
Column index
- *
store : Ext.data.Store
The {@link Ext.data.Store} object from which the Record - * was extracted.
- *
- * @property renderer - * @type Function - */ - renderer : function(value){ - if(Ext.isString(value) && value.length < 1){ - return ' '; - } - return value; - }, - - // private - getEditor: function(rowIndex){ - return this.editable !== false ? this.editor : null; - }, - - /** - * Sets a new editor for this column. - * @param {Ext.Editor/Ext.form.Field} editor The editor to set - */ - setEditor : function(editor){ - if(this.editor){ - this.editor.destroy(); - } - this.editor = null; - if(editor){ - //not an instance, create it - if(!editor.isXType){ - editor = Ext.create(editor, 'textfield'); - } - //check if it's wrapped in an editor - if(!editor.startEdit){ - editor = new Ext.grid.GridEditor(editor); - } - this.editor = editor; - } - }, - - destroy : function(){ - this.setEditor(null); - }, - - /** - * Returns the {@link Ext.Editor editor} defined for this column that was created to wrap the {@link Ext.form.Field Field} - * used to edit the cell. - * @param {Number} rowIndex The row index - * @return {Ext.Editor} - */ - getCellEditor: function(rowIndex){ - return this.getEditor(rowIndex); - } -}); - -/** - * @class Ext.grid.BooleanColumn - * @extends Ext.grid.Column - *
A Column definition class which renders boolean data fields. See the {@link Ext.grid.Column#xtype xtype} - * config option of {@link Ext.grid.Column} for more details.
- */ -Ext.grid.BooleanColumn = Ext.extend(Ext.grid.Column, { - /** - * @cfg {String} trueText - * The string returned by the renderer when the column value is not falsey (defaults to 'true'). - */ - trueText: 'true', - /** - * @cfg {String} falseText - * The string returned by the renderer when the column value is falsey (but not undefined) (defaults to - * 'false'). - */ - falseText: 'false', - /** - * @cfg {String} undefinedText - * The string returned by the renderer when the column value is undefined (defaults to ' '). - */ - undefinedText: ' ', - - constructor: function(cfg){ - Ext.grid.BooleanColumn.superclass.constructor.call(this, cfg); - var t = this.trueText, f = this.falseText, u = this.undefinedText; - this.renderer = function(v){ - if(v === undefined){ - return u; - } - if(!v || v === 'false'){ - return f; - } - return t; - }; - } -}); - -/** - * @class Ext.grid.NumberColumn - * @extends Ext.grid.Column - *
A Column definition class which renders a numeric data field according to a {@link #format} string. See the - * {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} for more details.
- */ -Ext.grid.NumberColumn = Ext.extend(Ext.grid.Column, { - /** - * @cfg {String} format - * A formatting string as used by {@link Ext.util.Format#number} to format a numeric value for this Column - * (defaults to '0,000.00'). - */ - format : '0,000.00', - constructor: function(cfg){ - Ext.grid.NumberColumn.superclass.constructor.call(this, cfg); - this.renderer = Ext.util.Format.numberRenderer(this.format); - } -}); - -/** - * @class Ext.grid.DateColumn - * @extends Ext.grid.Column - *
A Column definition class which renders a passed date according to the default locale, or a configured - * {@link #format}. See the {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} - * for more details.
- */ -Ext.grid.DateColumn = Ext.extend(Ext.grid.Column, { - /** - * @cfg {String} format - * A formatting string as used by {@link Date#format} to format a Date for this Column - * (defaults to 'm/d/Y'). - */ - format : 'm/d/Y', - constructor: function(cfg){ - Ext.grid.DateColumn.superclass.constructor.call(this, cfg); - this.renderer = Ext.util.Format.dateRenderer(this.format); - } -}); - -/** - * @class Ext.grid.TemplateColumn - * @extends Ext.grid.Column - *
A Column definition class which renders a value by processing a {@link Ext.data.Record Record}'s - * {@link Ext.data.Record#data data} using a {@link #tpl configured} {@link Ext.XTemplate XTemplate}. - * See the {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} for more - * details.
- */ -Ext.grid.TemplateColumn = Ext.extend(Ext.grid.Column, { - /** - * @cfg {String/XTemplate} tpl - * An {@link Ext.XTemplate XTemplate}, or an XTemplate definition string to use to process a - * {@link Ext.data.Record Record}'s {@link Ext.data.Record#data data} to produce a column's rendered value. - */ - constructor: function(cfg){ - Ext.grid.TemplateColumn.superclass.constructor.call(this, cfg); - var tpl = (!Ext.isPrimitive(this.tpl) && this.tpl.compile) ? this.tpl : new Ext.XTemplate(this.tpl); - this.renderer = function(value, p, r){ - return tpl.apply(r.data); - }; - this.tpl = tpl; - } -}); - -/* - * @property types - * @type Object - * @member Ext.grid.Column - * @static - *
An object containing predefined Column classes keyed by a mnemonic code which may be referenced - * by the {@link Ext.grid.ColumnModel#xtype xtype} config option of ColumnModel.
- *
This contains the following properties
- *
gridcolumn : {@link Ext.grid.Column Column constructor}
- *
booleancolumn : {@link Ext.grid.BooleanColumn BooleanColumn constructor}
- *
numbercolumn : {@link Ext.grid.NumberColumn NumberColumn constructor}
- *
datecolumn : {@link Ext.grid.DateColumn DateColumn constructor}
- *
templatecolumn : {@link Ext.grid.TemplateColumn TemplateColumn constructor}
- *
- */ -Ext.grid.Column.types = { - gridcolumn : Ext.grid.Column, - booleancolumn: Ext.grid.BooleanColumn, - numbercolumn: Ext.grid.NumberColumn, - datecolumn: Ext.grid.DateColumn, - templatecolumn: Ext.grid.TemplateColumn +});/** + * @class Ext.grid.Column + *
This class encapsulates column configuration data to be used in the initialization of a + * {@link Ext.grid.ColumnModel ColumnModel}.
+ *
While subclasses are provided to render data in different ways, this class renders a passed + * data field unchanged and is usually used for textual columns.
+ */ +Ext.grid.Column = Ext.extend(Object, { + /** + * @cfg {Boolean} editable Optional. Defaults to true, enabling the configured + * {@link #editor}. Set to false to initially disable editing on this column. + * The initial configuration may be dynamically altered using + * {@link Ext.grid.ColumnModel}.{@link Ext.grid.ColumnModel#setEditable setEditable()}. + */ + /** + * @cfg {String} id Optional. A name which identifies this column (defaults to the column's initial + * ordinal position.) The id is used to create a CSS class name which is applied to all + * table cells (including headers) in that column (in this context the id does not need to be + * unique). The class name takes the form of
x-grid3-td-id
+ * Header cells will also receive this class name, but will also have the class
x-grid3-hd
+ * So, to target header cells, use CSS selectors such as:
.x-grid3-hd-row .x-grid3-td-id
+ * The {@link Ext.grid.GridPanel#autoExpandColumn} grid config option references the column via this + * unique identifier. + */ + /** + * @cfg {String} header Optional. The header text to be used as innerHTML + * (html tags are accepted) to display in the Grid view. Note: to + * have a clickable header with no text displayed use ' '. + */ + /** + * @cfg {Boolean} groupable Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option + * may be used to disable the header menu item to group by the column selected. Defaults to true, + * which enables the header menu group option. Set to false to disable (but still show) the + * group option in the header menu for the column. See also {@link #groupName}. + */ + /** + * @cfg {String} groupName Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option + * may be used to specify the text with which to prefix the group field value in the group header line. + * See also {@link #groupRenderer} and + * {@link Ext.grid.GroupingView}.{@link Ext.grid.GroupingView#showGroupName showGroupName}. + */ + /** + * @cfg {Function} groupRenderer
Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option + * may be used to specify the function used to format the grouping field value for display in the group + * {@link #groupName header}. If a groupRenderer is not specified, the configured + * {@link #renderer} will be called; if a {@link #renderer} is also not specified + * the new value of the group field will be used.
+ *
The called function (either the groupRenderer or {@link #renderer}) will be + * passed the following parameters: + *
+ *
v : Object
The new value of the group field.
+ *
unused : undefined
Unused parameter.
+ *
r : Ext.data.Record
The Record providing the data + * for the row which caused group change.
+ *
rowIndex : Number
The row index of the Record which caused group change.
+ *
colIndex : Number
The column index of the group field.
+ *
ds : Ext.data.Store
The Store which is providing the data Model.
+ *
+ *
The function should return a string value.
+ */ + /** + * @cfg {String} emptyGroupText Optional. If the grid is being rendered by an {@link Ext.grid.GroupingView}, this option + * may be used to specify the text to display when there is an empty group value. Defaults to the + * {@link Ext.grid.GroupingView}.{@link Ext.grid.GroupingView#emptyGroupText emptyGroupText}. + */ + /** + * @cfg {String} dataIndex
Required. The name of the field in the + * grid's {@link Ext.data.Store}'s {@link Ext.data.Record} definition from + * which to draw the column's value.
+ */ + /** + * @cfg {Number} width + * Optional. The initial width in pixels of the column. + * The width of each column can also be affected if any of the following are configured: + *
+ *
{@link Ext.grid.GridPanel}.{@link Ext.grid.GridPanel#autoExpandColumn autoExpandColumn}
+ *
{@link Ext.grid.GridView}.{@link Ext.grid.GridView#forceFit forceFit} + *
+ *
By specifying forceFit:true, {@link #fixed non-fixed width} columns will be + * re-proportioned (based on the relative initial widths) to fill the width of the grid so + * that no horizontal scrollbar is shown.
+ *
+ *
{@link Ext.grid.GridView}.{@link Ext.grid.GridView#autoFill autoFill}
+ *
{@link Ext.grid.GridPanel}.{@link Ext.grid.GridPanel#minColumnWidth minColumnWidth}
+ *
Note: when the width of each column is determined, a space on the right side + * is reserved for the vertical scrollbar. The + * {@link Ext.grid.GridView}.{@link Ext.grid.GridView#scrollOffset scrollOffset} + * can be modified to reduce or eliminate the reserved offset.
+ */ + /** + * @cfg {Boolean} sortable Optional. true if sorting is to be allowed on this column. + * Defaults to the value of the {@link Ext.grid.ColumnModel#defaultSortable} property. + * Whether local/remote sorting is used is specified in {@link Ext.data.Store#remoteSort}. + */ + /** + * @cfg {Boolean} fixed Optional. true if the column width cannot be changed. Defaults to false. + */ + /** + * @cfg {Boolean} resizable Optional. false to disable column resizing. Defaults to true. + */ + /** + * @cfg {Boolean} menuDisabled Optional. true to disable the column menu. Defaults to false. + */ + /** + * @cfg {Boolean} hidden + * Optional. true to initially hide this column. Defaults to false. + * A hidden column {@link Ext.grid.GridPanel#enableColumnHide may be shown via the header row menu}. + * If a column is never to be shown, simply do not include this column in the Column Model at all. + */ + /** + * @cfg {String} tooltip Optional. A text string to use as the column header's tooltip. If Quicktips + * are enabled, this value will be used as the text of the quick tip, otherwise it will be set as the + * header's HTML title attribute. Defaults to ''. + */ + /** + * @cfg {Mixed} renderer + *
For an alternative to specifying a renderer see {@link #xtype}
+ *
Optional. A renderer is an 'interceptor' method which can be used transform data (value, + * appearance, etc.) before it is rendered). This may be specified in either of three ways: + *
+ *
A renderer function used to return HTML markup for a cell given the cell's data value.
+ *
A string which references a property name of the {@link Ext.util.Format} class which + * provides a renderer function.
+ *
An object specifying both the renderer function, and its execution scope (this + * reference) e.g.:
+{ + fn: this.gridRenderer, + scope: this +} +
+ * If not specified, the default renderer uses the raw data value.
+ *
For information about the renderer function (passed parameters, etc.), see + * {@link Ext.grid.ColumnModel#setRenderer}. An example of specifying renderer function inline:
+var companyColumn = { + header: 'Company Name', + dataIndex: 'company', + renderer: function(value, metaData, record, rowIndex, colIndex, store) { + // provide the logic depending on business rules + // name of your own choosing to manipulate the cell depending upon + // the data in the underlying Record object. + if (value == 'whatever') { + //metaData.css : String : A CSS class name to add to the TD element of the cell. + //metaData.attr : String : An html attribute definition string to apply to + // the data container element within the table + // cell (e.g. 'style="color:red;"'). + metaData.css = 'name-of-css-class-you-will-define'; + } + return value; + } +} + *
+ * See also {@link #scope}. + */ + /** + * @cfg {String} xtype Optional. A String which references a predefined {@link Ext.grid.Column} subclass + * type which is preconfigured with an appropriate {@link #renderer} to be easily + * configured into a ColumnModel. The predefined {@link Ext.grid.Column} subclass types are: + *
+ *
gridcolumn : {@link Ext.grid.Column} (Default)
+ *
booleancolumn : {@link Ext.grid.BooleanColumn}
+ *
numbercolumn : {@link Ext.grid.NumberColumn}
+ *
datecolumn : {@link Ext.grid.DateColumn}
+ *
templatecolumn : {@link Ext.grid.TemplateColumn}
+ *
+ *
Configuration properties for the specified xtype may be specified with + * the Column configuration properties, for example:
+ *
+var grid = new Ext.grid.GridPanel({ + ... + columns: [{ + header: 'Last Updated', + dataIndex: 'lastChange', + width: 85, + sortable: true, + //renderer: Ext.util.Format.dateRenderer('m/d/Y'), + xtype: 'datecolumn', // use xtype instead of renderer + format: 'M/d/Y' // configuration property for {@link Ext.grid.DateColumn} + }, { + ... + }] +}); + *
+ */ + /** + * @cfg {Object} scope Optional. The scope (this reference) in which to execute the + * renderer. Defaults to the Column configuration object. + */ + /** + * @cfg {String} align Optional. Set the CSS text-align property of the column. Defaults to undefined. + */ + /** + * @cfg {String} css Optional. An inline style definition string which is applied to all table cells in the column + * (excluding headers). Defaults to undefined. + */ + /** + * @cfg {Boolean} hideable Optional. Specify as false to prevent the user from hiding this column + * (defaults to true). To disallow column hiding globally for all columns in the grid, use + * {@link Ext.grid.GridPanel#enableColumnHide} instead. + */ + /** + * @cfg {Ext.form.Field} editor Optional. The {@link Ext.form.Field} to use when editing values in this column + * if editing is supported by the grid. See {@link #editable} also. + */ + + /** + * @private + * @cfg {Boolean} isColumn + * Used by ColumnModel setConfig method to avoid reprocessing a Column + * if isColumn is not set ColumnModel will recreate a new Ext.grid.Column + * Defaults to true. + */ + isColumn : true, + + constructor : function(config){ + Ext.apply(this, config); + + if(Ext.isString(this.renderer)){ + this.renderer = Ext.util.Format[this.renderer]; + }else if(Ext.isObject(this.renderer)){ + this.scope = this.renderer.scope; + this.renderer = this.renderer.fn; + } + if(!this.scope){ + this.scope = this; + } + + var ed = this.editor; + delete this.editor; + this.setEditor(ed); + }, + + /** + * Optional. A function which returns displayable data when passed the following parameters: + *
+ *
value : Object
The data value for the cell.
+ *
metadata : Object
An object in which you may set the following attributes:
+ *
css : String
A CSS class name to add to the cell's TD element.
+ *
attr : String
An HTML attribute definition string to apply to the data container + * element within the table cell (e.g. 'style="color:red;"').
+ *
record : Ext.data.record
The {@link Ext.data.Record} from which the data was + * extracted.
+ *
rowIndex : Number
Row index
+ *
colIndex : Number
Column index
+ *
store : Ext.data.Store
The {@link Ext.data.Store} object from which the Record + * was extracted.
+ *
+ * @property renderer + * @type Function + */ + renderer : function(value){ + if(Ext.isString(value) && value.length < 1){ + return ' '; + } + return value; + }, + + // private + getEditor: function(rowIndex){ + return this.editable !== false ? this.editor : null; + }, + + /** + * Sets a new editor for this column. + * @param {Ext.Editor/Ext.form.Field} editor The editor to set + */ + setEditor : function(editor){ + var ed = this.editor; + if(ed){ + if(ed.gridEditor){ + ed.gridEditor.destroy(); + delete ed.gridEditor; + }else{ + ed.destroy(); + } + } + this.editor = null; + if(editor){ + //not an instance, create it + if(!editor.isXType){ + editor = Ext.create(editor, 'textfield'); + } + this.editor = editor; + } + }, + + /** + * Returns the {@link Ext.Editor editor} defined for this column that was created to wrap the {@link Ext.form.Field Field} + * used to edit the cell. + * @param {Number} rowIndex The row index + * @return {Ext.Editor} + */ + getCellEditor: function(rowIndex){ + var ed = this.getEditor(rowIndex); + if(ed){ + if(!ed.startEdit){ + if(!ed.gridEditor){ + ed.gridEditor = new Ext.grid.GridEditor(ed); + } + ed = ed.gridEditor; + } + } + return ed; + } +}); + +/** + * @class Ext.grid.BooleanColumn + * @extends Ext.grid.Column + *
A Column definition class which renders boolean data fields. See the {@link Ext.grid.Column#xtype xtype} + * config option of {@link Ext.grid.Column} for more details.
+ */ +Ext.grid.BooleanColumn = Ext.extend(Ext.grid.Column, { + /** + * @cfg {String} trueText + * The string returned by the renderer when the column value is not falsey (defaults to 'true'). + */ + trueText: 'true', + /** + * @cfg {String} falseText + * The string returned by the renderer when the column value is falsey (but not undefined) (defaults to + * 'false'). + */ + falseText: 'false', + /** + * @cfg {String} undefinedText + * The string returned by the renderer when the column value is undefined (defaults to ' '). + */ + undefinedText: ' ', + + constructor: function(cfg){ + Ext.grid.BooleanColumn.superclass.constructor.call(this, cfg); + var t = this.trueText, f = this.falseText, u = this.undefinedText; + this.renderer = function(v){ + if(v === undefined){ + return u; + } + if(!v || v === 'false'){ + return f; + } + return t; + }; + } +}); + +/** + * @class Ext.grid.NumberColumn + * @extends Ext.grid.Column + *
A Column definition class which renders a numeric data field according to a {@link #format} string. See the + * {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} for more details.
+ */ +Ext.grid.NumberColumn = Ext.extend(Ext.grid.Column, { + /** + * @cfg {String} format + * A formatting string as used by {@link Ext.util.Format#number} to format a numeric value for this Column + * (defaults to '0,000.00'). + */ + format : '0,000.00', + constructor: function(cfg){ + Ext.grid.NumberColumn.superclass.constructor.call(this, cfg); + this.renderer = Ext.util.Format.numberRenderer(this.format); + } +}); + +/** + * @class Ext.grid.DateColumn + * @extends Ext.grid.Column + *
A Column definition class which renders a passed date according to the default locale, or a configured + * {@link #format}. See the {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} + * for more details.
+ */ +Ext.grid.DateColumn = Ext.extend(Ext.grid.Column, { + /** + * @cfg {String} format + * A formatting string as used by {@link Date#format} to format a Date for this Column + * (defaults to 'm/d/Y'). + */ + format : 'm/d/Y', + constructor: function(cfg){ + Ext.grid.DateColumn.superclass.constructor.call(this, cfg); + this.renderer = Ext.util.Format.dateRenderer(this.format); + } +}); + +/** + * @class Ext.grid.TemplateColumn + * @extends Ext.grid.Column + *
A Column definition class which renders a value by processing a {@link Ext.data.Record Record}'s + * {@link Ext.data.Record#data data} using a {@link #tpl configured} {@link Ext.XTemplate XTemplate}. + * See the {@link Ext.grid.Column#xtype xtype} config option of {@link Ext.grid.Column} for more + * details.
+ */ +Ext.grid.TemplateColumn = Ext.extend(Ext.grid.Column, { + /** + * @cfg {String/XTemplate} tpl + * An {@link Ext.XTemplate XTemplate}, or an XTemplate definition string to use to process a + * {@link Ext.data.Record Record}'s {@link Ext.data.Record#data data} to produce a column's rendered value. + */ + constructor: function(cfg){ + Ext.grid.TemplateColumn.superclass.constructor.call(this, cfg); + var tpl = (!Ext.isPrimitive(this.tpl) && this.tpl.compile) ? this.tpl : new Ext.XTemplate(this.tpl); + this.renderer = function(value, p, r){ + return tpl.apply(r.data); + }; + this.tpl = tpl; + } +}); + +/* + * @property types + * @type Object + * @member Ext.grid.Column + * @static + *
An object containing predefined Column classes keyed by a mnemonic code which may be referenced + * by the {@link Ext.grid.ColumnModel#xtype xtype} config option of ColumnModel.
+ *
This contains the following properties
+ *
gridcolumn : {@link Ext.grid.Column Column constructor}
+ *
booleancolumn : {@link Ext.grid.BooleanColumn BooleanColumn constructor}
+ *
numbercolumn : {@link Ext.grid.NumberColumn NumberColumn constructor}
+ *
datecolumn : {@link Ext.grid.DateColumn DateColumn constructor}
+ *
templatecolumn : {@link Ext.grid.TemplateColumn TemplateColumn constructor}
+ *
+ */ +Ext.grid.Column.types = { + gridcolumn : Ext.grid.Column, + booleancolumn: Ext.grid.BooleanColumn, + numbercolumn: Ext.grid.NumberColumn, + datecolumn: Ext.grid.DateColumn, + templatecolumn: Ext.grid.TemplateColumn };/** * @class Ext.grid.RowNumberer * This is a utility class that can be passed into a {@link Ext.grid.ColumnModel} as a column config that provides @@ -68772,6 +71796,7 @@ Ext.grid.RowNumberer = Ext.extend(Object, { // private fixed:true, + hideable: false, menuDisabled:true, dataIndex: '', id: 'numberer', @@ -68784,102 +71809,113 @@ Ext.grid.RowNumberer = Ext.extend(Object, { } return rowIndex+1; } -});/** - * @class Ext.grid.CheckboxSelectionModel - * @extends Ext.grid.RowSelectionModel - * A custom selection model that renders a column of checkboxes that can be toggled to select or deselect rows. - * @constructor - * @param {Object} config The configuration options - */ -Ext.grid.CheckboxSelectionModel = Ext.extend(Ext.grid.RowSelectionModel, { - - /** - * @cfg {Boolean} checkOnly true if rows can only be selected by clicking on the - * checkbox column (defaults to false). - */ - /** - * @cfg {String} header Any valid text or HTML fragment to display in the header cell for the - * checkbox column. Defaults to:
- * '<div class="x-grid3-hd-checker"> </div>' - *
- * The default CSS class of 'x-grid3-hd-checker' displays a checkbox in the header - * and provides support for automatic check all/none behavior on header click. This string - * can be replaced by any valid HTML fragment, including a simple text string (e.g., - * 'Select Rows'), but the automatic check all/none behavior will only work if the - * 'x-grid3-hd-checker' class is supplied. - */ - header : '

', - /** - * @cfg {Number} width The default width in pixels of the checkbox column (defaults to 20). - */ - width : 20, - /** - * @cfg {Boolean} sortable true if the checkbox column is sortable (defaults to - * false). - */ - sortable : false, - - // private - menuDisabled : true, - fixed : true, - dataIndex : '', - id : 'checker', - - constructor : function(){ - Ext.grid.CheckboxSelectionModel.superclass.constructor.apply(this, arguments); - - if(this.checkOnly){ - this.handleMouseDown = Ext.emptyFn; - } - }, - - // private - initEvents : function(){ - Ext.grid.CheckboxSelectionModel.superclass.initEvents.call(this); - this.grid.on('render', function(){ - var view = this.grid.getView(); - view.mainBody.on('mousedown', this.onMouseDown, this); - Ext.fly(view.innerHd).on('mousedown', this.onHdMouseDown, this); - - }, this); - }, - - // private - onMouseDown : function(e, t){ - if(e.button === 0 && t.className == 'x-grid3-row-checker'){ // Only fire if left-click - e.stopEvent(); - var row = e.getTarget('.x-grid3-row'); - if(row){ - var index = row.rowIndex; - if(this.isSelected(index)){ - this.deselectRow(index); - }else{ - this.selectRow(index, true); - } - } - } - }, - - // private - onHdMouseDown : function(e, t){ - if(t.className == 'x-grid3-hd-checker'){ - e.stopEvent(); - var hd = Ext.fly(t.parentNode); - var isChecked = hd.hasClass('x-grid3-hd-checker-on'); - if(isChecked){ - hd.removeClass('x-grid3-hd-checker-on'); - this.clearSelections(); - }else{ - hd.addClass('x-grid3-hd-checker-on'); - this.selectAll(); - } - } - }, - - // private - renderer : function(v, p, record){ - return '

'; - } +});/** + * @class Ext.grid.CheckboxSelectionModel + * @extends Ext.grid.RowSelectionModel + * A custom selection model that renders a column of checkboxes that can be toggled to select or deselect rows. + * @constructor + * @param {Object} config The configuration options + */ +Ext.grid.CheckboxSelectionModel = Ext.extend(Ext.grid.RowSelectionModel, { + + /** + * @cfg {Boolean} checkOnly true if rows can only be selected by clicking on the + * checkbox column (defaults to false). + */ + /** + * @cfg {String} header Any valid text or HTML fragment to display in the header cell for the + * checkbox column. Defaults to:
+ * '<div class="x-grid3-hd-checker"> </div>' + *
+ * The default CSS class of 'x-grid3-hd-checker' displays a checkbox in the header + * and provides support for automatic check all/none behavior on header click. This string + * can be replaced by any valid HTML fragment, including a simple text string (e.g., + * 'Select Rows'), but the automatic check all/none behavior will only work if the + * 'x-grid3-hd-checker' class is supplied. + */ + header : '

', + /** + * @cfg {Number} width The default width in pixels of the checkbox column (defaults to 20). + */ + width : 20, + /** + * @cfg {Boolean} sortable true if the checkbox column is sortable (defaults to + * false). + */ + sortable : false, + + // private + menuDisabled : true, + fixed : true, + hideable: false, + dataIndex : '', + id : 'checker', + + constructor : function(){ + Ext.grid.CheckboxSelectionModel.superclass.constructor.apply(this, arguments); + + if(this.checkOnly){ + this.handleMouseDown = Ext.emptyFn; + } + }, + + // private + initEvents : function(){ + Ext.grid.CheckboxSelectionModel.superclass.initEvents.call(this); + this.grid.on('render', function(){ + var view = this.grid.getView(); + view.mainBody.on('mousedown', this.onMouseDown, this); + Ext.fly(view.innerHd).on('mousedown', this.onHdMouseDown, this); + + }, this); + }, + + // If handleMouseDown was called from another event (enableDragDrop), set a flag so + // onMouseDown does not process it a second time + handleMouseDown : function() { + Ext.grid.CheckboxSelectionModel.superclass.handleMouseDown.apply(this, arguments); + this.mouseHandled = true; + }, + + // private + onMouseDown : function(e, t){ + if(e.button === 0 && t.className == 'x-grid3-row-checker'){ // Only fire if left-click + e.stopEvent(); + var row = e.getTarget('.x-grid3-row'); + + // mouseHandled flag check for a duplicate selection (handleMouseDown) call + if(!this.mouseHandled && row){ + var index = row.rowIndex; + if(this.isSelected(index)){ + this.deselectRow(index); + }else{ + this.selectRow(index, true); + } + } + } + this.mouseHandled = false; + }, + + // private + onHdMouseDown : function(e, t){ + if(t.className == 'x-grid3-hd-checker'){ + e.stopEvent(); + var hd = Ext.fly(t.parentNode); + var isChecked = hd.hasClass('x-grid3-hd-checker-on'); + if(isChecked){ + hd.removeClass('x-grid3-hd-checker-on'); + this.clearSelections(); + }else{ + hd.addClass('x-grid3-hd-checker-on'); + this.selectAll(); + } + } + }, + + // private + renderer : function(v, p, record){ + return '

'; + } });/** * @class Ext.grid.CellSelectionModel * @extends Ext.grid.AbstractSelectionModel @@ -69358,6 +72394,7 @@ grid.on('validateedit', function(e) { // private onEditComplete : function(ed, value, startValue){ this.editing = false; + this.lastActiveEditor = this.activeEditor; this.activeEditor = null; var r = ed.record, @@ -69950,568 +72987,574 @@ grid.setSource({ */ }); Ext.reg("propertygrid", Ext.grid.PropertyGrid); -/** - * @class Ext.grid.GroupingView - * @extends Ext.grid.GridView - * Adds the ability for single level grouping to the grid. A {@link Ext.data.GroupingStore GroupingStore} - * must be used to enable grouping. Some grouping characteristics may also be configured at the - * {@link Ext.grid.Column Column level}
- *
{@link Ext.grid.Column#emptyGroupText emptyGroupText}
- * {@link Ext.grid.Column#groupable groupable} - * {@link Ext.grid.Column#groupName groupName} - * {@link Ext.grid.Column#groupRender groupRender} - *
- * Sample usage: - * -var grid = new Ext.grid.GridPanel({ - // A groupingStore is required for a GroupingView - store: new {@link Ext.data.GroupingStore}({ - autoDestroy: true, - reader: reader, - data: xg.dummyData, - sortInfo: {field: 'company', direction: 'ASC'}, - {@link Ext.data.GroupingStore#groupOnSort groupOnSort}: true, - {@link Ext.data.GroupingStore#remoteGroup remoteGroup}: true, - {@link Ext.data.GroupingStore#groupField groupField}: 'industry' - }), - colModel: new {@link Ext.grid.ColumnModel}({ - columns:[ - {id:'company',header: 'Company', width: 60, dataIndex: 'company'}, - // {@link Ext.grid.Column#groupable groupable}, {@link Ext.grid.Column#groupName groupName}, {@link Ext.grid.Column#groupRender groupRender} are also configurable at column level - {header: 'Price', renderer: Ext.util.Format.usMoney, dataIndex: 'price', {@link Ext.grid.Column#groupable groupable}: false}, - {header: 'Change', dataIndex: 'change', renderer: Ext.util.Format.usMoney}, - {header: 'Industry', dataIndex: 'industry'}, - {header: 'Last Updated', renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'lastChange'} - ], - defaults: { - sortable: true, - menuDisabled: false, - width: 20 - } - }), - - view: new Ext.grid.GroupingView({ - {@link Ext.grid.GridView#forceFit forceFit}: true, - // custom grouping text template to display the number of items per group - {@link #groupTextTpl}: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Items" : "Item"]})' - }), - - frame:true, - width: 700, - height: 450, - collapsible: true, - animCollapse: false, - title: 'Grouping Example', - iconCls: 'icon-grid', - renderTo: document.body -}); - * - * @constructor - * @param {Object} config - */ -Ext.grid.GroupingView = Ext.extend(Ext.grid.GridView, { - - /** - * @cfg {String} groupByText Text displayed in the grid header menu for grouping by a column - * (defaults to 'Group By This Field'). - */ - groupByText : 'Group By This Field', - /** - * @cfg {String} showGroupsText Text displayed in the grid header for enabling/disabling grouping - * (defaults to 'Show in Groups'). - */ - showGroupsText : 'Show in Groups', - /** - * @cfg {Boolean} hideGroupedColumn true to hide the column that is currently grouped (defaults to false) - */ - hideGroupedColumn : false, - /** - * @cfg {Boolean} showGroupName If true will display a prefix plus a ': ' before the group field value - * in the group header line. The prefix will consist of the {@link Ext.grid.Column#groupName groupName} - * (or the configured {@link Ext.grid.Column#header header} if not provided) configured in the - * {@link Ext.grid.Column} for each set of grouped rows (defaults to true). - */ - showGroupName : true, - /** - * @cfg {Boolean} startCollapsed true to start all groups collapsed (defaults to false) - */ - startCollapsed : false, - /** - * @cfg {Boolean} enableGrouping false to disable grouping functionality (defaults to true) - */ - enableGrouping : true, - /** - * @cfg {Boolean} enableGroupingMenu true to enable the grouping control in the column menu (defaults to true) - */ - enableGroupingMenu : true, - /** - * @cfg {Boolean} enableNoGroups true to allow the user to turn off grouping (defaults to true) - */ - enableNoGroups : true, - /** - * @cfg {String} emptyGroupText The text to display when there is an empty group value (defaults to '(None)'). - * May also be specified per column, see {@link Ext.grid.Column}.{@link Ext.grid.Column#emptyGroupText emptyGroupText}. - */ - emptyGroupText : '(None)', - /** - * @cfg {Boolean} ignoreAdd true to skip refreshing the view when new rows are added (defaults to false) - */ - ignoreAdd : false, - /** - * @cfg {String} groupTextTpl The template used to render the group header (defaults to '{text}'). - * This is used to format an object which contains the following properties: - * - * group : StringThe rendered value of the group field. - * By default this is the unchanged value of the group field. If a {@link Ext.grid.Column#groupRenderer groupRenderer} - * is specified, it is the result of a call to that function. - * gvalue : ObjectThe raw value of the group field. - * text : StringThe configured header (as described in {@link #showGroupName}) - * if {@link #showGroupName} is true) plus the rendered group field value. - * groupId : StringA unique, generated ID which is applied to the - * View Element which contains the group. - * startRow : NumberThe row index of the Record which caused group change. - * rs : ArrayContains a single element: The Record providing the data - * for the row which caused group change. - * cls : StringThe generated class name string to apply to the group header Element. - * style : StringThe inline style rules to apply to the group header Element. - * - * See {@link Ext.XTemplate} for information on how to format data using a template. Possible usage: -var grid = new Ext.grid.GridPanel({ - ... - view: new Ext.grid.GroupingView({ - groupTextTpl: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Items" : "Item"]})' - }), -}); - * - */ - groupTextTpl : '{text}', - - /** - * @cfg {String} groupMode Indicates how to construct the group identifier. 'value' constructs the id using - * raw value, 'display' constructs the id using the rendered value. Defaults to 'value'. - */ - groupMode: 'value', - - /** - * @cfg {Function} groupRenderer This property must be configured in the {@link Ext.grid.Column} for - * each column. - */ - - // private - gidSeed : 1000, - - // private - initTemplates : function(){ - Ext.grid.GroupingView.superclass.initTemplates.call(this); - this.state = {}; - - var sm = this.grid.getSelectionModel(); - sm.on(sm.selectRow ? 'beforerowselect' : 'beforecellselect', - this.onBeforeRowSelect, this); - - if(!this.startGroup){ - this.startGroup = new Ext.XTemplate( - '', - '', this.groupTextTpl ,'', - '' - ); - } - this.startGroup.compile(); - if(!this.endGroup){ - this.endGroup = ''; - } - - this.endGroup = '
'; - }, - - // private - findGroup : function(el){ - return Ext.fly(el).up('.x-grid-group', this.mainBody.dom); - }, - - // private - getGroups : function(){ - return this.hasRows() ? this.mainBody.dom.childNodes : []; - }, - - // private - onAdd : function(){ - if(this.canGroup() && !this.ignoreAdd){ - var ss = this.getScrollState(); - this.refresh(); - this.restoreScroll(ss); - }else if(!this.canGroup()){ - Ext.grid.GroupingView.superclass.onAdd.apply(this, arguments); - } - }, - - // private - onRemove : function(ds, record, index, isUpdate){ - Ext.grid.GroupingView.superclass.onRemove.apply(this, arguments); - var g = document.getElementById(record._groupId); - if(g && g.childNodes[1].childNodes.length < 1){ - Ext.removeNode(g); - } - this.applyEmptyText(); - }, - - // private - refreshRow : function(record){ - if(this.ds.getCount()==1){ - this.refresh(); - }else{ - this.isUpdating = true; - Ext.grid.GroupingView.superclass.refreshRow.apply(this, arguments); - this.isUpdating = false; - } - }, - - // private - beforeMenuShow : function(){ - var item, items = this.hmenu.items, disabled = this.cm.config[this.hdCtxIndex].groupable === false; - if((item = items.get('groupBy'))){ - item.setDisabled(disabled); - } - if((item = items.get('showGroups'))){ - item.setDisabled(disabled); - item.setChecked(this.enableGrouping, true); - } - }, - - // private - renderUI : function(){ - Ext.grid.GroupingView.superclass.renderUI.call(this); - this.mainBody.on('mousedown', this.interceptMouse, this); - - if(this.enableGroupingMenu && this.hmenu){ - this.hmenu.add('-',{ - itemId:'groupBy', - text: this.groupByText, - handler: this.onGroupByClick, - scope: this, - iconCls:'x-group-by-icon' - }); - if(this.enableNoGroups){ - this.hmenu.add({ - itemId:'showGroups', - text: this.showGroupsText, - checked: true, - checkHandler: this.onShowGroupsClick, - scope: this - }); - } - this.hmenu.on('beforeshow', this.beforeMenuShow, this); - } - }, - - processEvent: function(name, e){ - var hd = e.getTarget('.x-grid-group-hd', this.mainBody); - if(hd){ - // group value is at the end of the string - var field = this.getGroupField(), - prefix = this.getPrefix(field), - groupValue = hd.id.substring(prefix.length); - - // remove trailing '-hd' - groupValue = groupValue.substr(0, groupValue.length - 3); - if(groupValue){ - this.grid.fireEvent('group' + name, this.grid, field, groupValue, e); - } - } - - }, - - // private - onGroupByClick : function(){ - this.enableGrouping = true; - this.grid.store.groupBy(this.cm.getDataIndex(this.hdCtxIndex)); - this.grid.fireEvent('groupchange', this, this.grid.store.getGroupState()); - this.beforeMenuShow(); // Make sure the checkboxes get properly set when changing groups - this.refresh(); - }, - - // private - onShowGroupsClick : function(mi, checked){ - this.enableGrouping = checked; - if(checked){ - this.onGroupByClick(); - }else{ - this.grid.store.clearGrouping(); - this.grid.fireEvent('groupchange', this, null); - } - }, - - /** - * Toggle the group that contains the specific row. - * @param {Number} rowIndex The row inside the group - * @param {Boolean} expanded (optional) - */ - toggleRowIndex : function(rowIndex, expanded){ - if(!this.canGroup()){ - return; - } - var row = this.getRow(rowIndex); - if(row){ - this.toggleGroup(this.findGroup(row), expanded); - } - }, - - /** - * Toggles the specified group if no value is passed, otherwise sets the expanded state of the group to the value passed. - * @param {String} groupId The groupId assigned to the group (see getGroupId) - * @param {Boolean} expanded (optional) - */ - toggleGroup : function(group, expanded){ - var gel = Ext.get(group); - expanded = Ext.isDefined(expanded) ? expanded : gel.hasClass('x-grid-group-collapsed'); - if(this.state[gel.id] !== expanded){ - this.grid.stopEditing(true); - this.state[gel.id] = expanded; - gel[expanded ? 'removeClass' : 'addClass']('x-grid-group-collapsed'); - } - }, - - /** - * Toggles all groups if no value is passed, otherwise sets the expanded state of all groups to the value passed. - * @param {Boolean} expanded (optional) - */ - toggleAllGroups : function(expanded){ - var groups = this.getGroups(); - for(var i = 0, len = groups.length; i < len; i++){ - this.toggleGroup(groups[i], expanded); - } - }, - - /** - * Expands all grouped rows. - */ - expandAllGroups : function(){ - this.toggleAllGroups(true); - }, - - /** - * Collapses all grouped rows. - */ - collapseAllGroups : function(){ - this.toggleAllGroups(false); - }, - - // private - interceptMouse : function(e){ - var hd = e.getTarget('.x-grid-group-hd', this.mainBody); - if(hd){ - e.stopEvent(); - this.toggleGroup(hd.parentNode); - } - }, - - // private - getGroup : function(v, r, groupRenderer, rowIndex, colIndex, ds){ - var g = groupRenderer ? groupRenderer(v, {}, r, rowIndex, colIndex, ds) : String(v); - if(g === '' || g === ' '){ - g = this.cm.config[colIndex].emptyGroupText || this.emptyGroupText; - } - return g; - }, - - // private - getGroupField : function(){ - return this.grid.store.getGroupState(); - }, - - // private - afterRender : function(){ - if(!this.ds || !this.cm){ - return; - } - Ext.grid.GroupingView.superclass.afterRender.call(this); - if(this.grid.deferRowRender){ - this.updateGroupWidths(); - } - }, - - // private - renderRows : function(){ - var groupField = this.getGroupField(); - var eg = !!groupField; - // if they turned off grouping and the last grouped field is hidden - if(this.hideGroupedColumn) { - var colIndex = this.cm.findColumnIndex(groupField), - hasLastGroupField = Ext.isDefined(this.lastGroupField); - if(!eg && hasLastGroupField){ - this.mainBody.update(''); - this.cm.setHidden(this.cm.findColumnIndex(this.lastGroupField), false); - delete this.lastGroupField; - }else if (eg && !hasLastGroupField){ - this.lastGroupField = groupField; - this.cm.setHidden(colIndex, true); - }else if (eg && hasLastGroupField && groupField !== this.lastGroupField) { - this.mainBody.update(''); - var oldIndex = this.cm.findColumnIndex(this.lastGroupField); - this.cm.setHidden(oldIndex, false); - this.lastGroupField = groupField; - this.cm.setHidden(colIndex, true); - } - } - return Ext.grid.GroupingView.superclass.renderRows.apply( - this, arguments); - }, - - // private - doRender : function(cs, rs, ds, startRow, colCount, stripe){ - if(rs.length < 1){ - return ''; - } - - if(!this.canGroup() || this.isUpdating){ - return Ext.grid.GroupingView.superclass.doRender.apply( - this, arguments); - } - - var groupField = this.getGroupField(), - colIndex = this.cm.findColumnIndex(groupField), - g, - gstyle = 'width:' + this.getTotalWidth() + ';', - cfg = this.cm.config[colIndex], - groupRenderer = cfg.groupRenderer || cfg.renderer, - prefix = this.showGroupName ? (cfg.groupName || cfg.header)+': ' : '', - groups = [], - curGroup, i, len, gid; - - for(i = 0, len = rs.length; i < len; i++){ - var rowIndex = startRow + i, - r = rs[i], - gvalue = r.data[groupField]; - - g = this.getGroup(gvalue, r, groupRenderer, rowIndex, colIndex, ds); - if(!curGroup || curGroup.group != g){ - gid = this.constructId(gvalue, groupField, colIndex); - // if state is defined use it, however state is in terms of expanded - // so negate it, otherwise use the default. - this.state[gid] = !(Ext.isDefined(this.state[gid]) ? !this.state[gid] : this.startCollapsed); - curGroup = { - group: g, - gvalue: gvalue, - text: prefix + g, - groupId: gid, - startRow: rowIndex, - rs: [r], - cls: this.state[gid] ? '' : 'x-grid-group-collapsed', - style: gstyle - }; - groups.push(curGroup); - }else{ - curGroup.rs.push(r); - } - r._groupId = gid; - } - - var buf = []; - for(i = 0, len = groups.length; i < len; i++){ - g = groups[i]; - this.doGroupStart(buf, g, cs, ds, colCount); - buf[buf.length] = Ext.grid.GroupingView.superclass.doRender.call( - this, cs, g.rs, ds, g.startRow, colCount, stripe); - - this.doGroupEnd(buf, g, cs, ds, colCount); - } - return buf.join(''); - }, - - /** - * Dynamically tries to determine the groupId of a specific value - * @param {String} value - * @return {String} The group id - */ - getGroupId : function(value){ - var field = this.getGroupField(); - return this.constructId(value, field, this.cm.findColumnIndex(field)); - }, - - // private - constructId : function(value, field, idx){ - var cfg = this.cm.config[idx], - groupRenderer = cfg.groupRenderer || cfg.renderer, - val = (this.groupMode == 'value') ? value : this.getGroup(value, {data:{}}, groupRenderer, 0, idx, this.ds); - - return this.getPrefix(field) + Ext.util.Format.htmlEncode(val); - }, - - // private - canGroup : function(){ - return this.enableGrouping && !!this.getGroupField(); - }, - - // private - getPrefix: function(field){ - return this.grid.getGridEl().id + '-gp-' + field + '-'; - }, - - // private - doGroupStart : function(buf, g, cs, ds, colCount){ - buf[buf.length] = this.startGroup.apply(g); - }, - - // private - doGroupEnd : function(buf, g, cs, ds, colCount){ - buf[buf.length] = this.endGroup; - }, - - // private - getRows : function(){ - if(!this.canGroup()){ - return Ext.grid.GroupingView.superclass.getRows.call(this); - } - var r = []; - var g, gs = this.getGroups(); - for(var i = 0, len = gs.length; i < len; i++){ - g = gs[i].childNodes[1].childNodes; - for(var j = 0, jlen = g.length; j < jlen; j++){ - r[r.length] = g[j]; - } - } - return r; - }, - - // private - updateGroupWidths : function(){ - if(!this.canGroup() || !this.hasRows()){ - return; - } - var tw = Math.max(this.cm.getTotalWidth(), this.el.dom.offsetWidth-this.getScrollOffset()) +'px'; - var gs = this.getGroups(); - for(var i = 0, len = gs.length; i < len; i++){ - gs[i].firstChild.style.width = tw; - } - }, - - // private - onColumnWidthUpdated : function(col, w, tw){ - Ext.grid.GroupingView.superclass.onColumnWidthUpdated.call(this, col, w, tw); - this.updateGroupWidths(); - }, - - // private - onAllColumnWidthsUpdated : function(ws, tw){ - Ext.grid.GroupingView.superclass.onAllColumnWidthsUpdated.call(this, ws, tw); - this.updateGroupWidths(); - }, - - // private - onColumnHiddenUpdated : function(col, hidden, tw){ - Ext.grid.GroupingView.superclass.onColumnHiddenUpdated.call(this, col, hidden, tw); - this.updateGroupWidths(); - }, - - // private - onLayout : function(){ - this.updateGroupWidths(); - }, - - // private - onBeforeRowSelect : function(sm, rowIndex){ - this.toggleRowIndex(rowIndex, true); - } -}); -// private +/** + * @class Ext.grid.GroupingView + * @extends Ext.grid.GridView + * Adds the ability for single level grouping to the grid. A {@link Ext.data.GroupingStore GroupingStore} + * must be used to enable grouping. Some grouping characteristics may also be configured at the + * {@link Ext.grid.Column Column level} + * {@link Ext.grid.Column#emptyGroupText emptyGroupText} + * {@link Ext.grid.Column#groupable groupable} + * {@link Ext.grid.Column#groupName groupName} + * {@link Ext.grid.Column#groupRender groupRender} + * + * Sample usage: + * +var grid = new Ext.grid.GridPanel({ + // A groupingStore is required for a GroupingView + store: new {@link Ext.data.GroupingStore}({ + autoDestroy: true, + reader: reader, + data: xg.dummyData, + sortInfo: {field: 'company', direction: 'ASC'}, + {@link Ext.data.GroupingStore#groupOnSort groupOnSort}: true, + {@link Ext.data.GroupingStore#remoteGroup remoteGroup}: true, + {@link Ext.data.GroupingStore#groupField groupField}: 'industry' + }), + colModel: new {@link Ext.grid.ColumnModel}({ + columns:[ + {id:'company',header: 'Company', width: 60, dataIndex: 'company'}, + // {@link Ext.grid.Column#groupable groupable}, {@link Ext.grid.Column#groupName groupName}, {@link Ext.grid.Column#groupRender groupRender} are also configurable at column level + {header: 'Price', renderer: Ext.util.Format.usMoney, dataIndex: 'price', {@link Ext.grid.Column#groupable groupable}: false}, + {header: 'Change', dataIndex: 'change', renderer: Ext.util.Format.usMoney}, + {header: 'Industry', dataIndex: 'industry'}, + {header: 'Last Updated', renderer: Ext.util.Format.dateRenderer('m/d/Y'), dataIndex: 'lastChange'} + ], + defaults: { + sortable: true, + menuDisabled: false, + width: 20 + } + }), + + view: new Ext.grid.GroupingView({ + {@link Ext.grid.GridView#forceFit forceFit}: true, + // custom grouping text template to display the number of items per group + {@link #groupTextTpl}: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Items" : "Item"]})' + }), + + frame:true, + width: 700, + height: 450, + collapsible: true, + animCollapse: false, + title: 'Grouping Example', + iconCls: 'icon-grid', + renderTo: document.body +}); + * + * @constructor + * @param {Object} config + */ +Ext.grid.GroupingView = Ext.extend(Ext.grid.GridView, { + + /** + * @cfg {String} groupByText Text displayed in the grid header menu for grouping by a column + * (defaults to 'Group By This Field'). + */ + groupByText : 'Group By This Field', + /** + * @cfg {String} showGroupsText Text displayed in the grid header for enabling/disabling grouping + * (defaults to 'Show in Groups'). + */ + showGroupsText : 'Show in Groups', + /** + * @cfg {Boolean} hideGroupedColumn true to hide the column that is currently grouped (defaults to false) + */ + hideGroupedColumn : false, + /** + * @cfg {Boolean} showGroupName If true will display a prefix plus a ': ' before the group field value + * in the group header line. The prefix will consist of the {@link Ext.grid.Column#groupName groupName} + * (or the configured {@link Ext.grid.Column#header header} if not provided) configured in the + * {@link Ext.grid.Column} for each set of grouped rows (defaults to true). + */ + showGroupName : true, + /** + * @cfg {Boolean} startCollapsed true to start all groups collapsed (defaults to false) + */ + startCollapsed : false, + /** + * @cfg {Boolean} enableGrouping false to disable grouping functionality (defaults to true) + */ + enableGrouping : true, + /** + * @cfg {Boolean} enableGroupingMenu true to enable the grouping control in the column menu (defaults to true) + */ + enableGroupingMenu : true, + /** + * @cfg {Boolean} enableNoGroups true to allow the user to turn off grouping (defaults to true) + */ + enableNoGroups : true, + /** + * @cfg {String} emptyGroupText The text to display when there is an empty group value (defaults to '(None)'). + * May also be specified per column, see {@link Ext.grid.Column}.{@link Ext.grid.Column#emptyGroupText emptyGroupText}. + */ + emptyGroupText : '(None)', + /** + * @cfg {Boolean} ignoreAdd true to skip refreshing the view when new rows are added (defaults to false) + */ + ignoreAdd : false, + /** + * @cfg {String} groupTextTpl The template used to render the group header (defaults to '{text}'). + * This is used to format an object which contains the following properties: + * + * group : StringThe rendered value of the group field. + * By default this is the unchanged value of the group field. If a {@link Ext.grid.Column#groupRenderer groupRenderer} + * is specified, it is the result of a call to that function. + * gvalue : ObjectThe raw value of the group field. + * text : StringThe configured header (as described in {@link #showGroupName}) + * if {@link #showGroupName} is true) plus the rendered group field value. + * groupId : StringA unique, generated ID which is applied to the + * View Element which contains the group. + * startRow : NumberThe row index of the Record which caused group change. + * rs : ArrayContains a single element: The Record providing the data + * for the row which caused group change. + * cls : StringThe generated class name string to apply to the group header Element. + * style : StringThe inline style rules to apply to the group header Element. + * + * See {@link Ext.XTemplate} for information on how to format data using a template. Possible usage: +var grid = new Ext.grid.GridPanel({ + ... + view: new Ext.grid.GroupingView({ + groupTextTpl: '{text} ({[values.rs.length]} {[values.rs.length > 1 ? "Items" : "Item"]})' + }), +}); + * + */ + groupTextTpl : '{text}', + + /** + * @cfg {String} groupMode Indicates how to construct the group identifier. 'value' constructs the id using + * raw value, 'display' constructs the id using the rendered value. Defaults to 'value'. + */ + groupMode: 'value', + + /** + * @cfg {Function} groupRenderer This property must be configured in the {@link Ext.grid.Column} for + * each column. + */ + + // private + initTemplates : function(){ + Ext.grid.GroupingView.superclass.initTemplates.call(this); + this.state = {}; + + var sm = this.grid.getSelectionModel(); + sm.on(sm.selectRow ? 'beforerowselect' : 'beforecellselect', + this.onBeforeRowSelect, this); + + if(!this.startGroup){ + this.startGroup = new Ext.XTemplate( + '', + '', this.groupTextTpl ,'', + '' + ); + } + this.startGroup.compile(); + + if (!this.endGroup) { + this.endGroup = ''; + } + }, + + // private + findGroup : function(el){ + return Ext.fly(el).up('.x-grid-group', this.mainBody.dom); + }, + + // private + getGroups : function(){ + return this.hasRows() ? this.mainBody.dom.childNodes : []; + }, + + // private + onAdd : function(ds, records, index) { + if (this.canGroup() && !this.ignoreAdd) { + var ss = this.getScrollState(); + this.fireEvent('beforerowsinserted', ds, index, index + (records.length-1)); + this.refresh(); + this.restoreScroll(ss); + this.fireEvent('rowsinserted', ds, index, index + (records.length-1)); + } else if (!this.canGroup()) { + Ext.grid.GroupingView.superclass.onAdd.apply(this, arguments); + } + }, + + // private + onRemove : function(ds, record, index, isUpdate){ + Ext.grid.GroupingView.superclass.onRemove.apply(this, arguments); + var g = document.getElementById(record._groupId); + if(g && g.childNodes[1].childNodes.length < 1){ + Ext.removeNode(g); + } + this.applyEmptyText(); + }, + + // private + refreshRow : function(record){ + if(this.ds.getCount()==1){ + this.refresh(); + }else{ + this.isUpdating = true; + Ext.grid.GroupingView.superclass.refreshRow.apply(this, arguments); + this.isUpdating = false; + } + }, + + // private + beforeMenuShow : function(){ + var item, items = this.hmenu.items, disabled = this.cm.config[this.hdCtxIndex].groupable === false; + if((item = items.get('groupBy'))){ + item.setDisabled(disabled); + } + if((item = items.get('showGroups'))){ + item.setDisabled(disabled); + item.setChecked(this.enableGrouping, true); + } + }, + + // private + renderUI : function(){ + Ext.grid.GroupingView.superclass.renderUI.call(this); + this.mainBody.on('mousedown', this.interceptMouse, this); + + if(this.enableGroupingMenu && this.hmenu){ + this.hmenu.add('-',{ + itemId:'groupBy', + text: this.groupByText, + handler: this.onGroupByClick, + scope: this, + iconCls:'x-group-by-icon' + }); + if(this.enableNoGroups){ + this.hmenu.add({ + itemId:'showGroups', + text: this.showGroupsText, + checked: true, + checkHandler: this.onShowGroupsClick, + scope: this + }); + } + this.hmenu.on('beforeshow', this.beforeMenuShow, this); + } + }, + + processEvent: function(name, e){ + Ext.grid.GroupingView.superclass.processEvent.call(this, name, e); + var hd = e.getTarget('.x-grid-group-hd', this.mainBody); + if(hd){ + // group value is at the end of the string + var field = this.getGroupField(), + prefix = this.getPrefix(field), + groupValue = hd.id.substring(prefix.length); + + // remove trailing '-hd' + groupValue = groupValue.substr(0, groupValue.length - 3); + if(groupValue){ + this.grid.fireEvent('group' + name, this.grid, field, groupValue, e); + } + } + + }, + + // private + onGroupByClick : function(){ + this.enableGrouping = true; + this.grid.store.groupBy(this.cm.getDataIndex(this.hdCtxIndex)); + this.grid.fireEvent('groupchange', this, this.grid.store.getGroupState()); + this.beforeMenuShow(); // Make sure the checkboxes get properly set when changing groups + this.refresh(); + }, + + // private + onShowGroupsClick : function(mi, checked){ + this.enableGrouping = checked; + if(checked){ + this.onGroupByClick(); + }else{ + this.grid.store.clearGrouping(); + this.grid.fireEvent('groupchange', this, null); + } + }, + + /** + * Toggle the group that contains the specific row. + * @param {Number} rowIndex The row inside the group + * @param {Boolean} expanded (optional) + */ + toggleRowIndex : function(rowIndex, expanded){ + if(!this.canGroup()){ + return; + } + var row = this.getRow(rowIndex); + if(row){ + this.toggleGroup(this.findGroup(row), expanded); + } + }, + + /** + * Toggles the specified group if no value is passed, otherwise sets the expanded state of the group to the value passed. + * @param {String} groupId The groupId assigned to the group (see getGroupId) + * @param {Boolean} expanded (optional) + */ + toggleGroup : function(group, expanded){ + var gel = Ext.get(group); + expanded = Ext.isDefined(expanded) ? expanded : gel.hasClass('x-grid-group-collapsed'); + if(this.state[gel.id] !== expanded){ + this.grid.stopEditing(true); + this.state[gel.id] = expanded; + gel[expanded ? 'removeClass' : 'addClass']('x-grid-group-collapsed'); + } + }, + + /** + * Toggles all groups if no value is passed, otherwise sets the expanded state of all groups to the value passed. + * @param {Boolean} expanded (optional) + */ + toggleAllGroups : function(expanded){ + var groups = this.getGroups(); + for(var i = 0, len = groups.length; i < len; i++){ + this.toggleGroup(groups[i], expanded); + } + }, + + /** + * Expands all grouped rows. + */ + expandAllGroups : function(){ + this.toggleAllGroups(true); + }, + + /** + * Collapses all grouped rows. + */ + collapseAllGroups : function(){ + this.toggleAllGroups(false); + }, + + // private + interceptMouse : function(e){ + var hd = e.getTarget('.x-grid-group-hd', this.mainBody); + if(hd){ + e.stopEvent(); + this.toggleGroup(hd.parentNode); + } + }, + + // private + getGroup : function(v, r, groupRenderer, rowIndex, colIndex, ds){ + var g = groupRenderer ? groupRenderer(v, {}, r, rowIndex, colIndex, ds) : String(v); + if(g === '' || g === ' '){ + g = this.cm.config[colIndex].emptyGroupText || this.emptyGroupText; + } + return g; + }, + + // private + getGroupField : function(){ + return this.grid.store.getGroupState(); + }, + + // private + afterRender : function(){ + if(!this.ds || !this.cm){ + return; + } + Ext.grid.GroupingView.superclass.afterRender.call(this); + if(this.grid.deferRowRender){ + this.updateGroupWidths(); + } + }, + + // private + renderRows : function(){ + var groupField = this.getGroupField(); + var eg = !!groupField; + // if they turned off grouping and the last grouped field is hidden + if(this.hideGroupedColumn) { + var colIndex = this.cm.findColumnIndex(groupField), + hasLastGroupField = Ext.isDefined(this.lastGroupField); + if(!eg && hasLastGroupField){ + this.mainBody.update(''); + this.cm.setHidden(this.cm.findColumnIndex(this.lastGroupField), false); + delete this.lastGroupField; + }else if (eg && !hasLastGroupField){ + this.lastGroupField = groupField; + this.cm.setHidden(colIndex, true); + }else if (eg && hasLastGroupField && groupField !== this.lastGroupField) { + this.mainBody.update(''); + var oldIndex = this.cm.findColumnIndex(this.lastGroupField); + this.cm.setHidden(oldIndex, false); + this.lastGroupField = groupField; + this.cm.setHidden(colIndex, true); + } + } + return Ext.grid.GroupingView.superclass.renderRows.apply( + this, arguments); + }, + + // private + doRender : function(cs, rs, ds, startRow, colCount, stripe){ + if(rs.length < 1){ + return ''; + } + + if(!this.canGroup() || this.isUpdating){ + return Ext.grid.GroupingView.superclass.doRender.apply(this, arguments); + } + + var groupField = this.getGroupField(), + colIndex = this.cm.findColumnIndex(groupField), + g, + gstyle = 'width:' + this.getTotalWidth() + ';', + cfg = this.cm.config[colIndex], + groupRenderer = cfg.groupRenderer || cfg.renderer, + prefix = this.showGroupName ? (cfg.groupName || cfg.header)+': ' : '', + groups = [], + curGroup, i, len, gid; + + for(i = 0, len = rs.length; i < len; i++){ + var rowIndex = startRow + i, + r = rs[i], + gvalue = r.data[groupField]; + + g = this.getGroup(gvalue, r, groupRenderer, rowIndex, colIndex, ds); + if(!curGroup || curGroup.group != g){ + gid = this.constructId(gvalue, groupField, colIndex); + // if state is defined use it, however state is in terms of expanded + // so negate it, otherwise use the default. + this.state[gid] = !(Ext.isDefined(this.state[gid]) ? !this.state[gid] : this.startCollapsed); + curGroup = { + group: g, + gvalue: gvalue, + text: prefix + g, + groupId: gid, + startRow: rowIndex, + rs: [r], + cls: this.state[gid] ? '' : 'x-grid-group-collapsed', + style: gstyle + }; + groups.push(curGroup); + }else{ + curGroup.rs.push(r); + } + r._groupId = gid; + } + + var buf = []; + for(i = 0, len = groups.length; i < len; i++){ + g = groups[i]; + this.doGroupStart(buf, g, cs, ds, colCount); + buf[buf.length] = Ext.grid.GroupingView.superclass.doRender.call( + this, cs, g.rs, ds, g.startRow, colCount, stripe); + + this.doGroupEnd(buf, g, cs, ds, colCount); + } + return buf.join(''); + }, + + /** + * Dynamically tries to determine the groupId of a specific value + * @param {String} value + * @return {String} The group id + */ + getGroupId : function(value){ + var field = this.getGroupField(); + return this.constructId(value, field, this.cm.findColumnIndex(field)); + }, + + // private + constructId : function(value, field, idx){ + var cfg = this.cm.config[idx], + groupRenderer = cfg.groupRenderer || cfg.renderer, + val = (this.groupMode == 'value') ? value : this.getGroup(value, {data:{}}, groupRenderer, 0, idx, this.ds); + + return this.getPrefix(field) + Ext.util.Format.htmlEncode(val); + }, + + // private + canGroup : function(){ + return this.enableGrouping && !!this.getGroupField(); + }, + + // private + getPrefix: function(field){ + return this.grid.getGridEl().id + '-gp-' + field + '-'; + }, + + // private + doGroupStart : function(buf, g, cs, ds, colCount){ + buf[buf.length] = this.startGroup.apply(g); + }, + + // private + doGroupEnd : function(buf, g, cs, ds, colCount){ + buf[buf.length] = this.endGroup; + }, + + // private + getRows : function(){ + if(!this.canGroup()){ + return Ext.grid.GroupingView.superclass.getRows.call(this); + } + var r = [], + gs = this.getGroups(), + g, + i = 0, + len = gs.length, + j, + jlen; + for(; i < len; ++i){ + g = gs[i].childNodes[1]; + if(g){ + g = g.childNodes; + for(j = 0, jlen = g.length; j < jlen; ++j){ + r[r.length] = g[j]; + } + } + } + return r; + }, + + // private + updateGroupWidths : function(){ + if(!this.canGroup() || !this.hasRows()){ + return; + } + var tw = Math.max(this.cm.getTotalWidth(), this.el.dom.offsetWidth-this.getScrollOffset()) +'px'; + var gs = this.getGroups(); + for(var i = 0, len = gs.length; i < len; i++){ + gs[i].firstChild.style.width = tw; + } + }, + + // private + onColumnWidthUpdated : function(col, w, tw){ + Ext.grid.GroupingView.superclass.onColumnWidthUpdated.call(this, col, w, tw); + this.updateGroupWidths(); + }, + + // private + onAllColumnWidthsUpdated : function(ws, tw){ + Ext.grid.GroupingView.superclass.onAllColumnWidthsUpdated.call(this, ws, tw); + this.updateGroupWidths(); + }, + + // private + onColumnHiddenUpdated : function(col, hidden, tw){ + Ext.grid.GroupingView.superclass.onColumnHiddenUpdated.call(this, col, hidden, tw); + this.updateGroupWidths(); + }, + + // private + onLayout : function(){ + this.updateGroupWidths(); + }, + + // private + onBeforeRowSelect : function(sm, rowIndex){ + this.toggleRowIndex(rowIndex, true); + } +}); +// private Ext.grid.GroupingView.GROUP_ID = 1000; \ No newline at end of file

Element Selectors:

Attribute Selectors:

Pseudo Classes:

CSS Value Selectors:

Element Selectors:

Attribute Selectors:

Pseudo Classes:

CSS Value Selectors:

File Uploads

File Uploads

', Date.getShortMonthName(i), '	', Date.getShortMonthName(i + 6), '