X-Git-Url: http://git.ithinksw.org/extjs.git/blobdiff_plain/0494b8d9b9bb03ab6c22b34dae81261e3cd7e3e6..6746dc89c47ed01b165cc1152533605f97eb8e8d:/ext-all-debug-w-comments.js
diff --git a/ext-all-debug-w-comments.js b/ext-all-debug-w-comments.js
index fde95ef9..c4e2c6b3 100644
--- a/ext-all-debug-w-comments.js
+++ b/ext-all-debug-w-comments.js
@@ -1,78773 +1,128800 @@
-/*!
- * Ext JS Library 3.3.1
- * Copyright(c) 2006-2010 Sencha Inc.
- * licensing@sencha.com
- * http://www.sencha.com/license
- */
-(function(){
+/*
-var EXTUTIL = Ext.util,
- EACH = Ext.each,
- TRUE = true,
- FALSE = false;
-/**
- * @class Ext.util.Observable
- * Base class that provides a common interface for publishing events. Subclasses are expected to
- * to have a property "events" with all the events defined, and, optionally, a property "listeners"
- * with configured listeners defined.
- * For example:
- *
-Employee = Ext.extend(Ext.util.Observable, {
- constructor: function(config){
- this.name = config.name;
- this.addEvents({
- "fired" : true,
- "quit" : true
- });
+This file is part of Ext JS 4
- // Copy configured listeners into *this* object so that the base class's
- // constructor will add them.
- this.listeners = config.listeners;
+Copyright (c) 2011 Sencha Inc
- // Call our superclass constructor to complete construction process.
- Employee.superclass.constructor.call(this, config)
- }
-});
-
- * This could then be used like this:
-var newEmployee = new Employee({
- name: employeeName,
- listeners: {
- quit: function() {
- // By default, "this" will be the object that fired the event.
- alert(this.name + " has quit!");
- }
- }
-});
-
A config object containing one or more event handlers to be added to this
- * object during initialization. This should be a valid listeners config object as specified in the
- * {@link #addListener} example for attaching multiple handlers at once.
- *
DOM events from ExtJs {@link Ext.Component Components}
- *
While some ExtJs Component classes export selected DOM events (e.g. "click", "mouseover" etc), this
- * is usually only done when extra value can be added. For example the {@link Ext.DataView DataView}'s
- * {@link Ext.DataView#click click} event passing the node clicked on. To access DOM
- * events directly from a Component's HTMLElement, listeners must be added to the {@link Ext.Component#getEl Element} after the Component
- * has been rendered. A plugin can simplify this step:
-// Plugin is configured with a listeners config object.
-// The Component is appended to the argument list of all handler functions.
-Ext.DomObserver = Ext.extend(Object, {
- constructor: function(config) {
- this.listeners = config.listeners ? config.listeners : config;
- },
+Contact: http://www.sencha.com/contact
- // Component passes itself into plugin's init method
- init: function(c) {
- var p, l = this.listeners;
- for (p in l) {
- if (Ext.isFunction(l[p])) {
- l[p] = this.createHandler(l[p], c);
- } else {
- l[p].fn = this.createHandler(l[p].fn, c);
- }
- }
+GNU General Public License Usage
+This file may be used under the terms of the GNU General Public License version 3.0 as published by the Free Software Foundation and appearing in the file LICENSE included in the packaging of this file. Please review the following information to ensure the GNU General Public License version 3.0 requirements will be met: http://www.gnu.org/copyleft/gpl.html.
- // Add the listeners to the Element immediately following the render call
- c.render = c.render.{@link Function#createSequence createSequence}(function() {
- var e = c.getEl();
- if (e) {
- e.on(l);
- }
- });
- },
+If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact.
- createHandler: function(fn, c) {
- return function(e) {
- fn.call(this, e, c);
- };
+*/
+/**
+ * @class Ext
+ * @singleton
+ */
+(function() {
+ var global = this,
+ objectPrototype = Object.prototype,
+ toString = objectPrototype.toString,
+ enumerables = true,
+ enumerablesTest = { toString: 1 },
+ i;
+
+ if (typeof Ext === 'undefined') {
+ global.Ext = {};
}
-});
-var combo = new Ext.form.ComboBox({
+ Ext.global = global;
- // Collapse combo when its element is clicked on
- plugins: [ new Ext.DomObserver({
- click: function(evt, comp) {
- comp.collapse();
- }
- })],
- store: myStore,
- typeAhead: true,
- mode: 'local',
- triggerAction: 'all'
-});
- *
- */
- var me = this, e = me.events;
- if(me.listeners){
- me.on(me.listeners);
- delete me.listeners;
+ for (i in enumerablesTest) {
+ enumerables = null;
}
- me.events = e || {};
-};
-EXTUTIL.Observable.prototype = {
- // private
- filterOptRe : /^(?:scope|delay|buffer|single)$/,
+ if (enumerables) {
+ enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
+ 'toLocaleString', 'toString', 'constructor'];
+ }
/**
- *
Fires the specified event with the passed parameters (minus the event name).
- *
An event may be set to bubble up an Observable parent hierarchy (See {@link Ext.Component#getBubbleTarget})
- * by calling {@link #enableBubble}.
- * @param {String} eventName The name of the event to fire.
- * @param {Object...} args Variable number of parameters are passed to handlers.
- * @return {Boolean} returns false if any of the handlers return false otherwise it returns true.
+ * An array containing extra enumerables for old browsers
+ * @type Array
*/
- fireEvent : function(){
- var a = Array.prototype.slice.call(arguments, 0),
- ename = a[0].toLowerCase(),
- me = this,
- ret = TRUE,
- ce = me.events[ename],
- cc,
- q,
- c;
- if (me.eventsSuspended === TRUE) {
- if (q = me.eventQueue) {
- q.push(a);
- }
- }
- else if(typeof ce == 'object') {
- if (ce.bubble){
- if(ce.fire.apply(ce, a.slice(1)) === FALSE) {
- return FALSE;
- }
- c = me.getBubbleTarget && me.getBubbleTarget();
- if(c && c.enableBubble) {
- cc = c.events[ename];
- if(!cc || typeof cc != 'object' || !cc.bubble) {
- c.enableBubble(ename);
- }
- return c.fireEvent.apply(c, a);
- }
- }
- else {
- a.shift();
- ret = ce.fire.apply(ce, a);
- }
- }
- return ret;
- },
+ Ext.enumerables = enumerables;
/**
- * Appends an event handler to this object.
- * @param {String} eventName The name of the event to listen for.
- * @param {Function} handler The method the event invokes.
- * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed.
- * If omitted, defaults to the object which fired the event.
- * @param {Object} options (optional) An object containing handler configuration.
- * properties. This may contain any of the following properties:
- *
scope : Object
The scope (this reference) in which the handler function is executed.
- * If omitted, defaults to the object which fired the event.
- *
delay : Number
The number of milliseconds to delay the invocation of the handler after the event fires.
- *
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
- *
buffer : Number
Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
- * by the specified number of milliseconds. If the event fires again within that time, the original
- * handler is not invoked, but the new handler is scheduled in its place.
- *
target : Observable
Only call the handler if the event was fired on the target Observable, not
- * if the event was bubbled up from a child Observable.
- *
- *
- * Combining Options
- * Using the options argument, it is possible to combine different types of listeners:
- *
- * A delayed, one-time listener.
- *
- * Attaching multiple handlers in 1 call
- * The method also allows for a single argument to be passed which is a config object containing properties
- * which specify multiple handlers.
- *
+ * Copies all the properties of config to the specified object.
+ * Note that if recursive merging and cloning without referencing the original objects / arrays is needed, use
+ * {@link Ext.Object#merge} instead.
+ * @param {Object} object The receiver of the properties
+ * @param {Object} config The source of the properties
+ * @param {Object} defaults A different object that will also be applied for default values
+ * @return {Object} returns obj
*/
- addListener : function(eventName, fn, scope, o){
- var me = this,
- e,
- oe,
- ce;
-
- if (typeof eventName == 'object') {
- o = eventName;
- for (e in o) {
- oe = o[e];
- if (!me.filterOptRe.test(e)) {
- me.addListener(e, oe.fn || oe, oe.scope || o.scope, oe.fn ? oe : o);
- }
- }
- } else {
- eventName = eventName.toLowerCase();
- ce = me.events[eventName] || TRUE;
- if (typeof ce == 'boolean') {
- me.events[eventName] = ce = new EXTUTIL.Event(me, eventName);
- }
- ce.addListener(fn, scope, typeof o == 'object' ? o : {});
+ Ext.apply = function(object, config, defaults) {
+ if (defaults) {
+ Ext.apply(object, defaults);
}
- },
- /**
- * Removes an event handler.
- * @param {String} eventName The type of event the handler was associated with.
- * @param {Function} handler The handler to remove. This must be a reference to the function passed into the {@link #addListener} call.
- * @param {Object} scope (optional) The scope originally specified for the handler.
- */
- removeListener : function(eventName, fn, scope){
- var ce = this.events[eventName.toLowerCase()];
- if (typeof ce == 'object') {
- ce.removeListener(fn, scope);
- }
- },
+ if (object && config && typeof config === 'object') {
+ var i, j, k;
- /**
- * Removes all listeners for this object
- */
- purgeListeners : function(){
- var events = this.events,
- evt,
- key;
- for(key in events){
- evt = events[key];
- if(typeof evt == 'object'){
- evt.clearListeners();
+ for (i in config) {
+ object[i] = config[i];
}
- }
- },
- /**
- * Adds the specified events to the list of events which this Observable may fire.
- * @param {Object|String} o Either an object with event names as properties with a value of true
- * or the first event name string if multiple event names are being passed as separate parameters.
- * @param {string} Optional. Event name if multiple event names are being passed as separate parameters.
- * Usage:
-this.addEvents('storeloaded', 'storecleared');
-
- */
- addEvents : function(o){
- var me = this;
- me.events = me.events || {};
- if (typeof o == 'string') {
- var a = arguments,
- i = a.length;
- while(i--) {
- me.events[a[i]] = me.events[a[i]] || TRUE;
+ if (enumerables) {
+ for (j = enumerables.length; j--;) {
+ k = enumerables[j];
+ if (config.hasOwnProperty(k)) {
+ object[k] = config[k];
+ }
+ }
}
- } else {
- Ext.applyIf(me.events, o);
- }
- },
-
- /**
- * Checks to see if this object has any listeners for a specified event
- * @param {String} eventName The name of the event to check for
- * @return {Boolean} True if the event is being listened for, else false
- */
- hasListener : function(eventName){
- var e = this.events[eventName.toLowerCase()];
- return typeof e == 'object' && e.listeners.length > 0;
- },
-
- /**
- * Suspend the firing of all events. (see {@link #resumeEvents})
- * @param {Boolean} queueSuspended Pass as true to queue up suspended events to be fired
- * after the {@link #resumeEvents} call instead of discarding all suspended events;
- */
- suspendEvents : function(queueSuspended){
- this.eventsSuspended = TRUE;
- if(queueSuspended && !this.eventQueue){
- this.eventQueue = [];
}
- },
-
- /**
- * Resume firing events. (see {@link #suspendEvents})
- * If events were suspended using the queueSuspended parameter, then all
- * events fired during event suspension will be sent to any listeners now.
- */
- resumeEvents : function(){
- var me = this,
- queued = me.eventQueue || [];
- me.eventsSuspended = FALSE;
- delete me.eventQueue;
- EACH(queued, function(e) {
- me.fireEvent.apply(me, e);
- });
- }
-};
-
-var OBSERVABLE = EXTUTIL.Observable.prototype;
-/**
- * Appends an event handler to this object (shorthand for {@link #addListener}.)
- * @param {String} eventName The type of event to listen for
- * @param {Function} handler The method the event invokes
- * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed.
- * If omitted, defaults to the object which fired the event.
- * @param {Object} options (optional) An object containing handler configuration.
- * @method
- */
-OBSERVABLE.on = OBSERVABLE.addListener;
-/**
- * Removes an event handler (shorthand for {@link #removeListener}.)
- * @param {String} eventName The type of event the handler was associated with.
- * @param {Function} handler The handler to remove. This must be a reference to the function passed into the {@link #addListener} call.
- * @param {Object} scope (optional) The scope originally specified for the handler.
- * @method
- */
-OBSERVABLE.un = OBSERVABLE.removeListener;
-
-/**
- * Removes all added captures from the Observable.
- * @param {Observable} o The Observable to release
- * @static
- */
-EXTUTIL.Observable.releaseCapture = function(o){
- o.fireEvent = OBSERVABLE.fireEvent;
-};
-function createTargeted(h, o, scope){
- return function(){
- if(o.target == arguments[0]){
- h.apply(scope, Array.prototype.slice.call(arguments, 0));
- }
+ return object;
};
-};
-function createBuffered(h, o, l, scope){
- l.task = new EXTUTIL.DelayedTask();
- return function(){
- l.task.delay(o.buffer, h, scope, Array.prototype.slice.call(arguments, 0));
- };
-};
+ Ext.buildSettings = Ext.apply({
+ baseCSSPrefix: 'x-',
+ scopeResetCSS: false
+ }, Ext.buildSettings || {});
-function createSingle(h, e, fn, scope){
- return function(){
- e.removeListener(fn, scope);
- return h.apply(scope, arguments);
- };
-};
+ Ext.apply(Ext, {
+ /**
+ * A reusable empty function
+ */
+ emptyFn: function() {},
-function createDelayed(h, o, l, scope){
- return function(){
- var task = new EXTUTIL.DelayedTask(),
- args = Array.prototype.slice.call(arguments, 0);
- if(!l.tasks) {
- l.tasks = [];
- }
- l.tasks.push(task);
- task.delay(o.delay || 10, function(){
- l.tasks.remove(task);
- h.apply(scope, args);
- }, scope);
- };
-};
+ baseCSSPrefix: Ext.buildSettings.baseCSSPrefix,
-EXTUTIL.Event = function(obj, name){
- this.name = name;
- this.obj = obj;
- this.listeners = [];
-};
+ /**
+ * Copies all the properties of config to object if they don't already exist.
+ * @param {Object} object The receiver of the properties
+ * @param {Object} config The source of the properties
+ * @return {Object} returns obj
+ */
+ applyIf: function(object, config) {
+ var property;
-EXTUTIL.Event.prototype = {
- addListener : function(fn, scope, options){
- var me = this,
- l;
- scope = scope || me.obj;
- if(!me.isListening(fn, scope)){
- l = me.createListener(fn, scope, options);
- if(me.firing){ // if we are currently firing this event, don't disturb the listener loop
- me.listeners = me.listeners.slice(0);
+ if (object) {
+ for (property in config) {
+ if (object[property] === undefined) {
+ object[property] = config[property];
+ }
+ }
}
- me.listeners.push(l);
- }
- },
-
- createListener: function(fn, scope, o){
- o = o || {};
- scope = scope || this.obj;
- var l = {
- fn: fn,
- scope: scope,
- options: o
- }, h = fn;
- if(o.target){
- h = createTargeted(h, o, scope);
- }
- if(o.delay){
- h = createDelayed(h, o, l, scope);
- }
- if(o.single){
- h = createSingle(h, this, fn, scope);
- }
- if(o.buffer){
- h = createBuffered(h, o, l, scope);
- }
- l.fireFn = h;
- return l;
- },
- findListener : function(fn, scope){
- var list = this.listeners,
- i = list.length,
- l;
+ return object;
+ },
- scope = scope || this.obj;
- while(i--){
- l = list[i];
- if(l){
- if(l.fn == fn && l.scope == scope){
- return i;
- }
+ /**
+ * Iterates either an array or an object. This method delegates to
+ * {@link Ext.Array#each Ext.Array.each} if the given value is iterable, and {@link Ext.Object#each Ext.Object.each} otherwise.
+ *
+ * @param {Object/Array} object The object or array to be iterated.
+ * @param {Function} fn The function to be called for each iteration. See and {@link Ext.Array#each Ext.Array.each} and
+ * {@link Ext.Object#each Ext.Object.each} for detailed lists of arguments passed to this function depending on the given object
+ * type that is being iterated.
+ * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
+ * Defaults to the object being iterated itself.
+ * @markdown
+ */
+ iterate: function(object, fn, scope) {
+ if (Ext.isEmpty(object)) {
+ return;
}
- }
- return -1;
- },
-
- isListening : function(fn, scope){
- return this.findListener(fn, scope) != -1;
- },
- removeListener : function(fn, scope){
- var index,
- l,
- k,
- me = this,
- ret = FALSE;
- if((index = me.findListener(fn, scope)) != -1){
- if (me.firing) {
- me.listeners = me.listeners.slice(0);
+ if (scope === undefined) {
+ scope = object;
}
- l = me.listeners[index];
- if(l.task) {
- l.task.cancel();
- delete l.task;
+
+ if (Ext.isIterable(object)) {
+ Ext.Array.each.call(Ext.Array, object, fn, scope);
}
- k = l.tasks && l.tasks.length;
- if(k) {
- while(k--) {
- l.tasks[k].cancel();
- }
- delete l.tasks;
+ else {
+ Ext.Object.each.call(Ext.Object, object, fn, scope);
}
- me.listeners.splice(index, 1);
- ret = TRUE;
- }
- return ret;
- },
-
- // Iterate to stop any buffered/delayed events
- clearListeners : function(){
- var me = this,
- l = me.listeners,
- i = l.length;
- while(i--) {
- me.removeListener(l[i].fn, l[i].scope);
}
- },
+ });
- fire : function(){
- var me = this,
- listeners = me.listeners,
- len = listeners.length,
- i = 0,
- l;
+ Ext.apply(Ext, {
- if(len > 0){
- me.firing = TRUE;
- var args = Array.prototype.slice.call(arguments, 0);
- for (; i < len; i++) {
- l = listeners[i];
- if(l && l.fireFn.apply(l.scope || me.obj || window, args) === FALSE) {
- return (me.firing = FALSE);
+ /**
+ * This method deprecated. Use {@link Ext#define Ext.define} instead.
+ * @method
+ * @param {Function} superclass
+ * @param {Object} overrides
+ * @return {Function} The subclass constructor from the overrides parameter, or a generated one if not provided.
+ * @deprecated 4.0.0 Use {@link Ext#define Ext.define} instead
+ */
+ extend: function() {
+ // inline overrides
+ var objectConstructor = objectPrototype.constructor,
+ inlineOverrides = function(o) {
+ for (var m in o) {
+ if (!o.hasOwnProperty(m)) {
+ continue;
+ }
+ this[m] = o[m];
}
- }
- }
- me.firing = FALSE;
- return TRUE;
- }
+ };
-};
-})();
-/**
- * @class Ext.DomHelper
- *
The DomHelper class provides a layer of abstraction from DOM and transparently supports creating
- * elements via DOM or using HTML fragments. It also has the ability to create HTML fragment templates
- * from your DOM building code.
- *
- *
DomHelper element specification object
- *
A specification object is used when creating elements. Attributes of this object
- * are assumed to be element attributes, except for 4 special attributes:
- *
- *
tag :
The tag name of the element
- *
children : or cn
An array of the
- * same kind of element definition objects to be created and appended. These can be nested
- * as deep as you want.
- *
cls :
The class attribute of the element.
- * This will end up being either the "class" attribute on a HTML fragment or className
- * for a DOM node, depending on whether DomHelper is using fragments or DOM.
- *
html :
The innerHTML for the element
- *
- *
- *
Insertion methods
- *
Commonly used insertion methods:
- *
- *
{@link #append} :
- *
{@link #insertBefore} :
- *
{@link #insertAfter} :
- *
{@link #overwrite} :
- *
{@link #createTemplate} :
- *
{@link #insertHtml} :
- *
- *
- *
Example
- *
This is an example, where an unordered list with 3 children items is appended to an existing
- * element with id 'my-div':
-
-var dh = Ext.DomHelper; // create shorthand alias
-// specification object
-var spec = {
- id: 'my-ul',
- tag: 'ul',
- cls: 'my-list',
- // append children after creating
- children: [ // may also specify 'cn' instead of 'children'
- {tag: 'li', id: 'item0', html: 'List Item 0'},
- {tag: 'li', id: 'item1', html: 'List Item 1'},
- {tag: 'li', id: 'item2', html: 'List Item 2'}
- ]
-};
-var list = dh.append(
- 'my-div', // the context element 'my-div' can either be the id or the actual node
- spec // the specification object
-);
-
- *
Element creation specification parameters in this class may also be passed as an Array of
- * specification objects. This can be used to insert multiple sibling nodes into an existing
- * container very efficiently. For example, to add more list items to the example above:
The real power is in the built-in templating. Instead of creating or appending any elements,
- * {@link #createTemplate} returns a Template object which can be used over and over to
- * insert new elements. Revisiting the example above, we could utilize templating this time:
- *
-// create the node
-var list = dh.append('my-div', {tag: 'ul', cls: 'my-list'});
-// get template
-var tpl = dh.createTemplate({tag: 'li', id: 'item{0}', html: 'List Item {0}'});
+ return function(subclass, superclass, overrides) {
+ // First we check if the user passed in just the superClass with overrides
+ if (Ext.isObject(superclass)) {
+ overrides = superclass;
+ superclass = subclass;
+ subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function() {
+ superclass.apply(this, arguments);
+ };
+ }
-for(var i = 0; i < 5, i++){
- tpl.append(list, [i]); // use template to append to the actual node
-}
- *
-var html = '{text}';
+ // We create a new temporary class
+ var F = function() {},
+ subclassProto, superclassProto = superclass.prototype;
-var tpl = new Ext.DomHelper.createTemplate(html);
-tpl.append('blog-roll', {
- id: 'link1',
- url: 'http://www.jackslocum.com/',
- text: "Jack's Site"
-});
-tpl.append('blog-roll', {
- id: 'link2',
- url: 'http://www.dustindiaz.com/',
- text: "Dustin's Site"
-});
- *
- *
- *
Compiling Templates
- *
Templates are applied using regular expressions. The performance is great, but if
- * you are adding a bunch of DOM elements using the same template, you can increase
- * performance even further by {@link Ext.Template#compile "compiling"} the template.
- * The way "{@link Ext.Template#compile compile()}" works is the template is parsed and
- * broken up at the different variable points and a dynamic function is created and eval'ed.
- * The generated function performs string concatenation of these parts and the passed
- * variables instead of using regular expressions.
- *
-var html = '{text}';
+ F.prototype = superclassProto;
+ subclassProto = subclass.prototype = new F();
+ subclassProto.constructor = subclass;
+ subclass.superclass = superclassProto;
-var tpl = new Ext.DomHelper.createTemplate(html);
-tpl.compile();
+ if (superclassProto.constructor === objectConstructor) {
+ superclassProto.constructor = superclass;
+ }
-//... use template like normal
- *
- *
- *
Performance Boost
- *
DomHelper will transparently create HTML fragments when it can. Using HTML fragments instead
- * of DOM can significantly boost performance.
- *
Element creation specification parameters may also be strings. If {@link #useDom} is false,
- * then the string is used as innerHTML. If {@link #useDom} is true, a string specification
- * results in the creation of a text node. Usage:
- *
-Ext.DomHelper.useDom = true; // force it to use DOM; reduces performance
- *
'+tbe;
+ subclass.override = function(overrides) {
+ Ext.override(subclass, overrides);
+ };
- // private
- function doInsert(el, o, returnElement, pos, sibling, append){
- var newNode = pub.insertHtml(pos, Ext.getDom(el), createHtml(o));
- return returnElement ? Ext.get(newNode, true) : newNode;
- }
+ subclassProto.override = inlineOverrides;
+ subclassProto.proto = subclassProto;
- // build as innerHTML where available
- function createHtml(o){
- var b = '',
- attr,
- val,
- key,
- cn;
+ subclass.override(overrides);
+ subclass.extend = function(o) {
+ return Ext.extend(subclass, o);
+ };
- if(typeof o == "string"){
- b = o;
- } else if (Ext.isArray(o)) {
- for (var i=0; i < o.length; i++) {
- if(o[i]) {
- b += createHtml(o[i]);
- }
- };
- } else {
- b += '<' + (o.tag = o.tag || 'div');
- for (attr in o) {
- val = o[attr];
- if(!confRe.test(attr)){
- if (typeof val == "object") {
- b += ' ' + attr + '="';
- for (key in val) {
- b += key + ':' + val[key] + ';';
- };
- b += '"';
- }else{
- b += ' ' + ({cls : 'class', htmlFor : 'for'}[attr] || attr) + '="' + val + '"';
- }
- }
+ return subclass;
};
- // Now either just close the tag or try to add children and close the tag.
- if (emptyTags.test(o.tag)) {
- b += '/>';
- } else {
- b += '>';
- if ((cn = o.children || o.cn)) {
- b += createHtml(cn);
- } else if(o.html){
- b += o.html;
- }
- b += '' + o.tag + '>';
- }
- }
- return b;
- }
+ }(),
- function ieTable(depth, s, h, e){
- tempTableEl.innerHTML = [s, h, e].join('');
- var i = -1,
- el = tempTableEl,
- ns;
- while(++i < depth){
- el = el.firstChild;
- }
-// If the result is multiple siblings, then encapsulate them into one fragment.
- if(ns = el.nextSibling){
- var df = document.createDocumentFragment();
- while(el){
- ns = el.nextSibling;
- df.appendChild(el);
- el = ns;
- }
- el = df;
+ /**
+ * Proxy to {@link Ext.Base#override}. Please refer {@link Ext.Base#override} for further details.
+
+ Ext.define('My.cool.Class', {
+ sayHi: function() {
+ alert('Hi!');
}
- return el;
}
- /**
- * @ignore
- * Nasty code for IE's broken table implementation
- */
- function insertIntoTable(tag, where, el, html) {
- var node,
- before;
-
- tempTableEl = tempTableEl || document.createElement('div');
+ Ext.override(My.cool.Class, {
+ sayHi: function() {
+ alert('About to say...');
- if(tag == 'td' && (where == afterbegin || where == beforeend) ||
- !tableElRe.test(tag) && (where == beforebegin || where == afterend)) {
- return;
+ this.callOverridden();
}
- before = where == beforebegin ? el :
- where == afterend ? el.nextSibling :
- where == afterbegin ? el.firstChild : null;
+ });
- if (where == beforebegin || where == afterend) {
- el = el.parentNode;
- }
+ var cool = new My.cool.Class();
+ cool.sayHi(); // alerts 'About to say...'
+ // alerts 'Hi!'
- if (tag == 'td' || (tag == 'tr' && (where == beforeend || where == afterbegin))) {
- node = ieTable(4, trs, html, tre);
- } else if ((tag == 'tbody' && (where == beforeend || where == afterbegin)) ||
- (tag == 'tr' && (where == beforebegin || where == afterend))) {
- node = ieTable(3, tbs, html, tbe);
- } else {
- node = ieTable(2, ts, html, te);
+ * Please note that `this.callOverridden()` only works if the class was previously
+ * created with {@link Ext#define)
+ *
+ * @param {Object} cls The class to override
+ * @param {Object} overrides The list of functions to add to origClass. This should be specified as an object literal
+ * containing one or more methods.
+ * @method override
+ * @markdown
+ */
+ override: function(cls, overrides) {
+ if (cls.prototype.$className) {
+ return cls.override(overrides);
+ }
+ else {
+ Ext.apply(cls.prototype, overrides);
+ }
}
- el.insertBefore(node, before);
- return node;
- }
+ });
+ // A full set of static methods to do type checking
+ Ext.apply(Ext, {
- pub = {
/**
- * Returns the markup for the passed Element(s) config.
- * @param {Object} o The DOM object spec (and children)
- * @return {String}
+ * Returns the given value itself if it's not empty, as described in {@link Ext#isEmpty}; returns the default
+ * value (second argument) otherwise.
+ *
+ * @param {Mixed} value The value to test
+ * @param {Mixed} defaultValue The value to return if the original value is empty
+ * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
+ * @return {Mixed} value, if non-empty, else defaultValue
*/
- markup : function(o){
- return createHtml(o);
+ valueFrom: function(value, defaultValue, allowBlank){
+ return Ext.isEmpty(value, allowBlank) ? defaultValue : value;
},
/**
- * Applies a style specification to an element.
- * @param {String/HTMLElement} el The element to apply styles to
- * @param {String/Object/Function} styles A style specification string e.g. 'width:100px', or object in the form {width:'100px'}, or
- * a function which returns such a specification.
+ * Returns the type of the given variable in string format. List of possible values are:
+ *
+ * - `undefined`: If the given value is `undefined`
+ * - `null`: If the given value is `null`
+ * - `string`: If the given value is a string
+ * - `number`: If the given value is a number
+ * - `boolean`: If the given value is a boolean value
+ * - `date`: If the given value is a `Date` object
+ * - `function`: If the given value is a function reference
+ * - `object`: If the given value is an object
+ * - `array`: If the given value is an array
+ * - `regexp`: If the given value is a regular expression
+ * - `element`: If the given value is a DOM Element
+ * - `textnode`: If the given value is a DOM text node and contains something other than whitespace
+ * - `whitespace`: If the given value is a DOM text node and contains only whitespace
+ *
+ * @param {Mixed} value
+ * @return {String}
+ * @markdown
*/
- applyStyles : function(el, styles){
- if (styles) {
- var matches;
+ typeOf: function(value) {
+ if (value === null) {
+ return 'null';
+ }
- el = Ext.fly(el);
- if (typeof styles == "function") {
- styles = styles.call();
- }
- if (typeof styles == "string") {
- /**
- * Since we're using the g flag on the regex, we need to set the lastIndex.
- * This automatically happens on some implementations, but not others, see:
- * http://stackoverflow.com/questions/2645273/javascript-regular-expression-literal-persists-between-function-calls
- * http://blog.stevenlevithan.com/archives/fixing-javascript-regexp
- */
- cssRe.lastIndex = 0;
- while ((matches = cssRe.exec(styles))) {
- el.setStyle(matches[1], matches[2]);
+ var type = typeof value;
+
+ if (type === 'undefined' || type === 'string' || type === 'number' || type === 'boolean') {
+ return type;
+ }
+
+ var typeToString = toString.call(value);
+
+ switch(typeToString) {
+ case '[object Array]':
+ return 'array';
+ case '[object Date]':
+ return 'date';
+ case '[object Boolean]':
+ return 'boolean';
+ case '[object Number]':
+ return 'number';
+ case '[object RegExp]':
+ return 'regexp';
+ }
+
+ if (type === 'function') {
+ return 'function';
+ }
+
+ if (type === 'object') {
+ if (value.nodeType !== undefined) {
+ if (value.nodeType === 3) {
+ return (/\S/).test(value.nodeValue) ? 'textnode' : 'whitespace';
+ }
+ else {
+ return 'element';
}
- } else if (typeof styles == "object") {
- el.setStyle(styles);
}
+
+ return 'object';
}
+
},
/**
- * Inserts an HTML fragment into the DOM.
- * @param {String} where Where to insert the html in relation to el - beforeBegin, afterBegin, beforeEnd, afterEnd.
- * @param {HTMLElement} el The context element
- * @param {String} html The HTML fragment
- * @return {HTMLElement} The new node
+ * Returns true if the passed value is empty, false otherwise. The value is deemed to be empty if it is either:
+ *
+ * - `null`
+ * - `undefined`
+ * - a zero-length array
+ * - a zero-length string (Unless the `allowEmptyString` parameter is set to `true`)
+ *
+ * @param {Mixed} value The value to test
+ * @param {Boolean} allowEmptyString (optional) true to allow empty strings (defaults to false)
+ * @return {Boolean}
+ * @markdown
*/
- insertHtml : function(where, el, html){
- var hash = {},
- hashVal,
- setStart,
- range,
- frag,
- rangeEl,
- rs;
+ isEmpty: function(value, allowEmptyString) {
+ return (value === null) || (value === undefined) || (!allowEmptyString ? value === '' : false) || (Ext.isArray(value) && value.length === 0);
+ },
- where = where.toLowerCase();
- // add these here because they are used in both branches of the condition.
- hash[beforebegin] = ['BeforeBegin', 'previousSibling'];
- hash[afterend] = ['AfterEnd', 'nextSibling'];
+ /**
+ * Returns true if the passed value is a JavaScript Array, false otherwise.
+ *
+ * @param {Mixed} target The target to test
+ * @return {Boolean}
+ * @method
+ */
+ isArray: ('isArray' in Array) ? Array.isArray : function(value) {
+ return toString.call(value) === '[object Array]';
+ },
- if (el.insertAdjacentHTML) {
- if(tableRe.test(el.tagName) && (rs = insertIntoTable(el.tagName.toLowerCase(), where, el, html))){
- return rs;
+ /**
+ * Returns true if the passed value is a JavaScript Date object, false otherwise.
+ * @param {Object} object The object to test
+ * @return {Boolean}
+ */
+ isDate: function(value) {
+ return toString.call(value) === '[object Date]';
+ },
+
+ /**
+ * Returns true if the passed value is a JavaScript Object, false otherwise.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ * @method
+ */
+ isObject: (toString.call(null) === '[object Object]') ?
+ function(value) {
+ // check ownerDocument here as well to exclude DOM nodes
+ return value !== null && value !== undefined && toString.call(value) === '[object Object]' && value.ownerDocument === undefined;
+ } :
+ function(value) {
+ return toString.call(value) === '[object Object]';
+ },
+
+ /**
+ * Returns true if the passed value is a JavaScript 'primitive', a string, number or boolean.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isPrimitive: function(value) {
+ var type = typeof value;
+
+ return type === 'string' || type === 'number' || type === 'boolean';
+ },
+
+ /**
+ * Returns true if the passed value is a JavaScript Function, false otherwise.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ * @method
+ */
+ isFunction:
+ // Safari 3.x and 4.x returns 'function' for typeof , hence we need to fall back to using
+ // Object.prorotype.toString (slower)
+ (typeof document !== 'undefined' && typeof document.getElementsByTagName('body') === 'function') ? function(value) {
+ return toString.call(value) === '[object Function]';
+ } : function(value) {
+ return typeof value === 'function';
+ },
+
+ /**
+ * Returns true if the passed value is a number. Returns false for non-finite numbers.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isNumber: function(value) {
+ return typeof value === 'number' && isFinite(value);
+ },
+
+ /**
+ * Validates that a value is numeric.
+ * @param {Mixed} value Examples: 1, '1', '2.34'
+ * @return {Boolean} True if numeric, false otherwise
+ */
+ isNumeric: function(value) {
+ return !isNaN(parseFloat(value)) && isFinite(value);
+ },
+
+ /**
+ * Returns true if the passed value is a string.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isString: function(value) {
+ return typeof value === 'string';
+ },
+
+ /**
+ * Returns true if the passed value is a boolean.
+ *
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isBoolean: function(value) {
+ return typeof value === 'boolean';
+ },
+
+ /**
+ * Returns true if the passed value is an HTMLElement
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isElement: function(value) {
+ return value ? value.nodeType === 1 : false;
+ },
+
+ /**
+ * Returns true if the passed value is a TextNode
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isTextNode: function(value) {
+ return value ? value.nodeName === "#text" : false;
+ },
+
+ /**
+ * Returns true if the passed value is defined.
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isDefined: function(value) {
+ return typeof value !== 'undefined';
+ },
+
+ /**
+ * Returns true if the passed value is iterable, false otherwise
+ * @param {Mixed} value The value to test
+ * @return {Boolean}
+ */
+ isIterable: function(value) {
+ return (value && typeof value !== 'string') ? value.length !== undefined : false;
+ }
+ });
+
+ Ext.apply(Ext, {
+
+ /**
+ * Clone almost any type of variable including array, object, DOM nodes and Date without keeping the old reference
+ * @param {Mixed} item The variable to clone
+ * @return {Mixed} clone
+ */
+ clone: function(item) {
+ if (item === null || item === undefined) {
+ return item;
+ }
+
+ // DOM nodes
+ // TODO proxy this to Ext.Element.clone to handle automatic id attribute changing
+ // recursively
+ if (item.nodeType && item.cloneNode) {
+ return item.cloneNode(true);
+ }
+
+ var type = toString.call(item);
+
+ // Date
+ if (type === '[object Date]') {
+ return new Date(item.getTime());
+ }
+
+ var i, j, k, clone, key;
+
+ // Array
+ if (type === '[object Array]') {
+ i = item.length;
+
+ clone = [];
+
+ while (i--) {
+ clone[i] = Ext.clone(item[i]);
}
- // add these two to the hash.
- hash[afterbegin] = ['AfterBegin', 'firstChild'];
- hash[beforeend] = ['BeforeEnd', 'lastChild'];
- if ((hashVal = hash[where])) {
- el.insertAdjacentHTML(hashVal[0], html);
- return el[hashVal[1]];
+ }
+ // Object
+ else if (type === '[object Object]' && item.constructor === Object) {
+ clone = {};
+
+ for (key in item) {
+ clone[key] = Ext.clone(item[key]);
}
- } else {
- range = el.ownerDocument.createRange();
- setStart = 'setStart' + (endRe.test(where) ? 'After' : 'Before');
- if (hash[where]) {
- range[setStart](el);
- frag = range.createContextualFragment(html);
- el.parentNode.insertBefore(frag, where == beforebegin ? el : el.nextSibling);
- return el[(where == beforebegin ? 'previous' : 'next') + 'Sibling'];
- } else {
- rangeEl = (where == afterbegin ? 'first' : 'last') + 'Child';
- if (el.firstChild) {
- range[setStart](el[rangeEl]);
- frag = range.createContextualFragment(html);
- if(where == afterbegin){
- el.insertBefore(frag, el.firstChild);
- }else{
- el.appendChild(frag);
- }
- } else {
- el.innerHTML = html;
+
+ if (enumerables) {
+ for (j = enumerables.length; j--;) {
+ k = enumerables[j];
+ clone[k] = item[k];
}
- return el[rangeEl];
}
}
- throw 'Illegal insertion point -> "' + where + '"';
+
+ return clone || item;
},
/**
- * Creates new DOM element(s) and inserts them before el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
+ * @private
+ * Generate a unique reference of Ext in the global scope, useful for sandboxing
*/
- insertBefore : function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforebegin);
+ getUniqueGlobalNamespace: function() {
+ var uniqueGlobalNamespace = this.uniqueGlobalNamespace;
+
+ if (uniqueGlobalNamespace === undefined) {
+ var i = 0;
+
+ do {
+ uniqueGlobalNamespace = 'ExtBox' + (++i);
+ } while (Ext.global[uniqueGlobalNamespace] !== undefined);
+
+ Ext.global[uniqueGlobalNamespace] = Ext;
+ this.uniqueGlobalNamespace = uniqueGlobalNamespace;
+ }
+
+ return uniqueGlobalNamespace;
},
/**
- * Creates new DOM element(s) and inserts them after el.
- * @param {Mixed} el The context element
- * @param {Object} o The DOM object spec (and children)
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
+ * @private
*/
- insertAfter : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterend, 'nextSibling');
+ functionFactory: function() {
+ var args = Array.prototype.slice.call(arguments);
+
+ if (args.length > 0) {
+ args[args.length - 1] = 'var Ext=window.' + this.getUniqueGlobalNamespace() + ';' +
+ args[args.length - 1];
+ }
+
+ return Function.prototype.constructor.apply(Function.prototype, args);
+ }
+ });
+
+ /**
+ * Old alias to {@link Ext#typeOf}
+ * @deprecated 4.0.0 Use {@link Ext#typeOf} instead
+ * @method
+ * @alias Ext#typeOf
+ */
+ Ext.type = Ext.typeOf;
+
+})();
+
+/**
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.Version
+ *
+ * A utility class that wrap around a string version number and provide convenient
+ * method to perform comparison. See also: {@link Ext.Version#compare compare}. Example:
+
+ var version = new Ext.Version('1.0.2beta');
+ console.log("Version is " + version); // Version is 1.0.2beta
+
+ console.log(version.getMajor()); // 1
+ console.log(version.getMinor()); // 0
+ console.log(version.getPatch()); // 2
+ console.log(version.getBuild()); // 0
+ console.log(version.getRelease()); // beta
+
+ console.log(version.isGreaterThan('1.0.1')); // True
+ console.log(version.isGreaterThan('1.0.2alpha')); // True
+ console.log(version.isGreaterThan('1.0.2RC')); // False
+ console.log(version.isGreaterThan('1.0.2')); // False
+ console.log(version.isLessThan('1.0.2')); // True
+
+ console.log(version.match(1.0)); // True
+ console.log(version.match('1.0.2')); // True
+
+ * @markdown
+ */
+(function() {
+
+// Current core version
+var version = '4.0.2', Version;
+ Ext.Version = Version = Ext.extend(Object, {
+
+ /**
+ * @param {String/Number} version The version number in the follow standard format: major[.minor[.patch[.build[release]]]]
+ * Examples: 1.0 or 1.2.3beta or 1.2.3.4RC
+ * @return {Ext.Version} this
+ */
+ constructor: function(version) {
+ var parts, releaseStartIndex;
+
+ if (version instanceof Version) {
+ return version;
+ }
+
+ this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
+
+ releaseStartIndex = this.version.search(/([^\d\.])/);
+
+ if (releaseStartIndex !== -1) {
+ this.release = this.version.substr(releaseStartIndex, version.length);
+ this.shortVersion = this.version.substr(0, releaseStartIndex);
+ }
+
+ this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
+
+ parts = this.version.split('.');
+
+ this.major = parseInt(parts.shift() || 0, 10);
+ this.minor = parseInt(parts.shift() || 0, 10);
+ this.patch = parseInt(parts.shift() || 0, 10);
+ this.build = parseInt(parts.shift() || 0, 10);
+
+ return this;
},
/**
- * Creates new DOM element(s) and inserts them as the first child of el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
+ * Override the native toString method
+ * @private
+ * @return {String} version
*/
- insertFirst : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterbegin, 'firstChild');
+ toString: function() {
+ return this.version;
},
/**
- * Creates new DOM element(s) and appends them to el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
+ * Override the native valueOf method
+ * @private
+ * @return {String} version
*/
- append : function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforeend, '', true);
+ valueOf: function() {
+ return this.version;
},
/**
- * Creates new DOM element(s) and overwrites the contents of el with them.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
+ * Returns the major component value
+ * @return {Number} major
*/
- overwrite : function(el, o, returnElement){
- el = Ext.getDom(el);
- el.innerHTML = createHtml(o);
- return returnElement ? Ext.get(el.firstChild) : el.firstChild;
+ getMajor: function() {
+ return this.major || 0;
},
- createHtml : createHtml
- };
- return pub;
-}();
+ /**
+ * Returns the minor component value
+ * @return {Number} minor
+ */
+ getMinor: function() {
+ return this.minor || 0;
+ },
+
+ /**
+ * Returns the patch component value
+ * @return {Number} patch
+ */
+ getPatch: function() {
+ return this.patch || 0;
+ },
+
+ /**
+ * Returns the build component value
+ * @return {Number} build
+ */
+ getBuild: function() {
+ return this.build || 0;
+ },
+
+ /**
+ * Returns the release component value
+ * @return {Number} release
+ */
+ getRelease: function() {
+ return this.release || '';
+ },
+
+ /**
+ * Returns whether this version if greater than the supplied argument
+ * @param {String/Number} target The version to compare with
+ * @return {Boolean} True if this version if greater than the target, false otherwise
+ */
+ isGreaterThan: function(target) {
+ return Version.compare(this.version, target) === 1;
+ },
+
+ /**
+ * Returns whether this version if smaller than the supplied argument
+ * @param {String/Number} target The version to compare with
+ * @return {Boolean} True if this version if smaller than the target, false otherwise
+ */
+ isLessThan: function(target) {
+ return Version.compare(this.version, target) === -1;
+ },
+
+ /**
+ * Returns whether this version equals to the supplied argument
+ * @param {String/Number} target The version to compare with
+ * @return {Boolean} True if this version equals to the target, false otherwise
+ */
+ equals: function(target) {
+ return Version.compare(this.version, target) === 0;
+ },
+
+ /**
+ * Returns whether this version matches the supplied argument. Example:
+ *
+ * var version = new Ext.Version('1.0.2beta');
+ * console.log(version.match(1)); // True
+ * console.log(version.match(1.0)); // True
+ * console.log(version.match('1.0.2')); // True
+ * console.log(version.match('1.0.2RC')); // False
+ *
+ * @param {String/Number} target The version to compare with
+ * @return {Boolean} True if this version matches the target, false otherwise
+ */
+ match: function(target) {
+ target = String(target);
+ return this.version.substr(0, target.length) === target;
+ },
+
+ /**
+ * Returns this format: [major, minor, patch, build, release]. Useful for comparison
+ * @return {Array}
+ */
+ toArray: function() {
+ return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
+ },
+
+ /**
+ * Returns shortVersion version without dots and release
+ * @return {String}
+ */
+ getShortVersion: function() {
+ return this.shortVersion;
+ }
+ });
+
+ Ext.apply(Version, {
+ // @private
+ releaseValueMap: {
+ 'dev': -6,
+ 'alpha': -5,
+ 'a': -5,
+ 'beta': -4,
+ 'b': -4,
+ 'rc': -3,
+ '#': -2,
+ 'p': -1,
+ 'pl': -1
+ },
+
+ /**
+ * Converts a version component to a comparable value
+ *
+ * @static
+ * @param {Mixed} value The value to convert
+ * @return {Mixed}
+ */
+ getComponentValue: function(value) {
+ return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
+ },
+
+ /**
+ * Compare 2 specified versions, starting from left to right. If a part contains special version strings,
+ * they are handled in the following order:
+ * 'dev' < 'alpha' = 'a' < 'beta' = 'b' < 'RC' = 'rc' < '#' < 'pl' = 'p' < 'anything else'
+ *
+ * @static
+ * @param {String} current The current version to compare to
+ * @param {String} target The target version to compare to
+ * @return {Number} Returns -1 if the current version is smaller than the target version, 1 if greater, and 0 if they're equivalent
+ */
+ compare: function(current, target) {
+ var currentValue, targetValue, i;
+
+ current = new Version(current).toArray();
+ target = new Version(target).toArray();
+
+ for (i = 0; i < Math.max(current.length, target.length); i++) {
+ currentValue = this.getComponentValue(current[i]);
+ targetValue = this.getComponentValue(target[i]);
+
+ if (currentValue < targetValue) {
+ return -1;
+ } else if (currentValue > targetValue) {
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+ });
+
+ Ext.apply(Ext, {
+ /**
+ * @private
+ */
+ versions: {},
+
+ /**
+ * @private
+ */
+ lastRegisteredVersion: null,
+
+ /**
+ * Set version number for the given package name.
+ *
+ * @param {String} packageName The package name, for example: 'core', 'touch', 'extjs'
+ * @param {String/Ext.Version} version The version, for example: '1.2.3alpha', '2.4.0-dev'
+ * @return {Ext}
+ */
+ setVersion: function(packageName, version) {
+ Ext.versions[packageName] = new Version(version);
+ Ext.lastRegisteredVersion = Ext.versions[packageName];
+
+ return this;
+ },
+
+ /**
+ * Get the version number of the supplied package name; will return the last registered version
+ * (last Ext.setVersion call) if there's no package name given.
+ *
+ * @param {String} packageName (Optional) The package name, for example: 'core', 'touch', 'extjs'
+ * @return {Ext.Version} The version
+ */
+ getVersion: function(packageName) {
+ if (packageName === undefined) {
+ return Ext.lastRegisteredVersion;
+ }
+
+ return Ext.versions[packageName];
+ },
+
+ /**
+ * Create a closure for deprecated code.
+ *
+ // This means Ext.oldMethod is only supported in 4.0.0beta and older.
+ // If Ext.getVersion('extjs') returns a version that is later than '4.0.0beta', for example '4.0.0RC',
+ // the closure will not be invoked
+ Ext.deprecate('extjs', '4.0.0beta', function() {
+ Ext.oldMethod = Ext.newMethod;
+
+ ...
+ });
+
+ * @param {String} packageName The package name
+ * @param {String} since The last version before it's deprecated
+ * @param {Function} closure The callback function to be executed with the specified version is less than the current version
+ * @param {Object} scope The execution scope (this) if the closure
+ * @markdown
+ */
+ deprecate: function(packageName, since, closure, scope) {
+ if (Version.compare(Ext.getVersion(packageName), since) < 1) {
+ closure.call(scope);
+ }
+ }
+ }); // End Versioning
+
+ Ext.setVersion('core', version);
+
+})();
+
/**
- * @class Ext.Template
- *
Represents an HTML fragment template. Templates may be {@link #compile precompiled}
- * for greater performance.
- *
For example usage {@link #Template see the constructor}.
+ * @class Ext.String
*
- * @constructor
- * An instance of this class may be created by passing to the constructor either
- * a single argument, or multiple arguments:
- *
- *
single argument : String/Array
- *
- * The single argument may be either a String or an Array:
- *
String :
-var t = new Ext.Template("<div>Hello {0}.</div>");
-t.{@link #append}('some-element', ['foo']);
- *
- * Multiple arguments will be combined with join('').
- *
-var t = new Ext.Template(
- '<div name="{id}">',
- '<span class="{cls}">{name} {value}</span>',
- '</div>',
- // a configuration object:
- {
- compiled: true, // {@link #compile} immediately
- disableFormats: true // See Notes below.
- }
-);
- *
- *
Notes:
- *
- *
Formatting and disableFormats are not applicable for Ext Core.
- *
For a list of available format functions, see {@link Ext.util.Format}.
- *
disableFormats reduces {@link #apply} time
- * when no formatting is required.
- *
- *
- *
- * @param {Mixed} config
+ * A collection of useful static methods to deal with strings
+ * @singleton
*/
-Ext.Template = function(html){
- var me = this,
- a = arguments,
- buf = [],
- v;
-
- if (Ext.isArray(html)) {
- html = html.join("");
- } else if (a.length > 1) {
- for(var i = 0, len = a.length; i < len; i++){
- v = a[i];
- if(typeof v == 'object'){
- Ext.apply(me, v);
- } else {
- buf.push(v);
- }
+
+Ext.String = {
+ trimRegex: /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
+ escapeRe: /('|\\)/g,
+ formatRe: /\{(\d+)\}/g,
+ escapeRegexRe: /([-.*+?^${}()|[\]\/\\])/g,
+
+ /**
+ * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
+ * @param {String} value The string to encode
+ * @return {String} The encoded text
+ * @method
+ */
+ htmlEncode: (function() {
+ var entities = {
+ '&': '&',
+ '>': '>',
+ '<': '<',
+ '"': '"'
+ }, keys = [], p, regex;
+
+ for (p in entities) {
+ keys.push(p);
+ }
+
+ regex = new RegExp('(' + keys.join('|') + ')', 'g');
+
+ return function(value) {
+ return (!value) ? value : String(value).replace(regex, function(match, capture) {
+ return entities[capture];
+ });
};
- html = buf.join('');
- }
+ })(),
- /**@private*/
- me.html = html;
/**
- * @cfg {Boolean} compiled Specify true to compile the template
- * immediately (see {@link #compile}).
- * Defaults to false.
+ * Convert certain characters (&, <, >, and ') from their HTML character equivalents.
+ * @param {String} value The string to decode
+ * @return {String} The decoded text
+ * @method
*/
- if (me.compiled) {
- me.compile();
- }
-};
-Ext.Template.prototype = {
+ htmlDecode: (function() {
+ var entities = {
+ '&': '&',
+ '>': '>',
+ '<': '<',
+ '"': '"'
+ }, keys = [], p, regex;
+
+ for (p in entities) {
+ keys.push(p);
+ }
+
+ regex = new RegExp('(' + keys.join('|') + '|[0-9]{1,5};' + ')', 'g');
+
+ return function(value) {
+ return (!value) ? value : String(value).replace(regex, function(match, capture) {
+ if (capture in entities) {
+ return entities[capture];
+ } else {
+ return String.fromCharCode(parseInt(capture.substr(2), 10));
+ }
+ });
+ };
+ })(),
+
/**
- * @cfg {RegExp} re The regular expression used to match template variables.
- * Defaults to:
- * re : /\{([\w-]+)\}/g // for Ext Core
- * re : /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g // for Ext JS
- *
+ * Appends content to the query string of a URL, handling logic for whether to place
+ * a question mark or ampersand.
+ * @param {String} url The URL to append to.
+ * @param {String} string The content to append to the URL.
+ * @return (String) The resulting URL
*/
- re : /\{([\w-]+)\}/g,
+ urlAppend : function(url, string) {
+ if (!Ext.isEmpty(string)) {
+ return url + (url.indexOf('?') === -1 ? '?' : '&') + string;
+ }
+
+ return url;
+ },
+
/**
- * See {@link #re}.
- * @type RegExp
- * @property re
+ * Trims whitespace from either end of a string, leaving spaces within the string intact. Example:
+ * @example
+var s = ' foo bar ';
+alert('-' + s + '-'); //alerts "- foo bar -"
+alert('-' + Ext.String.trim(s) + '-'); //alerts "-foo bar-"
+
+ * @param {String} string The string to escape
+ * @return {String} The trimmed string
*/
+ trim: function(string) {
+ return string.replace(Ext.String.trimRegex, "");
+ },
/**
- * Returns an HTML fragment of this template with the specified values applied.
- * @param {Object/Array} values
- * The template values. Can be an array if the params are numeric (i.e. {0})
- * or an object (i.e. {foo: 'bar'}).
- * @return {String} The HTML fragment
+ * Capitalize the given string
+ * @param {String} string
+ * @return {String}
*/
- applyTemplate : function(values){
- var me = this;
+ capitalize: function(string) {
+ return string.charAt(0).toUpperCase() + string.substr(1);
+ },
- return me.compiled ?
- me.compiled(values) :
- me.html.replace(me.re, function(m, name){
- return values[name] !== undefined ? values[name] : "";
- });
+ /**
+ * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
+ * @param {String} value The string to truncate
+ * @param {Number} length The maximum length to allow before truncating
+ * @param {Boolean} word True to try to find a common word break
+ * @return {String} The converted text
+ */
+ ellipsis: function(value, len, word) {
+ if (value && value.length > len) {
+ if (word) {
+ var vs = value.substr(0, len - 2),
+ index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
+ if (index !== -1 && index >= (len - 15)) {
+ return vs.substr(0, index) + "...";
+ }
+ }
+ return value.substr(0, len - 3) + "...";
+ }
+ return value;
},
/**
- * Sets the HTML used as the template and optionally compiles it.
- * @param {String} html
- * @param {Boolean} compile (optional) True to compile the template (defaults to undefined)
- * @return {Ext.Template} this
+ * Escapes the passed string for use in a regular expression
+ * @param {String} string
+ * @return {String}
*/
- set : function(html, compile){
- var me = this;
- me.html = html;
- me.compiled = null;
- return compile ? me.compile() : me;
+ escapeRegex: function(string) {
+ return string.replace(Ext.String.escapeRegexRe, "\\$1");
},
/**
- * Compiles the template into an internal function, eliminating the RegEx overhead.
- * @return {Ext.Template} this
+ * Escapes the passed string for ' and \
+ * @param {String} string The string to escape
+ * @return {String} The escaped string
*/
- compile : function(){
- var me = this,
- sep = Ext.isGecko ? "+" : ",";
+ escape: function(string) {
+ return string.replace(Ext.String.escapeRe, "\\$1");
+ },
- function fn(m, name){
- name = "values['" + name + "']";
- return "'"+ sep + '(' + name + " == undefined ? '' : " + name + ')' + sep + "'";
- }
+ /**
+ * Utility function that allows you to easily switch a string between two alternating values. The passed value
+ * is compared to the current string, and if they are equal, the other value that was passed in is returned. If
+ * they are already different, the first value passed in is returned. Note that this method returns the new value
+ * but does not change the current string.
+ *
+ * @param {String} string The current string
+ * @param {String} value The value to compare to the current string
+ * @param {String} other The new value to use if the string already equals the first value passed in
+ * @return {String} The new value
+ */
+ toggle: function(string, value, other) {
+ return string === value ? other : value;
},
/**
- * Applies the supplied values to the template and inserts the new node(s) as the first child of el.
- * @param {Mixed} el The context element
- * @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'})
- * @param {Boolean} returnElement (optional) true to return a Ext.Element (defaults to undefined)
- * @return {HTMLElement/Ext.Element} The new node or Element
+ * Pads the left side of a string with a specified character. This is especially useful
+ * for normalizing number and date strings. Example usage:
+ *
+ *
+var s = Ext.String.leftPad('123', 5, '0');
+// s now contains the string: '00123'
+
+ * @param {String} string The original string
+ * @param {Number} size The total length of the output string
+ * @param {String} character (optional) The character with which to pad the original string (defaults to empty string " ")
+ * @return {String} The padded string
*/
- insertFirst: function(el, values, returnElement){
- return this.doInsert('afterBegin', el, values, returnElement);
+ leftPad: function(string, size, character) {
+ var result = String(string);
+ character = character || " ";
+ while (result.length < size) {
+ result = character + result;
+ }
+ return result;
},
/**
- * Applies the supplied values to the template and inserts the new node(s) before el.
- * @param {Mixed} el The context element
- * @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'})
- * @param {Boolean} returnElement (optional) true to return a Ext.Element (defaults to undefined)
- * @return {HTMLElement/Ext.Element} The new node or Element
+ * Allows you to define a tokenized string and pass an arbitrary number of arguments to replace the tokens. Each
+ * token must be unique, and must increment in the format {0}, {1}, etc. Example usage:
+ *
+var cls = 'my-class', text = 'Some text';
+var s = Ext.String.format('<div class="{0}">{1}</div>', cls, text);
+// s now contains the string: '<div class="my-class">Some text</div>'
+
+ * @param {String} string The tokenized string to be formatted
+ * @param {String} value1 The value to replace token {0}
+ * @param {String} value2 Etc...
+ * @return {String} The formatted string
+ */
+ format: function(format) {
+ var args = Ext.Array.toArray(arguments, 1);
+ return format.replace(Ext.String.formatRe, function(m, i) {
+ return args[i];
+ });
+ }
+};
+
+/**
+ * @class Ext.Number
+ *
+ * A collection of useful static methods to deal with numbers
+ * @singleton
+ */
+
+(function() {
+
+var isToFixedBroken = (0.9).toFixed() !== '1';
+
+Ext.Number = {
+ /**
+ * Checks whether or not the passed number is within a desired range. If the number is already within the
+ * range it is returned, otherwise the min or max value is returned depending on which side of the range is
+ * exceeded. Note that this method returns the constrained value but does not change the current number.
+ * @param {Number} number The number to check
+ * @param {Number} min The minimum number in the range
+ * @param {Number} max The maximum number in the range
+ * @return {Number} The constrained value if outside the range, otherwise the current value
*/
- insertBefore: function(el, values, returnElement){
- return this.doInsert('beforeBegin', el, values, returnElement);
+ constrain: function(number, min, max) {
+ number = parseFloat(number);
+
+ if (!isNaN(min)) {
+ number = Math.max(number, min);
+ }
+ if (!isNaN(max)) {
+ number = Math.min(number, max);
+ }
+ return number;
},
/**
- * Applies the supplied values to the template and inserts the new node(s) after el.
- * @param {Mixed} el The context element
- * @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'})
- * @param {Boolean} returnElement (optional) true to return a Ext.Element (defaults to undefined)
- * @return {HTMLElement/Ext.Element} The new node or Element
+ * Snaps the passed number between stopping points based upon a passed increment value.
+ * @param {Number} value The unsnapped value.
+ * @param {Number} increment The increment by which the value must move.
+ * @param {Number} minValue The minimum value to which the returned value must be constrained. Overrides the increment..
+ * @param {Number} maxValue The maximum value to which the returned value must be constrained. Overrides the increment..
+ * @return {Number} The value of the nearest snap target.
*/
- insertAfter : function(el, values, returnElement){
- return this.doInsert('afterEnd', el, values, returnElement);
+ snap : function(value, increment, minValue, maxValue) {
+ var newValue = value,
+ m;
+
+ if (!(increment && value)) {
+ return value;
+ }
+ m = value % increment;
+ if (m !== 0) {
+ newValue -= m;
+ if (m * 2 >= increment) {
+ newValue += increment;
+ } else if (m * 2 < -increment) {
+ newValue -= increment;
+ }
+ }
+ return Ext.Number.constrain(newValue, minValue, maxValue);
},
/**
- * Applies the supplied values to the template and appends
- * the new node(s) to the specified el.
- *
For example usage {@link #Template see the constructor}.
- * @param {Mixed} el The context element
- * @param {Object/Array} values
- * The template values. Can be an array if the params are numeric (i.e. {0})
- * or an object (i.e. {foo: 'bar'}).
- * @param {Boolean} returnElement (optional) true to return an Ext.Element (defaults to undefined)
- * @return {HTMLElement/Ext.Element} The new node or Element
+ * Formats a number using fixed-point notation
+ * @param {Number} value The number to format
+ * @param {Number} precision The number of digits to show after the decimal point
*/
- append : function(el, values, returnElement){
- return this.doInsert('beforeEnd', el, values, returnElement);
- },
+ toFixed: function(value, precision) {
+ if (isToFixedBroken) {
+ precision = precision || 0;
+ var pow = Math.pow(10, precision);
+ return (Math.round(value * pow) / pow).toFixed(precision);
+ }
- doInsert : function(where, el, values, returnEl){
- el = Ext.getDom(el);
- var newNode = Ext.DomHelper.insertHtml(where, el, this.applyTemplate(values));
- return returnEl ? Ext.get(newNode, true) : newNode;
+ return value.toFixed(precision);
},
/**
- * Applies the supplied values to the template and overwrites the content of el with the new node(s).
- * @param {Mixed} el The context element
- * @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'})
- * @param {Boolean} returnElement (optional) true to return a Ext.Element (defaults to undefined)
- * @return {HTMLElement/Ext.Element} The new node or Element
+ * Validate that a value is numeric and convert it to a number if necessary. Returns the specified default value if
+ * it is not.
+
+Ext.Number.from('1.23', 1); // returns 1.23
+Ext.Number.from('abc', 1); // returns 1
+
+ * @param {Mixed} value
+ * @param {Number} defaultValue The value to return if the original value is non-numeric
+ * @return {Number} value, if numeric, defaultValue otherwise
*/
- overwrite : function(el, values, returnElement){
- el = Ext.getDom(el);
- el.innerHTML = this.applyTemplate(values);
- return returnElement ? Ext.get(el.firstChild, true) : el.firstChild;
+ from: function(value, defaultValue) {
+ if (isFinite(value)) {
+ value = parseFloat(value);
+ }
+
+ return !isNaN(value) ? value : defaultValue;
}
};
-/**
- * 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 the params are numeric (i.e. {0})
- * or an object (i.e. {foo: 'bar'}).
- * @return {String} The HTML fragment
- * @member Ext.Template
- * @method apply
- */
-Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
+
+})();
/**
- * Creates a template from the passed element's value (display:none textarea, preferred) or innerHTML.
- * @param {String/HTMLElement} el A DOM element or its id
- * @param {Object} config A configuration object
- * @return {Ext.Template} The created template
- * @static
+ * This method is deprecated, please use {@link Ext.Number#from Ext.Number.from} instead
+ *
+ * @deprecated 4.0.0 Replaced by Ext.Number.from
+ * @member Ext
+ * @method num
*/
-Ext.Template.from = function(el, config){
- el = Ext.getDom(el);
- return new Ext.Template(el.value || el.innerHTML, config || '');
+Ext.num = function() {
+ return Ext.Number.from.apply(this, arguments);
};
-/*
- * This is code is also distributed under MIT license for use
- * with jQuery and prototype JavaScript libraries.
- */
/**
- * @class Ext.DomQuery
-Provides high performance selector/xpath processing by compiling queries into reusable functions. New pseudo classes and matchers can be plugged. It works on HTML and XML documents (if a content node is passed in).
-
-DomQuery supports most of the CSS3 selectors spec, along with some custom selectors and basic XPath.
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.Array
+ *
+ * A set of useful static methods to deal with arrays; provide missing methods for older browsers.
-
-All selectors, attribute filters and pseudos below can be combined infinitely in any order. For example "div.foo:nth-child(odd)[@foo=bar].bar:first" would be a perfectly valid selector. Node filters are processed in the order in which they appear, which allows you to optimize your queries for your document structure.
-
-
Element Selectors:
-
-
* any element
-
E an element with the tag E
-
E F All descendent elements of E that have the tag F
-
E > F or E/F all direct children elements of E that have the tag F
-
E + F all elements with the tag F that are immediately preceded by an element with the tag E
-
E ~ F all elements with the tag F that are preceded by a sibling element with the tag E
-
-
Attribute Selectors:
-
The use of @ and quotes are optional. For example, div[@foo='bar'] is also a valid attribute selector.
-
-
E[foo] has an attribute "foo"
-
E[foo=bar] has an attribute "foo" that equals "bar"
-
E[foo^=bar] has an attribute "foo" that starts with "bar"
-
E[foo$=bar] has an attribute "foo" that ends with "bar"
-
E[foo*=bar] has an attribute "foo" that contains the substring "bar"
-
E[foo%=2] has an attribute "foo" that is evenly divisible by 2
-
E[foo!=bar] attribute "foo" does not equal "bar"
-
-
Pseudo Classes:
-
-
E:first-child E is the first child of its parent
-
E:last-child E is the last child of its parent
-
E:nth-child(n) E is the nth child of its parent (1 based as per the spec)
-
E:nth-child(odd) E is an odd child of its parent
-
E:nth-child(even) E is an even child of its parent
-
E:only-child E is the only child of its parent
-
E:checked E is an element that is has a checked attribute that is true (e.g. a radio or checkbox)
-
E:first the first E in the resultset
-
E:last the last E in the resultset
-
E:nth(n) the nth E in the resultset (1 based)
-
E:odd shortcut for :nth-child(odd)
-
E:even shortcut for :nth-child(even)
-
E:contains(foo) E's innerHTML contains the substring "foo"
-
E:nodeValue(foo) E contains a textNode with a nodeValue that equals "foo"
-
E:not(S) an E element that does not match simple selector S
-
E:has(S) an E element that has a descendent that matches simple selector S
-
E:next(S) an E element whose next sibling matches simple selector S
-
E:prev(S) an E element whose previous sibling matches simple selector S
-
E:any(S1|S2|S2) an E element which matches any of the simple selectors S1, S2 or S3//\\
-
-
CSS Value Selectors:
-
-
E{display=none} css value "display" that equals "none"
-
E{display^=none} css value "display" that starts with "none"
-
E{display$=none} css value "display" that ends with "none"
-
E{display*=none} css value "display" that contains the substring "none"
-
E{display%=2} css value "display" that is evenly divisible by 2
-
E{display!=none} css value "display" that does not equal "none"
-
* @singleton
+ * @markdown
*/
-Ext.DomQuery = function(){
- var cache = {},
- simpleCache = {},
- valueCache = {},
- nonSpace = /\S/,
- trimRe = /^\s+|\s+$/g,
- tplRe = /\{(\d+)\}/g,
- modeRe = /^(\s?[\/>+~]\s?|\s|$)/,
- tagTokenRe = /^(#)?([\w-\*]+)/,
- nthRe = /(\d*)n\+?(\d*)/,
- nthRe2 = /\D/,
- // This is for IE MSXML which does not support expandos.
- // IE runs the same speed using setAttribute, however FF slows way down
- // and Safari completely fails so they need to continue to use expandos.
- isIE = window.ActiveXObject ? true : false,
- key = 30803;
-
- // this eval is stop the compressor from
- // renaming the variable to something shorter
- eval("var batch = 30803;");
+(function() {
- // Retrieve the child node from a particular
- // parent at the specified index.
- function child(parent, index){
- var i = 0,
- n = parent.firstChild;
- while(n){
- if(n.nodeType == 1){
- if(++i == index){
- return n;
- }
+ var arrayPrototype = Array.prototype,
+ slice = arrayPrototype.slice,
+ supportsSplice = function () {
+ var array = [],
+ lengthBefore,
+ j = 20;
+
+ if (!array.splice) {
+ return false;
}
- n = n.nextSibling;
- }
- return null;
- }
- // retrieve the next element node
- function next(n){
- while((n = n.nextSibling) && n.nodeType != 1);
- return n;
- }
+ // This detects a bug in IE8 splice method:
+ // see http://social.msdn.microsoft.com/Forums/en-US/iewebdevelopment/thread/6e946d03-e09f-4b22-a4dd-cd5e276bf05a/
- // retrieve the previous element node
- function prev(n){
- while((n = n.previousSibling) && n.nodeType != 1);
- return n;
- }
+ while (j--) {
+ array.push("A");
+ }
- // Mark each child node with a nodeIndex skipping and
- // removing empty text nodes.
- function children(parent){
- var n = parent.firstChild,
- nodeIndex = -1,
- nextNode;
- while(n){
- nextNode = n.nextSibling;
- // clean worthless empty nodes.
- if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){
- parent.removeChild(n);
- }else{
- // add an expando nodeIndex
- n.nodeIndex = ++nodeIndex;
- }
- n = nextNode;
- }
- return this;
- }
+ array.splice(15, 0, "F", "F", "F", "F", "F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F");
+ lengthBefore = array.length; //41
+ array.splice(13, 0, "XXX"); // add one element
- // nodeSet - array of nodes
- // cls - CSS Class
- function byClassName(nodeSet, cls){
- if(!cls){
- return nodeSet;
- }
- var result = [], ri = -1;
- for(var i = 0, ci; ci = nodeSet[i]; i++){
- if((' '+ci.className+' ').indexOf(cls) != -1){
- result[++ri] = ci;
+ if (lengthBefore+1 != array.length) {
+ return false;
}
- }
- return result;
- };
+ // end IE8 bug
- function attrValue(n, attr){
- // if its an array, use the first node.
- if(!n.tagName && typeof n.length != "undefined"){
- n = n[0];
- }
- if(!n){
- return null;
- }
+ return true;
+ }(),
+ supportsForEach = 'forEach' in arrayPrototype,
+ supportsMap = 'map' in arrayPrototype,
+ supportsIndexOf = 'indexOf' in arrayPrototype,
+ supportsEvery = 'every' in arrayPrototype,
+ supportsSome = 'some' in arrayPrototype,
+ supportsFilter = 'filter' in arrayPrototype,
+ supportsSort = function() {
+ var a = [1,2,3,4,5].sort(function(){ return 0; });
+ return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
+ }(),
+ supportsSliceOnNodeList = true,
+ ExtArray;
- if(attr == "for"){
- return n.htmlFor;
- }
- if(attr == "class" || attr == "className"){
- return n.className;
+ try {
+ // IE 6 - 8 will throw an error when using Array.prototype.slice on NodeList
+ if (typeof document !== 'undefined') {
+ slice.call(document.getElementsByTagName('body'));
}
- return n.getAttribute(attr) || n[attr];
+ } catch (e) {
+ supportsSliceOnNodeList = false;
+ }
- };
+ function fixArrayIndex (array, index) {
+ return (index < 0) ? Math.max(0, array.length + index)
+ : Math.min(array.length, index);
+ }
+ /*
+ Does the same work as splice, but with a slightly more convenient signature. The splice
+ method has bugs in IE8, so this is the implementation we use on that platform.
+
+ The rippling of items in the array can be tricky. Consider two use cases:
+
+ index=2
+ removeCount=2
+ /=====\
+ +---+---+---+---+---+---+---+---+
+ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+ +---+---+---+---+---+---+---+---+
+ / \/ \/ \/ \
+ / /\ /\ /\ \
+ / / \/ \/ \ +--------------------------+
+ / / /\ /\ +--------------------------+ \
+ / / / \/ +--------------------------+ \ \
+ / / / /+--------------------------+ \ \ \
+ / / / / \ \ \ \
+ v v v v v v v v
+ +---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+---+
+ | 0 | 1 | 4 | 5 | 6 | 7 | | 0 | 1 | a | b | c | 4 | 5 | 6 | 7 |
+ +---+---+---+---+---+---+ +---+---+---+---+---+---+---+---+---+
+ A B \=========/
+ insert=[a,b,c]
+
+ In case A, it is obvious that copying of [4,5,6,7] must be left-to-right so
+ that we don't end up with [0,1,6,7,6,7]. In case B, we have the opposite; we
+ must go right-to-left or else we would end up with [0,1,a,b,c,4,4,4,4].
+ */
+ function replaceSim (array, index, removeCount, insert) {
+ var add = insert ? insert.length : 0,
+ length = array.length,
+ pos = fixArrayIndex(array, index);
- // ns - nodes
- // mode - false, /, >, +, ~
- // tagName - defaults to "*"
- function getNodes(ns, mode, tagName){
- var result = [], ri = -1, cs;
- if(!ns){
- return result;
- }
- tagName = tagName || "*";
- // convert to array
- if(typeof ns.getElementsByTagName != "undefined"){
- ns = [ns];
- }
-
- // no mode specified, grab all elements by tagName
- // at any depth
- if(!mode){
- for(var i = 0, ni; ni = ns[i]; i++){
- cs = ni.getElementsByTagName(tagName);
- for(var j = 0, ci; ci = cs[j]; j++){
- result[++ri] = ci;
- }
+ // we try to use Array.push when we can for efficiency...
+ if (pos === length) {
+ if (add) {
+ array.push.apply(array, insert);
}
- // Direct Child mode (/ or >)
- // E > F or E/F all direct children elements of E that have the tag
- } else if(mode == "/" || mode == ">"){
- var utag = tagName.toUpperCase();
- for(var i = 0, ni, cn; ni = ns[i]; i++){
- cn = ni.childNodes;
- for(var j = 0, cj; cj = cn[j]; j++){
- if(cj.nodeName == utag || cj.nodeName == tagName || tagName == '*'){
- result[++ri] = cj;
- }
+ } else {
+ var remove = Math.min(removeCount, length - pos),
+ tailOldPos = pos + remove,
+ tailNewPos = tailOldPos + add - remove,
+ tailCount = length - tailOldPos,
+ lengthAfterRemove = length - remove,
+ i;
+
+ if (tailNewPos < tailOldPos) { // case A
+ for (i = 0; i < tailCount; ++i) {
+ array[tailNewPos+i] = array[tailOldPos+i];
}
- }
- // Immediately Preceding mode (+)
- // E + F all elements with the tag F that are immediately preceded by an element with the tag E
- }else if(mode == "+"){
- var utag = tagName.toUpperCase();
- for(var i = 0, n; n = ns[i]; i++){
- while((n = n.nextSibling) && n.nodeType != 1);
- if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){
- result[++ri] = n;
+ } else if (tailNewPos > tailOldPos) { // case B
+ for (i = tailCount; i--; ) {
+ array[tailNewPos+i] = array[tailOldPos+i];
}
- }
- // Sibling mode (~)
- // E ~ F all elements with the tag F that are preceded by a sibling element with the tag E
- }else if(mode == "~"){
- var utag = tagName.toUpperCase();
- for(var i = 0, n; n = ns[i]; i++){
- while((n = n.nextSibling)){
- if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
- result[++ri] = n;
- }
+ } // else, add == remove (nothing to do)
+
+ if (add && pos === lengthAfterRemove) {
+ array.length = lengthAfterRemove; // truncate array
+ array.push.apply(array, insert);
+ } else {
+ array.length = lengthAfterRemove + add; // reserves space
+ for (i = 0; i < add; ++i) {
+ array[pos+i] = insert[i];
}
}
}
- return result;
- }
- function concat(a, b){
- if(b.slice){
- return a.concat(b);
- }
- for(var i = 0, l = b.length; i < l; i++){
- a[a.length] = b[i];
- }
- return a;
+ return array;
}
- function byTag(cs, tagName){
- if(cs.tagName || cs == document){
- cs = [cs];
- }
- if(!tagName){
- return cs;
- }
- var result = [], ri = -1;
- tagName = tagName.toLowerCase();
- for(var i = 0, ci; ci = cs[i]; i++){
- if(ci.nodeType == 1 && ci.tagName.toLowerCase() == tagName){
- result[++ri] = ci;
+ function replaceNative (array, index, removeCount, insert) {
+ if (insert && insert.length) {
+ if (index < array.length) {
+ array.splice.apply(array, [index, removeCount].concat(insert));
+ } else {
+ array.push.apply(array, insert);
}
+ } else {
+ array.splice(index, removeCount);
}
- return result;
+ return array;
}
- function byId(cs, id){
- if(cs.tagName || cs == document){
- cs = [cs];
- }
- if(!id){
- return cs;
- }
- var result = [], ri = -1;
- for(var i = 0, ci; ci = cs[i]; i++){
- if(ci && ci.id == id){
- result[++ri] = ci;
- return result;
- }
- }
- return result;
+ function eraseSim (array, index, removeCount) {
+ return replaceSim(array, index, removeCount);
}
- // operators are =, !=, ^=, $=, *=, %=, |= and ~=
- // custom can be "{"
- function byAttribute(cs, attr, value, op, custom){
- var result = [],
- ri = -1,
- useGetStyle = custom == "{",
- fn = Ext.DomQuery.operators[op],
- a,
- xml,
- hasXml;
-
- for(var i = 0, ci; ci = cs[i]; i++){
- // skip non-element nodes.
- if(ci.nodeType != 1){
- continue;
- }
- // only need to do this for the first node
- if(!hasXml){
- xml = Ext.DomQuery.isXml(ci);
- hasXml = true;
- }
-
- // we only need to change the property names if we're dealing with html nodes, not XML
- if(!xml){
- if(useGetStyle){
- a = Ext.DomQuery.getStyle(ci, attr);
- } else if (attr == "class" || attr == "className"){
- a = ci.className;
- } else if (attr == "for"){
- a = ci.htmlFor;
- } else if (attr == "href"){
- // getAttribute href bug
- // http://www.glennjones.net/Post/809/getAttributehrefbug.htm
- a = ci.getAttribute("href", 2);
- } else{
- a = ci.getAttribute(attr);
- }
- }else{
- a = ci.getAttribute(attr);
- }
- if((fn && fn(a, value)) || (!fn && a)){
- result[++ri] = ci;
- }
- }
- return result;
+ function eraseNative (array, index, removeCount) {
+ array.splice(index, removeCount);
+ return array;
}
- function byPseudo(cs, name, value){
- return Ext.DomQuery.pseudos[name](cs, value);
- }
+ function spliceSim (array, index, removeCount) {
+ var pos = fixArrayIndex(array, index),
+ removed = array.slice(index, fixArrayIndex(array, pos+removeCount));
- function nodupIEXml(cs){
- var d = ++key,
- r;
- cs[0].setAttribute("_nodup", d);
- r = [cs[0]];
- for(var i = 1, len = cs.length; i < len; i++){
- var c = cs[i];
- if(!c.getAttribute("_nodup") != d){
- c.setAttribute("_nodup", d);
- r[r.length] = c;
- }
- }
- for(var i = 0, len = cs.length; i < len; i++){
- cs[i].removeAttribute("_nodup");
+ if (arguments.length < 4) {
+ replaceSim(array, pos, removeCount);
+ } else {
+ replaceSim(array, pos, removeCount, slice.call(arguments, 3));
}
- return r;
- }
- function nodup(cs){
- if(!cs){
- return [];
- }
- var len = cs.length, c, i, r = cs, cj, ri = -1;
- if(!len || typeof cs.nodeType != "undefined" || len == 1){
- return cs;
- }
- if(isIE && typeof cs[0].selectSingleNode != "undefined"){
- return nodupIEXml(cs);
- }
- var d = ++key;
- cs[0]._nodup = d;
- for(i = 1; c = cs[i]; i++){
- if(c._nodup != d){
- c._nodup = d;
- }else{
- r = [];
- for(var j = 0; j < i; j++){
- r[++ri] = cs[j];
- }
- for(j = i+1; cj = cs[j]; j++){
- if(cj._nodup != d){
- cj._nodup = d;
- r[++ri] = cj;
- }
- }
- return r;
- }
- }
- return r;
+ return removed;
}
- function quickDiffIEXml(c1, c2){
- var d = ++key,
- r = [];
- for(var i = 0, len = c1.length; i < len; i++){
- c1[i].setAttribute("_qdiff", d);
- }
- for(var i = 0, len = c2.length; i < len; i++){
- if(c2[i].getAttribute("_qdiff") != d){
- r[r.length] = c2[i];
- }
- }
- for(var i = 0, len = c1.length; i < len; i++){
- c1[i].removeAttribute("_qdiff");
- }
- return r;
+ function spliceNative (array) {
+ return array.splice.apply(array, slice.call(arguments, 1));
}
- function quickDiff(c1, c2){
- var len1 = c1.length,
- d = ++key,
- r = [];
- if(!len1){
- return c2;
- }
- if(isIE && typeof c1[0].selectSingleNode != "undefined"){
- return quickDiffIEXml(c1, c2);
- }
- for(var i = 0; i < len1; i++){
- c1[i]._qdiff = d;
- }
- for(var i = 0, len = c2.length; i < len; i++){
- if(c2[i]._qdiff != d){
- r[r.length] = c2[i];
- }
- }
- return r;
- }
+ var erase = supportsSplice ? eraseNative : eraseSim,
+ replace = supportsSplice ? replaceNative : replaceSim,
+ splice = supportsSplice ? spliceNative : spliceSim;
- function quickId(ns, mode, root, id){
- if(ns == root){
- var d = root.ownerDocument || root;
- return d.getElementById(id);
- }
- ns = getNodes(ns, mode, "*");
- return byId(ns, id);
- }
+ // NOTE: from here on, use erase, replace or splice (not native methods)...
- return {
- getStyle : function(el, name){
- return Ext.fly(el).getStyle(name);
- },
+ ExtArray = Ext.Array = {
/**
- * Compiles a selector/xpath query into a reusable function. The returned function
- * takes one parameter "root" (optional), which is the context node from where the query should start.
- * @param {String} selector The selector/xpath query
- * @param {String} type (optional) Either "select" (the default) or "simple" for a simple selector match
- * @return {Function}
+ * Iterates an array or an iterable value and invoke the given callback function for each item.
+ *
+ * var countries = ['Vietnam', 'Singapore', 'United States', 'Russia'];
+ *
+ * Ext.Array.each(countries, function(name, index, countriesItSelf) {
+ * console.log(name);
+ * });
+ *
+ * var sum = function() {
+ * var sum = 0;
+ *
+ * Ext.Array.each(arguments, function(value) {
+ * sum += value;
+ * });
+ *
+ * return sum;
+ * };
+ *
+ * sum(1, 2, 3); // returns 6
+ *
+ * The iteration can be stopped by returning false in the function callback.
+ *
+ * Ext.Array.each(countries, function(name, index, countriesItSelf) {
+ * if (name === 'Singapore') {
+ * return false; // break here
+ * }
+ * });
+ *
+ * {@link Ext#each Ext.each} is alias for {@link Ext.Array#each Ext.Array.each}
+ *
+ * @param {Array/NodeList/Mixed} iterable The value to be iterated. If this
+ * argument is not iterable, the callback function is called once.
+ * @param {Function} fn The callback function. If it returns false, the iteration stops and this method returns
+ * the current `index`. Arguments passed to this callback function are:
+ *
+ * - `item` : Mixed - The item at the current `index` in the passed `array`
+ * - `index` : Number - The current `index` within the `array`
+ * - `allItems` : Array/NodeList/Mixed - The `array` passed as the first argument to `Ext.Array.each`
+ *
+ * @param {Object} scope (Optional) The scope (`this` reference) in which the specified function is executed.
+ * @param {Boolean} reverse (Optional) Reverse the iteration order (loop from the end to the beginning)
+ * Defaults false
+ * @return {Boolean} See description for the `fn` parameter.
*/
- compile : function(path, type){
- type = type || "select";
+ each: function(array, fn, scope, reverse) {
+ array = ExtArray.from(array);
- // setup fn preamble
- var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"],
- mode,
- lastPath,
- matchers = Ext.DomQuery.matchers,
- matchersLn = matchers.length,
- modeMatch,
- // accept leading mode switch
- lmode = path.match(modeRe);
-
- if(lmode && lmode[1]){
- fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
- path = path.replace(lmode[1], "");
- }
-
- // strip leading slashes
- while(path.substr(0, 1)=="/"){
- path = path.substr(1);
- }
+ var i,
+ ln = array.length;
- while(path && lastPath != path){
- lastPath = path;
- var tokenMatch = path.match(tagTokenRe);
- if(type == "select"){
- if(tokenMatch){
- // ID Selector
- if(tokenMatch[1] == "#"){
- fn[fn.length] = 'n = quickId(n, mode, root, "'+tokenMatch[2]+'");';
- }else{
- fn[fn.length] = 'n = getNodes(n, mode, "'+tokenMatch[2]+'");';
- }
- path = path.replace(tokenMatch[0], "");
- }else if(path.substr(0, 1) != '@'){
- fn[fn.length] = 'n = getNodes(n, mode, "*");';
- }
- // type of "simple"
- }else{
- if(tokenMatch){
- if(tokenMatch[1] == "#"){
- fn[fn.length] = 'n = byId(n, "'+tokenMatch[2]+'");';
- }else{
- fn[fn.length] = 'n = byTag(n, "'+tokenMatch[2]+'");';
- }
- path = path.replace(tokenMatch[0], "");
+ if (reverse !== true) {
+ for (i = 0; i < ln; i++) {
+ if (fn.call(scope || array[i], array[i], i, array) === false) {
+ return i;
}
}
- while(!(modeMatch = path.match(modeRe))){
- var matched = false;
- for(var j = 0; j < matchersLn; j++){
- var t = matchers[j];
- var m = path.match(t.re);
- if(m){
- fn[fn.length] = t.select.replace(tplRe, function(x, i){
- return m[i];
- });
- path = path.replace(m[0], "");
- matched = true;
- break;
- }
- }
- // prevent infinite loop on bad selector
- if(!matched){
- throw 'Error parsing selector, parsing failed at "' + path + '"';
+ }
+ else {
+ for (i = ln - 1; i > -1; i--) {
+ if (fn.call(scope || array[i], array[i], i, array) === false) {
+ return i;
}
}
- if(modeMatch[1]){
- fn[fn.length] = 'mode="'+modeMatch[1].replace(trimRe, "")+'";';
- path = path.replace(modeMatch[1], "");
- }
}
- // close fn out
- fn[fn.length] = "return nodup(n);\n}";
-
- // eval fn and return it
- eval(fn.join(""));
- return f;
+
+ return true;
},
/**
- * Selects a group of elements.
- * @param {String} selector The selector/xpath query (can be a comma separated list of selectors)
- * @param {Node/String} root (optional) The start of the query (defaults to document).
- * @return {Array} An Array of DOM elements which match the selector. If there are
- * no matches, and empty Array is returned.
+ * Iterates an array and invoke the given callback function for each item. Note that this will simply
+ * delegate to the native Array.prototype.forEach method if supported.
+ * It doesn't support stopping the iteration by returning false in the callback function like
+ * {@link Ext.Array#each}. However, performance could be much better in modern browsers comparing with
+ * {@link Ext.Array#each}
+ *
+ * @param {Array} array The array to iterate
+ * @param {Function} fn The function callback, to be invoked these arguments:
+ *
+ * - `item` : Mixed - The item at the current `index` in the passed `array`
+ * - `index` : Number - The current `index` within the `array`
+ * - `allItems` : Array - The `array` itself which was passed as the first argument
+ *
+ * @param {Object} scope (Optional) The execution scope (`this`) in which the specified function is executed.
*/
- jsSelect: function(path, root, type){
- // set root to doc if not specified.
- root = root || document;
-
- if(typeof root == "string"){
- root = document.getElementById(root);
- }
- var paths = path.split(","),
- results = [];
-
- // loop over each selector
- for(var i = 0, len = paths.length; i < len; i++){
- var subPath = paths[i].replace(trimRe, "");
- // compile and place in cache
- if(!cache[subPath]){
- cache[subPath] = Ext.DomQuery.compile(subPath);
- if(!cache[subPath]){
- throw subPath + " is not a valid selector";
- }
- }
- var result = cache[subPath](root);
- if(result && result != document){
- results = results.concat(result);
- }
+ forEach: function(array, fn, scope) {
+ if (supportsForEach) {
+ return array.forEach(fn, scope);
}
-
- // if there were multiple selectors, make sure dups
- // are eliminated
- if(paths.length > 1){
- return nodup(results);
+
+ var i = 0,
+ ln = array.length;
+
+ for (; i < ln; i++) {
+ fn.call(scope, array[i], i, array);
}
- return results;
},
- isXml: function(el) {
- var docEl = (el ? el.ownerDocument || el : 0).documentElement;
- return docEl ? docEl.nodeName !== "HTML" : false;
- },
- select : document.querySelectorAll ? function(path, root, type) {
- root = root || document;
- if (!Ext.DomQuery.isXml(root)) {
- try {
- var cs = root.querySelectorAll(path);
- return Ext.toArray(cs);
- }
- catch (ex) {}
- }
- return Ext.DomQuery.jsSelect.call(this, path, root, type);
- } : function(path, root, type) {
- return Ext.DomQuery.jsSelect.call(this, path, root, type);
- },
/**
- * Selects a single element.
- * @param {String} selector The selector/xpath query
- * @param {Node} root (optional) The start of the query (defaults to document).
- * @return {Element} The DOM element which matched the selector.
+ * Get the index of the provided `item` in the given `array`, a supplement for the
+ * missing arrayPrototype.indexOf in Internet Explorer.
+ *
+ * @param {Array} array The array to check
+ * @param {Mixed} item The item to look for
+ * @param {Number} from (Optional) The index at which to begin the search
+ * @return {Number} The index of item in the array (or -1 if it is not found)
*/
- selectNode : function(path, root){
- return Ext.DomQuery.select(path, root)[0];
- },
+ indexOf: function(array, item, from) {
+ if (supportsIndexOf) {
+ return array.indexOf(item, from);
+ }
- /**
- * Selects the value of a node, optionally replacing null with the defaultValue.
- * @param {String} selector The selector/xpath query
- * @param {Node} root (optional) The start of the query (defaults to document).
- * @param {String} defaultValue
- * @return {String}
- */
- selectValue : function(path, root, defaultValue){
- path = path.replace(trimRe, "");
- if(!valueCache[path]){
- valueCache[path] = Ext.DomQuery.compile(path, "select");
+ var i, length = array.length;
+
+ for (i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++) {
+ if (array[i] === item) {
+ return i;
+ }
}
- var n = valueCache[path](root), v;
- n = n[0] ? n[0] : n;
-
- // overcome a limitation of maximum textnode size
- // Rumored to potentially crash IE6 but has not been confirmed.
- // http://reference.sitepoint.com/javascript/Node/normalize
- // https://developer.mozilla.org/En/DOM/Node.normalize
- if (typeof n.normalize == 'function') n.normalize();
-
- v = (n && n.firstChild ? n.firstChild.nodeValue : null);
- return ((v === null||v === undefined||v==='') ? defaultValue : v);
- },
- /**
- * Selects the value of a node, parsing integers and floats. Returns the defaultValue, or 0 if none is specified.
- * @param {String} selector The selector/xpath query
- * @param {Node} root (optional) The start of the query (defaults to document).
- * @param {Number} defaultValue
- * @return {Number}
- */
- selectNumber : function(path, root, defaultValue){
- var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
- return parseFloat(v);
+ return -1;
},
/**
- * Returns true if the passed element(s) match the passed simple selector (e.g. div.some-class or span:first-child)
- * @param {String/HTMLElement/Array} el An element id, element or array of elements
- * @param {String} selector The simple selector to test
- * @return {Boolean}
+ * Checks whether or not the given `array` contains the specified `item`
+ *
+ * @param {Array} array The array to check
+ * @param {Mixed} item The item to look for
+ * @return {Boolean} True if the array contains the item, false otherwise
*/
- is : function(el, ss){
- if(typeof el == "string"){
- el = document.getElementById(el);
+ contains: function(array, item) {
+ if (supportsIndexOf) {
+ return array.indexOf(item) !== -1;
}
- var isArray = Ext.isArray(el),
- result = Ext.DomQuery.filter(isArray ? el : [el], ss);
- return isArray ? (result.length == el.length) : (result.length > 0);
- },
- /**
- * Filters an array of elements to only include matches of a simple selector (e.g. div.some-class or span:first-child)
- * @param {Array} el An array of elements to filter
- * @param {String} selector The simple selector to test
- * @param {Boolean} nonMatches If true, it returns the elements that DON'T match
- * the selector instead of the ones that match
- * @return {Array} An Array of DOM elements which match the selector. If there are
- * no matches, and empty Array is returned.
+ var i, ln;
+
+ for (i = 0, ln = array.length; i < ln; i++) {
+ if (array[i] === item) {
+ return true;
+ }
+ }
+
+ return false;
+ },
+
+ /**
+ * Converts any iterable (numeric indices and a length property) into a true array.
+ *
+ * function test() {
+ * var args = Ext.Array.toArray(arguments),
+ * fromSecondToLastArgs = Ext.Array.toArray(arguments, 1);
+ *
+ * alert(args.join(' '));
+ * alert(fromSecondToLastArgs.join(' '));
+ * }
+ *
+ * test('just', 'testing', 'here'); // alerts 'just testing here';
+ * // alerts 'testing here';
+ *
+ * Ext.Array.toArray(document.getElementsByTagName('div')); // will convert the NodeList into an array
+ * Ext.Array.toArray('splitted'); // returns ['s', 'p', 'l', 'i', 't', 't', 'e', 'd']
+ * Ext.Array.toArray('splitted', 0, 3); // returns ['s', 'p', 'l', 'i']
+ *
+ * {@link Ext#toArray Ext.toArray} is alias for {@link Ext.Array#toArray Ext.Array.toArray}
+ *
+ * @param {Mixed} iterable the iterable object to be turned into a true Array.
+ * @param {Number} start (Optional) a zero-based index that specifies the start of extraction. Defaults to 0
+ * @param {Number} end (Optional) a zero-based index that specifies the end of extraction. Defaults to the last
+ * index of the iterable value
+ * @return {Array} array
*/
- filter : function(els, ss, nonMatches){
- ss = ss.replace(trimRe, "");
- if(!simpleCache[ss]){
- simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");
+ toArray: function(iterable, start, end){
+ if (!iterable || !iterable.length) {
+ return [];
}
- var result = simpleCache[ss](els);
- return nonMatches ? quickDiff(result, els) : result;
+
+ if (typeof iterable === 'string') {
+ iterable = iterable.split('');
+ }
+
+ if (supportsSliceOnNodeList) {
+ return slice.call(iterable, start || 0, end || iterable.length);
+ }
+
+ var array = [],
+ i;
+
+ start = start || 0;
+ end = end ? ((end < 0) ? iterable.length + end : end) : iterable.length;
+
+ for (i = start; i < end; i++) {
+ array.push(iterable[i]);
+ }
+
+ return array;
},
/**
- * Collection of matching regular expressions and code snippets.
- * Each capture group within () will be replace the {} in the select
- * statement as specified by their index.
+ * Plucks the value of a property from each item in the Array. Example:
+ *
+ * Ext.Array.pluck(Ext.query("p"), "className"); // [el1.className, el2.className, ..., elN.className]
+ *
+ * @param {Array|NodeList} array The Array of items to pluck the value from.
+ * @param {String} propertyName The property name to pluck from each element.
+ * @return {Array} The value from each item in the Array.
*/
- matchers : [{
- re: /^\.([\w-]+)/,
- select: 'n = byClassName(n, " {1} ");'
- }, {
- re: /^\:([\w-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
- select: 'n = byPseudo(n, "{1}", "{2}");'
- },{
- re: /^(?:([\[\{])(?:@)?([\w-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
- select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'
- }, {
- re: /^#([\w-]+)/,
- select: 'n = byId(n, "{1}");'
- },{
- re: /^@([\w-]+)/,
- select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'
+ pluck: function(array, propertyName) {
+ var ret = [],
+ i, ln, item;
+
+ for (i = 0, ln = array.length; i < ln; i++) {
+ item = array[i];
+
+ ret.push(item[propertyName]);
}
- ],
+
+ return ret;
+ },
/**
- * Collection of operator comparison functions. The default operators are =, !=, ^=, $=, *=, %=, |= and ~=.
- * New operators can be added as long as the match the format c= where c is any character other than space, > <.
+ * Creates a new array with the results of calling a provided function on every element in this array.
+ *
+ * @param {Array} array
+ * @param {Function} fn Callback function for each item
+ * @param {Object} scope Callback function scope
+ * @return {Array} results
*/
- operators : {
- "=" : function(a, v){
- return a == v;
- },
- "!=" : function(a, v){
- return a != v;
- },
- "^=" : function(a, v){
- return a && a.substr(0, v.length) == v;
- },
- "$=" : function(a, v){
- return a && a.substr(a.length-v.length) == v;
- },
- "*=" : function(a, v){
- return a && a.indexOf(v) !== -1;
- },
- "%=" : function(a, v){
- return (a % v) == 0;
- },
- "|=" : function(a, v){
- return a && (a == v || a.substr(0, v.length+1) == v+'-');
- },
- "~=" : function(a, v){
- return a && (' '+a+' ').indexOf(' '+v+' ') != -1;
+ map: function(array, fn, scope) {
+ if (supportsMap) {
+ return array.map(fn, scope);
+ }
+
+ var results = [],
+ i = 0,
+ len = array.length;
+
+ for (; i < len; i++) {
+ results[i] = fn.call(scope, array[i], i, array);
}
+
+ return results;
},
/**
- *
Object hash of "pseudo class" filter functions which are used when filtering selections. Each function is passed
- * two parameters:
- *
c : Array
An Array of DOM elements to filter.
- *
v : String
The argument (if any) supplied in the selector.
- *
- *
A filter function returns an Array of DOM elements which conform to the pseudo class.
- *
In addition to the provided pseudo classes listed above such as first-child and nth-child,
- * developers may add additional, custom psuedo class filters to select elements according to application-specific requirements.
- *
For example, to filter <a> elements to only return links to external resources:
- *
-Ext.DomQuery.pseudos.external = function(c, v){
- var r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
-// Include in result set only if it's a link to an external resource
- if(ci.hostname != location.hostname){
- r[++ri] = ci;
- }
- }
- return r;
-};
- * Then external links could be gathered with the following statement:
-var externalLinks = Ext.select("a:external");
-
+ * Executes the specified function for each array element until the function returns a falsy value.
+ * If such an item is found, the function will return false immediately.
+ * Otherwise, it will return true.
+ *
+ * @param {Array} array
+ * @param {Function} fn Callback function for each item
+ * @param {Object} scope Callback function scope
+ * @return {Boolean} True if no false value is returned by the callback function.
*/
- pseudos : {
- "first-child" : function(c){
- var r = [], ri = -1, n;
- for(var i = 0, ci; ci = n = c[i]; i++){
- while((n = n.previousSibling) && n.nodeType != 1);
- if(!n){
- r[++ri] = ci;
- }
+ every: function(array, fn, scope) {
+ if (supportsEvery) {
+ return array.every(fn, scope);
+ }
+
+ var i = 0,
+ ln = array.length;
+
+ for (; i < ln; ++i) {
+ if (!fn.call(scope, array[i], i, array)) {
+ return false;
}
- return r;
- },
+ }
- "last-child" : function(c){
- var r = [], ri = -1, n;
- for(var i = 0, ci; ci = n = c[i]; i++){
- while((n = n.nextSibling) && n.nodeType != 1);
- if(!n){
- r[++ri] = ci;
- }
+ return true;
+ },
+
+ /**
+ * Executes the specified function for each array element until the function returns a truthy value.
+ * If such an item is found, the function will return true immediately. Otherwise, it will return false.
+ *
+ * @param {Array} array
+ * @param {Function} fn Callback function for each item
+ * @param {Object} scope Callback function scope
+ * @return {Boolean} True if the callback function returns a truthy value.
+ */
+ some: function(array, fn, scope) {
+ if (supportsSome) {
+ return array.some(fn, scope);
+ }
+
+ var i = 0,
+ ln = array.length;
+
+ for (; i < ln; ++i) {
+ if (fn.call(scope, array[i], i, array)) {
+ return true;
}
- return r;
- },
+ }
- "nth-child" : function(c, a) {
- var r = [], ri = -1,
- m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a),
- f = (m[1] || 1) - 0, l = m[2] - 0;
- for(var i = 0, n; n = c[i]; i++){
- var pn = n.parentNode;
- if (batch != pn._batch) {
- var j = 0;
- for(var cn = pn.firstChild; cn; cn = cn.nextSibling){
- if(cn.nodeType == 1){
- cn.nodeIndex = ++j;
- }
- }
- pn._batch = batch;
- }
- if (f == 1) {
- if (l == 0 || n.nodeIndex == l){
- r[++ri] = n;
- }
- } else if ((n.nodeIndex + l) % f == 0){
- r[++ri] = n;
- }
+ return false;
+ },
+
+ /**
+ * Filter through an array and remove empty item as defined in {@link Ext#isEmpty Ext.isEmpty}
+ *
+ * See {@link Ext.Array#filter}
+ *
+ * @param {Array} array
+ * @return {Array} results
+ */
+ clean: function(array) {
+ var results = [],
+ i = 0,
+ ln = array.length,
+ item;
+
+ for (; i < ln; i++) {
+ item = array[i];
+
+ if (!Ext.isEmpty(item)) {
+ results.push(item);
}
+ }
- return r;
- },
+ return results;
+ },
- "only-child" : function(c){
- var r = [], ri = -1;;
- for(var i = 0, ci; ci = c[i]; i++){
- if(!prev(ci) && !next(ci)){
- r[++ri] = ci;
- }
+ /**
+ * Returns a new array with unique items
+ *
+ * @param {Array} array
+ * @return {Array} results
+ */
+ unique: function(array) {
+ var clone = [],
+ i = 0,
+ ln = array.length,
+ item;
+
+ for (; i < ln; i++) {
+ item = array[i];
+
+ if (ExtArray.indexOf(clone, item) === -1) {
+ clone.push(item);
}
- return r;
- },
+ }
- "empty" : function(c){
- var r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- var cns = ci.childNodes, j = 0, cn, empty = true;
- while(cn = cns[j]){
- ++j;
- if(cn.nodeType == 1 || cn.nodeType == 3){
- empty = false;
+ return clone;
+ },
+
+ /**
+ * Creates a new array with all of the elements of this array for which
+ * the provided filtering function returns true.
+ *
+ * @param {Array} array
+ * @param {Function} fn Callback function for each item
+ * @param {Object} scope Callback function scope
+ * @return {Array} results
+ */
+ filter: function(array, fn, scope) {
+ if (supportsFilter) {
+ return array.filter(fn, scope);
+ }
+
+ var results = [],
+ i = 0,
+ ln = array.length;
+
+ for (; i < ln; i++) {
+ if (fn.call(scope, array[i], i, array)) {
+ results.push(array[i]);
+ }
+ }
+
+ return results;
+ },
+
+ /**
+ * Converts a value to an array if it's not already an array; returns:
+ *
+ * - An empty array if given value is `undefined` or `null`
+ * - Itself if given value is already an array
+ * - An array copy if given value is {@link Ext#isIterable iterable} (arguments, NodeList and alike)
+ * - An array with one item which is the given value, otherwise
+ *
+ * @param {Array/Mixed} value The value to convert to an array if it's not already is an array
+ * @param {Boolean} (Optional) newReference True to clone the given array and return a new reference if necessary,
+ * defaults to false
+ * @return {Array} array
+ */
+ from: function(value, newReference) {
+ if (value === undefined || value === null) {
+ return [];
+ }
+
+ if (Ext.isArray(value)) {
+ return (newReference) ? slice.call(value) : value;
+ }
+
+ if (value && value.length !== undefined && typeof value !== 'string') {
+ return Ext.toArray(value);
+ }
+
+ return [value];
+ },
+
+ /**
+ * Removes the specified item from the array if it exists
+ *
+ * @param {Array} array The array
+ * @param {Mixed} item The item to remove
+ * @return {Array} The passed array itself
+ */
+ remove: function(array, item) {
+ var index = ExtArray.indexOf(array, item);
+
+ if (index !== -1) {
+ erase(array, index, 1);
+ }
+
+ return array;
+ },
+
+ /**
+ * Push an item into the array only if the array doesn't contain it yet
+ *
+ * @param {Array} array The array
+ * @param {Mixed} item The item to include
+ */
+ include: function(array, item) {
+ if (!ExtArray.contains(array, item)) {
+ array.push(item);
+ }
+ },
+
+ /**
+ * Clone a flat array without referencing the previous one. Note that this is different
+ * from Ext.clone since it doesn't handle recursive cloning. It's simply a convenient, easy-to-remember method
+ * for Array.prototype.slice.call(array)
+ *
+ * @param {Array} array The array
+ * @return {Array} The clone array
+ */
+ clone: function(array) {
+ return slice.call(array);
+ },
+
+ /**
+ * Merge multiple arrays into one with unique items.
+ *
+ * {@link Ext.Array#union} is alias for {@link Ext.Array#merge}
+ *
+ * @param {Array} array1
+ * @param {Array} array2
+ * @param {Array} etc
+ * @return {Array} merged
+ */
+ merge: function() {
+ var args = slice.call(arguments),
+ array = [],
+ i, ln;
+
+ for (i = 0, ln = args.length; i < ln; i++) {
+ array = array.concat(args[i]);
+ }
+
+ return ExtArray.unique(array);
+ },
+
+ /**
+ * Merge multiple arrays into one with unique items that exist in all of the arrays.
+ *
+ * @param {Array} array1
+ * @param {Array} array2
+ * @param {Array} etc
+ * @return {Array} intersect
+ */
+ intersect: function() {
+ var intersect = [],
+ arrays = slice.call(arguments),
+ i, j, k, minArray, array, x, y, ln, arraysLn, arrayLn;
+
+ if (!arrays.length) {
+ return intersect;
+ }
+
+ // Find the smallest array
+ for (i = x = 0,ln = arrays.length; i < ln,array = arrays[i]; i++) {
+ if (!minArray || array.length < minArray.length) {
+ minArray = array;
+ x = i;
+ }
+ }
+
+ minArray = ExtArray.unique(minArray);
+ erase(arrays, x, 1);
+
+ // Use the smallest unique'd array as the anchor loop. If the other array(s) do contain
+ // an item in the small array, we're likely to find it before reaching the end
+ // of the inner loop and can terminate the search early.
+ for (i = 0,ln = minArray.length; i < ln,x = minArray[i]; i++) {
+ var count = 0;
+
+ for (j = 0,arraysLn = arrays.length; j < arraysLn,array = arrays[j]; j++) {
+ for (k = 0,arrayLn = array.length; k < arrayLn,y = array[k]; k++) {
+ if (x === y) {
+ count++;
break;
}
}
- if(empty){
- r[++ri] = ci;
- }
}
- return r;
- },
- "contains" : function(c, v){
- var r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- if((ci.textContent||ci.innerText||'').indexOf(v) != -1){
- r[++ri] = ci;
- }
+ if (count === arraysLn) {
+ intersect.push(x);
}
- return r;
- },
+ }
- "nodeValue" : function(c, v){
- var r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- if(ci.firstChild && ci.firstChild.nodeValue == v){
- r[++ri] = ci;
- }
- }
- return r;
- },
+ return intersect;
+ },
- "checked" : function(c){
- var r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- if(ci.checked == true){
- r[++ri] = ci;
+ /**
+ * Perform a set difference A-B by subtracting all items in array B from array A.
+ *
+ * @param {Array} arrayA
+ * @param {Array} arrayB
+ * @return {Array} difference
+ */
+ difference: function(arrayA, arrayB) {
+ var clone = slice.call(arrayA),
+ ln = clone.length,
+ i, j, lnB;
+
+ for (i = 0,lnB = arrayB.length; i < lnB; i++) {
+ for (j = 0; j < ln; j++) {
+ if (clone[j] === arrayB[i]) {
+ erase(clone, j, 1);
+ j--;
+ ln--;
}
}
- return r;
- },
+ }
- "not" : function(c, ss){
- return Ext.DomQuery.filter(c, ss, true);
- },
+ return clone;
+ },
- "any" : function(c, selectors){
- var ss = selectors.split('|'),
- r = [], ri = -1, s;
- for(var i = 0, ci; ci = c[i]; i++){
- for(var j = 0; s = ss[j]; j++){
- if(Ext.DomQuery.is(ci, s)){
- r[++ri] = ci;
- break;
+ /**
+ * Returns a shallow copy of a part of an array. This is equivalent to the native
+ * call "Array.prototype.slice.call(array, begin, end)". This is often used when "array"
+ * is "arguments" since the arguments object does not supply a slice method but can
+ * be the context object to Array.prototype.slice.
+ *
+ * @param {Array} array The array (or arguments object).
+ * @param {Number} begin The index at which to begin. Negative values are offsets from
+ * the end of the array.
+ * @param {Number} end The index at which to end. The copied items do not include
+ * end. Negative values are offsets from the end of the array. If end is omitted,
+ * all items up to the end of the array are copied.
+ * @return {Array} The copied piece of the array.
+ */
+ slice: function(array, begin, end) {
+ return slice.call(array, begin, end);
+ },
+
+ /**
+ * Sorts the elements of an Array.
+ * By default, this method sorts the elements alphabetically and ascending.
+ *
+ * @param {Array} array The array to sort.
+ * @param {Function} sortFn (optional) The comparison function.
+ * @return {Array} The sorted array.
+ */
+ sort: function(array, sortFn) {
+ if (supportsSort) {
+ if (sortFn) {
+ return array.sort(sortFn);
+ } else {
+ return array.sort();
+ }
+ }
+
+ var length = array.length,
+ i = 0,
+ comparison,
+ j, min, tmp;
+
+ for (; i < length; i++) {
+ min = i;
+ for (j = i + 1; j < length; j++) {
+ if (sortFn) {
+ comparison = sortFn(array[j], array[min]);
+ if (comparison < 0) {
+ min = j;
}
+ } else if (array[j] < array[min]) {
+ min = j;
}
}
- return r;
- },
-
- "odd" : function(c){
- return this["nth-child"](c, "odd");
- },
+ if (min !== i) {
+ tmp = array[i];
+ array[i] = array[min];
+ array[min] = tmp;
+ }
+ }
- "even" : function(c){
- return this["nth-child"](c, "even");
- },
+ return array;
+ },
- "nth" : function(c, a){
- return c[a-1] || [];
- },
+ /**
+ * Recursively flattens into 1-d Array. Injects Arrays inline.
+ *
+ */
+ flatten: function(array) {
+ var worker = [];
- "first" : function(c){
- return c[0] || [];
- },
+ function rFlatten(a) {
+ var i, ln, v;
- "last" : function(c){
- return c[c.length-1] || [];
- },
+ for (i = 0, ln = a.length; i < ln; i++) {
+ v = a[i];
- "has" : function(c, ss){
- var s = Ext.DomQuery.select,
- r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- if(s(ss, ci).length > 0){
- r[++ri] = ci;
+ if (Ext.isArray(v)) {
+ rFlatten(v);
+ } else {
+ worker.push(v);
}
}
- return r;
- },
- "next" : function(c, ss){
- var is = Ext.DomQuery.is,
- r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- var n = next(ci);
- if(n && is(n, ss)){
- r[++ri] = ci;
+ return worker;
+ }
+
+ return rFlatten(array);
+ },
+
+ /**
+ * Returns the minimum value in the Array.
+ *
+ * @param {Array|NodeList} array The Array from which to select the minimum value.
+ * @param {Function} comparisonFn (optional) a function to perform the comparision which determines minimization.
+ * If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1
+ * @return {Mixed} minValue The minimum value
+ */
+ min: function(array, comparisonFn) {
+ var min = array[0],
+ i, ln, item;
+
+ for (i = 0, ln = array.length; i < ln; i++) {
+ item = array[i];
+
+ if (comparisonFn) {
+ if (comparisonFn(min, item) === 1) {
+ min = item;
}
}
- return r;
- },
+ else {
+ if (item < min) {
+ min = item;
+ }
+ }
+ }
- "prev" : function(c, ss){
- var is = Ext.DomQuery.is,
- r = [], ri = -1;
- for(var i = 0, ci; ci = c[i]; i++){
- var n = prev(ci);
- if(n && is(n, ss)){
- r[++ri] = ci;
+ return min;
+ },
+
+ /**
+ * Returns the maximum value in the Array.
+ *
+ * @param {Array|NodeList} array The Array from which to select the maximum value.
+ * @param {Function} comparisonFn (optional) a function to perform the comparision which determines maximization.
+ * If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1
+ * @return {Mixed} maxValue The maximum value
+ */
+ max: function(array, comparisonFn) {
+ var max = array[0],
+ i, ln, item;
+
+ for (i = 0, ln = array.length; i < ln; i++) {
+ item = array[i];
+
+ if (comparisonFn) {
+ if (comparisonFn(max, item) === -1) {
+ max = item;
+ }
+ }
+ else {
+ if (item > max) {
+ max = item;
}
}
- return r;
}
- }
+
+ return max;
+ },
+
+ /**
+ * Calculates the mean of all items in the array.
+ *
+ * @param {Array} array The Array to calculate the mean value of.
+ * @return {Number} The mean.
+ */
+ mean: function(array) {
+ return array.length > 0 ? ExtArray.sum(array) / array.length : undefined;
+ },
+
+ /**
+ * Calculates the sum of all items in the given array.
+ *
+ * @param {Array} array The Array to calculate the sum value of.
+ * @return {Number} The sum.
+ */
+ sum: function(array) {
+ var sum = 0,
+ i, ln, item;
+
+ for (i = 0,ln = array.length; i < ln; i++) {
+ item = array[i];
+
+ sum += item;
+ }
+
+ return sum;
+ },
+
+
+ /**
+ * Removes items from an array. This is functionally equivalent to the splice method
+ * of Array, but works around bugs in IE8's splice method and does not copy the
+ * removed elements in order to return them (because very often they are ignored).
+ *
+ * @param {Array} array The Array on which to replace.
+ * @param {Number} index The index in the array at which to operate.
+ * @param {Number} removeCount The number of items to remove at index.
+ * @return {Array} The array passed.
+ * @method
+ */
+ erase: erase,
+
+ /**
+ * Inserts items in to an array.
+ *
+ * @param {Array} array The Array on which to replace.
+ * @param {Number} index The index in the array at which to operate.
+ * @param {Array} items The array of items to insert at index.
+ * @return {Array} The array passed.
+ */
+ insert: function (array, index, items) {
+ return replace(array, index, 0, items);
+ },
+
+ /**
+ * Replaces items in an array. This is functionally equivalent to the splice method
+ * of Array, but works around bugs in IE8's splice method and is often more convenient
+ * to call because it accepts an array of items to insert rather than use a variadic
+ * argument list.
+ *
+ * @param {Array} array The Array on which to replace.
+ * @param {Number} index The index in the array at which to operate.
+ * @param {Number} removeCount The number of items to remove at index (can be 0).
+ * @param {Array} insert An optional array of items to insert at index.
+ * @return {Array} The array passed.
+ * @method
+ */
+ replace: replace,
+
+ /**
+ * Replaces items in an array. This is equivalent to the splice method of Array, but
+ * works around bugs in IE8's splice method. The signature is exactly the same as the
+ * splice method except that the array is the first argument. All arguments following
+ * removeCount are inserted in the array at index.
+ *
+ * @param {Array} array The Array on which to replace.
+ * @param {Number} index The index in the array at which to operate.
+ * @param {Number} removeCount The number of items to remove at index (can be 0).
+ * @return {Array} An array containing the removed items.
+ * @method
+ */
+ splice: splice
};
-}();
-/**
- * Selects an array of DOM nodes by CSS/XPath selector. Shorthand of {@link Ext.DomQuery#select}
- * @param {String} path The selector/xpath query
- * @param {Node} root (optional) The start of the query (defaults to document).
- * @return {Array}
- * @member Ext
- * @method query
- */
-Ext.query = Ext.DomQuery.select;
-/**
- * @class Ext.util.DelayedTask
- *
The DelayedTask class provides a convenient way to "buffer" the execution of a method,
- * performing setTimeout where a new timeout cancels the old timeout. When called, the
- * task will wait the specified time period before executing. If durng that time period,
- * the task is called again, the original call will be cancelled. This continues so that
- * the function is only called a single time for each iteration.
- *
This method is especially useful for things like detecting whether a user has finished
- * typing in a text field. An example would be performing validation on a keypress. You can
- * use this class to buffer the keypress events for a certain number of milliseconds, and
- * perform only if they stop for that amount of time. Usage:
-var task = new Ext.util.DelayedTask(function(){
- alert(Ext.getDom('myInputField').value.length);
-});
-// Wait 500ms before calling our function. If the user presses another key
-// during that 500ms, it will be cancelled and we'll wait another 500ms.
-Ext.get('myInputField').on('keypress', function(){
- task.{@link #delay}(500);
-});
- *
- *
Note that we are using a DelayedTask here to illustrate a point. The configuration
- * option buffer for {@link Ext.util.Observable#addListener addListener/on} will
- * also setup a delayed task for you to buffer events.
- * @constructor The parameters to this constructor serve as defaults and are not required.
- * @param {Function} fn (optional) The default function to call.
- * @param {Object} scope The default scope (The this reference) in which the
- * function is called. If not specified, this will refer to the browser window.
- * @param {Array} args (optional) The default Array of arguments.
- */
-Ext.util.DelayedTask = function(fn, scope, args){
- var me = this,
- id,
- call = function(){
- clearInterval(id);
- id = null;
- fn.apply(scope, args || []);
- };
-
/**
- * Cancels any pending timeout and queues a new one
- * @param {Number} delay The milliseconds to delay
- * @param {Function} newFn (optional) Overrides function passed to constructor
- * @param {Object} newScope (optional) Overrides scope passed to constructor. Remember that if no scope
- * is specified, this will refer to the browser window.
- * @param {Array} newArgs (optional) Overrides args passed to constructor
+ * @method
+ * @member Ext
+ * @alias Ext.Array#each
*/
- me.delay = function(delay, newFn, newScope, newArgs){
- me.cancel();
- fn = newFn || fn;
- scope = newScope || scope;
- args = newArgs || args;
- id = setInterval(call, delay);
- };
+ Ext.each = ExtArray.each;
/**
- * Cancel the last queued timeout
+ * @method
+ * @member Ext.Array
+ * @alias Ext.Array#merge
*/
- me.cancel = function(){
- if(id){
- clearInterval(id);
- id = null;
- }
- };
-};/**
- * @class Ext.Element
- *
Encapsulates a DOM element, adding simple DOM manipulation facilities, normalizing for browser differences.
- *
All instances of this class inherit the methods of {@link Ext.Fx} making visual effects easily available to all DOM elements.
- *
Note that the events documented in this class are not Ext events, they encapsulate browser events. To
- * access the underlying browser event, see {@link Ext.EventObject#browserEvent}. Some older
- * browsers may not support the full range of events. Which events are supported is beyond the control of ExtJs.
- * Usage:
-
-// by id
-var el = Ext.get("my-div");
+ ExtArray.union = ExtArray.merge;
-// by DOM element reference
-var el = Ext.get(myDivElement);
-
- * Animations
- *
When an element is manipulated, by default there is no animation.
- *
-var el = Ext.get("my-div");
+ /**
+ * Old alias to {@link Ext.Array#min}
+ * @deprecated 4.0.0 Use {@link Ext.Array#min} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#min
+ */
+ Ext.min = ExtArray.min;
-// no animation
-el.setWidth(100);
- *
- *
Many of the functions for manipulating an element have an optional "animate" parameter. This
- * parameter can be specified as boolean (true) for default animation effects.
To configure the effects, an object literal with animation options to use as the Element animation
- * configuration object can also be specified. Note that the supported Element animation configuration
- * options are a subset of the {@link Ext.Fx} animation options specific to Fx effects. The supported
- * Element animation configuration options are:
-
-Option Default Description
---------- -------- ---------------------------------------------
-{@link Ext.Fx#duration duration} .35 The duration of the animation in seconds
-{@link Ext.Fx#easing easing} easeOut The easing method
-{@link Ext.Fx#callback callback} none A function to execute when the anim completes
-{@link Ext.Fx#scope scope} this The scope (this) of the callback function
-
- *
- *
-// Element animation options object
-var opt = {
- {@link Ext.Fx#duration duration}: 1,
- {@link Ext.Fx#easing easing}: 'elasticIn',
- {@link Ext.Fx#callback callback}: this.foo,
- {@link Ext.Fx#scope scope}: this
-};
-// animation with some options set
-el.setWidth(100, opt);
- *
- *
The Element animation object being used for the animation will be set on the options
- * object as "anim", which allows you to stop or manipulate the animation. Here is an example:
- *
-// using the "anim" property to get the Anim object
-if(opt.anim.isAnimated()){
- opt.anim.stop();
-}
- *
- *
Also see the {@link #animate} method for another animation technique.
- *
Composite (Collections of) Elements
- *
For working with collections of Elements, see {@link Ext.CompositeElement}
- * @constructor Create a new Element directly.
- * @param {String/HTMLElement} element
- * @param {Boolean} forceNew (optional) By default the constructor checks to see if there is already an instance of this element in the cache and if there is it returns the same instance. This will skip that check (useful for extending this class).
- */
-(function(){
-var DOC = document;
+ /**
+ * Old alias to {@link Ext.Array#max}
+ * @deprecated 4.0.0 Use {@link Ext.Array#max} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#max
+ */
+ Ext.max = ExtArray.max;
-Ext.Element = function(element, forceNew){
- var dom = typeof element == "string" ?
- DOC.getElementById(element) : element,
- id;
+ /**
+ * Old alias to {@link Ext.Array#sum}
+ * @deprecated 4.0.0 Use {@link Ext.Array#sum} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#sum
+ */
+ Ext.sum = ExtArray.sum;
- if(!dom) return null;
+ /**
+ * Old alias to {@link Ext.Array#mean}
+ * @deprecated 4.0.0 Use {@link Ext.Array#mean} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#mean
+ */
+ Ext.mean = ExtArray.mean;
- id = dom.id;
+ /**
+ * Old alias to {@link Ext.Array#flatten}
+ * @deprecated 4.0.0 Use {@link Ext.Array#flatten} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#flatten
+ */
+ Ext.flatten = ExtArray.flatten;
- if(!forceNew && id && Ext.elCache[id]){ // element object already exists
- return Ext.elCache[id].el;
- }
+ /**
+ * Old alias to {@link Ext.Array#clean}
+ * @deprecated 4.0.0 Use {@link Ext.Array#clean} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#clean
+ */
+ Ext.clean = ExtArray.clean;
/**
- * The DOM element
- * @type HTMLElement
+ * Old alias to {@link Ext.Array#unique}
+ * @deprecated 4.0.0 Use {@link Ext.Array#unique} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#unique
*/
- this.dom = dom;
+ Ext.unique = ExtArray.unique;
/**
- * The DOM element ID
- * @type String
+ * Old alias to {@link Ext.Array#pluck Ext.Array.pluck}
+ * @deprecated 4.0.0 Use {@link Ext.Array#pluck Ext.Array.pluck} instead
+ * @method
+ * @member Ext
+ * @alias Ext.Array#pluck
*/
- this.id = id || Ext.id(dom);
-};
+ Ext.pluck = ExtArray.pluck;
+
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.Array#toArray
+ */
+ Ext.toArray = function() {
+ return ExtArray.toArray.apply(ExtArray, arguments);
+ };
+})();
-var DH = Ext.DomHelper,
- El = Ext.Element,
- EC = Ext.elCache;
+/**
+ * @class Ext.Function
+ *
+ * A collection of useful static methods to deal with function callbacks
+ * @singleton
+ */
+Ext.Function = {
-El.prototype = {
/**
- * Sets the passed attributes as attributes of this element (a style attribute can be a string, object or function)
- * @param {Object} o The object with the attributes
- * @param {Boolean} useSet (optional) false to override the default setAttribute to use expandos.
- * @return {Ext.Element} this
+ * A very commonly used method throughout the framework. It acts as a wrapper around another method
+ * which originally accepts 2 arguments for `name` and `value`.
+ * The wrapped function then allows "flexible" value setting of either:
+ *
+ * - `name` and `value` as 2 arguments
+ * - one single object argument with multiple key - value pairs
+ *
+ * For example:
+ *
+ * var setValue = Ext.Function.flexSetter(function(name, value) {
+ * this[name] = value;
+ * });
+ *
+ * // Afterwards
+ * // Setting a single name - value
+ * setValue('name1', 'value1');
+ *
+ * // Settings multiple name - value pairs
+ * setValue({
+ * name1: 'value1',
+ * name2: 'value2',
+ * name3: 'value3'
+ * });
+ *
+ * @param {Function} setter
+ * @returns {Function} flexSetter
*/
- set : function(o, useSet){
- var el = this.dom,
- attr,
- val,
- useSet = (useSet !== false) && !!el.setAttribute;
+ flexSetter: function(fn) {
+ return function(a, b) {
+ var k, i;
- for (attr in o) {
- if (o.hasOwnProperty(attr)) {
- val = o[attr];
- if (attr == 'style') {
- DH.applyStyles(el, val);
- } else if (attr == 'cls') {
- el.className = val;
- } else if (useSet) {
- el.setAttribute(attr, val);
- } else {
- el[attr] = val;
+ if (a === null) {
+ return this;
+ }
+
+ if (typeof a !== 'string') {
+ for (k in a) {
+ if (a.hasOwnProperty(k)) {
+ fn.call(this, k, a[k]);
+ }
}
+
+ if (Ext.enumerables) {
+ for (i = Ext.enumerables.length; i--;) {
+ k = Ext.enumerables[i];
+ if (a.hasOwnProperty(k)) {
+ fn.call(this, k, a[k]);
+ }
+ }
+ }
+ } else {
+ fn.call(this, a, b);
}
- }
- return this;
+
+ return this;
+ };
},
-// Mouse events
- /**
- * @event click
- * Fires when a mouse click is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
/**
- * @event contextmenu
- * Fires when a right click is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Create a new function from the provided `fn`, change `this` to the provided scope, optionally
+ * overrides arguments for the call. (Defaults to the arguments passed by the caller)
+ *
+ * {@link Ext#bind Ext.bind} is alias for {@link Ext.Function#bind Ext.Function.bind}
+ *
+ * @param {Function} fn The function to delegate.
+ * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
+ * **If omitted, defaults to the browser window.**
+ * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
+ * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
+ * if a number the args are inserted at the specified position
+ * @return {Function} The new function
*/
+ bind: function(fn, scope, args, appendArgs) {
+ var method = fn,
+ slice = Array.prototype.slice;
+
+ return function() {
+ var callArgs = args || arguments;
+
+ if (appendArgs === true) {
+ callArgs = slice.call(arguments, 0);
+ callArgs = callArgs.concat(args);
+ }
+ else if (Ext.isNumber(appendArgs)) {
+ callArgs = slice.call(arguments, 0); // copy arguments first
+ Ext.Array.insert(callArgs, appendArgs, args);
+ }
+
+ return method.apply(scope || window, callArgs);
+ };
+ },
+
/**
- * @event dblclick
- * Fires when a mouse double click is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Create a new function from the provided `fn`, the arguments of which are pre-set to `args`.
+ * New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones.
+ * This is especially useful when creating callbacks.
+ *
+ * For example:
+ *
+ * var originalFunction = function(){
+ * alert(Ext.Array.from(arguments).join(' '));
+ * };
+ *
+ * var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']);
+ *
+ * callback(); // alerts 'Hello World'
+ * callback('by Me'); // alerts 'Hello World by Me'
+ *
+ * {@link Ext#pass Ext.pass} is alias for {@link Ext.Function#pass Ext.Function.pass}
+ *
+ * @param {Function} fn The original function
+ * @param {Array} args The arguments to pass to new callback
+ * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
+ * @return {Function} The new callback function
*/
+ pass: function(fn, args, scope) {
+ if (args) {
+ args = Ext.Array.from(args);
+ }
+
+ return function() {
+ return fn.apply(scope, args.concat(Ext.Array.toArray(arguments)));
+ };
+ },
+
/**
- * @event mousedown
- * Fires when a mousedown is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Create an alias to the provided method property with name `methodName` of `object`.
+ * Note that the execution scope will still be bound to the provided `object` itself.
+ *
+ * @param {Object/Function} object
+ * @param {String} methodName
+ * @return {Function} aliasFn
*/
+ alias: function(object, methodName) {
+ return function() {
+ return object[methodName].apply(object, arguments);
+ };
+ },
+
/**
- * @event mouseup
- * Fires when a mouseup is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Creates an interceptor function. The passed function is called before the original one. If it returns false,
+ * the original one is not called. The resulting function returns the results of the original function.
+ * The passed function is called with the parameters of the original function. Example usage:
+ *
+ * var sayHi = function(name){
+ * alert('Hi, ' + name);
+ * }
+ *
+ * sayHi('Fred'); // alerts "Hi, Fred"
+ *
+ * // create a new function that validates input without
+ * // directly modifying the original function:
+ * var sayHiToFriend = Ext.Function.createInterceptor(sayHi, function(name){
+ * return name == 'Brian';
+ * });
+ *
+ * sayHiToFriend('Fred'); // no alert
+ * sayHiToFriend('Brian'); // alerts "Hi, Brian"
+ *
+ * @param {Function} origFn The original function.
+ * @param {Function} newFn The function to call before the original
+ * @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed.
+ * **If omitted, defaults to the scope in which the original function is called or the browser window.**
+ * @param {Mixed} returnValue (optional) The value to return if the passed function return false (defaults to null).
+ * @return {Function} The new function
*/
+ createInterceptor: function(origFn, newFn, scope, returnValue) {
+ var method = origFn;
+ if (!Ext.isFunction(newFn)) {
+ return origFn;
+ }
+ else {
+ return function() {
+ var me = this,
+ args = arguments;
+ newFn.target = me;
+ newFn.method = origFn;
+ return (newFn.apply(scope || me || window, args) !== false) ? origFn.apply(me || window, args) : returnValue || null;
+ };
+ }
+ },
+
/**
- * @event mouseover
- * Fires when a mouseover is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Creates a delegate (callback) which, when called, executes after a specific delay.
+ *
+ * @param {Function} fn The function which will be called on a delay when the returned function is called.
+ * Optionally, a replacement (or additional) argument list may be specified.
+ * @param {Number} delay The number of milliseconds to defer execution by whenever called.
+ * @param {Object} scope (optional) The scope (`this` reference) used by the function at execution time.
+ * @param {Array} args (optional) Override arguments for the call. (Defaults to the arguments passed by the caller)
+ * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
+ * if a number the args are inserted at the specified position.
+ * @return {Function} A function which, when called, executes the original function after the specified delay.
*/
+ createDelayed: function(fn, delay, scope, args, appendArgs) {
+ if (scope || args) {
+ fn = Ext.Function.bind(fn, scope, args, appendArgs);
+ }
+ return function() {
+ var me = this;
+ setTimeout(function() {
+ fn.apply(me, arguments);
+ }, delay);
+ };
+ },
+
/**
- * @event mousemove
- * Fires when a mousemove is detected with the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
+ *
+ * var sayHi = function(name){
+ * alert('Hi, ' + name);
+ * }
+ *
+ * // executes immediately:
+ * sayHi('Fred');
+ *
+ * // executes after 2 seconds:
+ * Ext.Function.defer(sayHi, 2000, this, ['Fred']);
+ *
+ * // this syntax is sometimes useful for deferring
+ * // execution of an anonymous function:
+ * Ext.Function.defer(function(){
+ * alert('Anonymous');
+ * }, 100);
+ *
+ * {@link Ext#defer Ext.defer} is alias for {@link Ext.Function#defer Ext.Function.defer}
+ *
+ * @param {Function} fn The function to defer.
+ * @param {Number} millis The number of milliseconds for the setTimeout call
+ * (if less than or equal to 0 the function is executed immediately)
+ * @param {Object} scope (optional) The scope (`this` reference) in which the function is executed.
+ * **If omitted, defaults to the browser window.**
+ * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
+ * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
+ * if a number the args are inserted at the specified position
+ * @return {Number} The timeout id that can be used with clearTimeout
*/
+ defer: function(fn, millis, obj, args, appendArgs) {
+ fn = Ext.Function.bind(fn, obj, args, appendArgs);
+ if (millis > 0) {
+ return setTimeout(fn, millis);
+ }
+ fn();
+ return 0;
+ },
+
/**
- * @event mouseout
- * Fires when a mouseout is detected with the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Create a combined function call sequence of the original function + the passed function.
+ * The resulting function returns the results of the original function.
+ * The passed function is called with the parameters of the original function. Example usage:
+ *
+ * var sayHi = function(name){
+ * alert('Hi, ' + name);
+ * }
+ *
+ * sayHi('Fred'); // alerts "Hi, Fred"
+ *
+ * var sayGoodbye = Ext.Function.createSequence(sayHi, function(name){
+ * alert('Bye, ' + name);
+ * });
+ *
+ * sayGoodbye('Fred'); // both alerts show
+ *
+ * @param {Function} origFn The original function.
+ * @param {Function} newFn The function to sequence
+ * @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed.
+ * If omitted, defaults to the scope in which the original function is called or the browser window.
+ * @return {Function} The new function
*/
+ createSequence: function(origFn, newFn, scope) {
+ if (!Ext.isFunction(newFn)) {
+ return origFn;
+ }
+ else {
+ return function() {
+ var retval = origFn.apply(this || window, arguments);
+ newFn.apply(scope || this || window, arguments);
+ return retval;
+ };
+ }
+ },
+
/**
- * @event mouseenter
- * Fires when the mouse enters the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
+ * Creates a delegate function, optionally with a bound scope which, when called, buffers
+ * the execution of the passed function for the configured number of milliseconds.
+ * If called again within that period, the impending invocation will be canceled, and the
+ * timeout period will begin again.
+ *
+ * @param {Function} fn The function to invoke on a buffered timer.
+ * @param {Number} buffer The number of milliseconds by which to buffer the invocation of the
+ * function.
+ * @param {Object} scope (optional) The scope (`this` reference) in which
+ * the passed function is executed. If omitted, defaults to the scope specified by the caller.
+ * @param {Array} args (optional) Override arguments for the call. Defaults to the arguments
+ * passed by the caller.
+ * @return {Function} A function which invokes the passed function after buffering for the specified time.
+ */
+ createBuffered: function(fn, buffer, scope, args) {
+ return function(){
+ var timerId;
+ return function() {
+ var me = this;
+ if (timerId) {
+ clearInterval(timerId);
+ timerId = null;
+ }
+ timerId = setTimeout(function(){
+ fn.apply(scope || me, args || arguments);
+ }, buffer);
+ };
+ }();
+ },
+
/**
- * @event mouseleave
- * Fires when the mouse leaves the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
+ * Creates a throttled version of the passed function which, when called repeatedly and
+ * rapidly, invokes the passed function only after a certain interval has elapsed since the
+ * previous invocation.
+ *
+ * This is useful for wrapping functions which may be called repeatedly, such as
+ * a handler of a mouse move event when the processing is expensive.
+ *
+ * @param {Function} fn The function to execute at a regular time interval.
+ * @param {Number} interval The interval **in milliseconds** on which the passed function is executed.
+ * @param {Object} scope (optional) The scope (`this` reference) in which
+ * the passed function is executed. If omitted, defaults to the scope specified by the caller.
+ * @returns {Function} A function which invokes the passed function at the specified interval.
+ */
+ createThrottled: function(fn, interval, scope) {
+ var lastCallTime, elapsed, lastArgs, timer, execute = function() {
+ fn.apply(scope || this, lastArgs);
+ lastCallTime = new Date().getTime();
+ };
+
+ return function() {
+ elapsed = new Date().getTime() - lastCallTime;
+ lastArgs = arguments;
+
+ clearTimeout(timer);
+ if (!lastCallTime || (elapsed >= interval)) {
+ execute();
+ } else {
+ timer = setTimeout(execute, interval - elapsed);
+ }
+ };
+ }
+};
+
+/**
+ * @method
+ * @member Ext
+ * @alias Ext.Function#defer
+ */
+Ext.defer = Ext.Function.alias(Ext.Function, 'defer');
+
+/**
+ * @method
+ * @member Ext
+ * @alias Ext.Function#pass
+ */
+Ext.pass = Ext.Function.alias(Ext.Function, 'pass');
+
+/**
+ * @method
+ * @member Ext
+ * @alias Ext.Function#bind
+ */
+Ext.bind = Ext.Function.alias(Ext.Function, 'bind');
+
+/**
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.Object
+ *
+ * A collection of useful static methods to deal with objects
+ *
+ * @singleton
+ */
+
+(function() {
+
+var ExtObject = Ext.Object = {
-// Keyboard events
/**
- * @event keypress
- * Fires when a keypress is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Convert a `name` - `value` pair to an array of objects with support for nested structures; useful to construct
+ * query strings. For example:
+
+ var objects = Ext.Object.toQueryObjects('hobbies', ['reading', 'cooking', 'swimming']);
+
+ // objects then equals:
+ [
+ { name: 'hobbies', value: 'reading' },
+ { name: 'hobbies', value: 'cooking' },
+ { name: 'hobbies', value: 'swimming' },
+ ];
+
+ var objects = Ext.Object.toQueryObjects('dateOfBirth', {
+ day: 3,
+ month: 8,
+ year: 1987,
+ extra: {
+ hour: 4
+ minute: 30
+ }
+ }, true); // Recursive
+
+ // objects then equals:
+ [
+ { name: 'dateOfBirth[day]', value: 3 },
+ { name: 'dateOfBirth[month]', value: 8 },
+ { name: 'dateOfBirth[year]', value: 1987 },
+ { name: 'dateOfBirth[extra][hour]', value: 4 },
+ { name: 'dateOfBirth[extra][minute]', value: 30 },
+ ];
+
+ * @param {String} name
+ * @param {Mixed} value
+ * @param {Boolean} recursive
+ * @markdown
*/
+ toQueryObjects: function(name, value, recursive) {
+ var self = ExtObject.toQueryObjects,
+ objects = [],
+ i, ln;
+
+ if (Ext.isArray(value)) {
+ for (i = 0, ln = value.length; i < ln; i++) {
+ if (recursive) {
+ objects = objects.concat(self(name + '[' + i + ']', value[i], true));
+ }
+ else {
+ objects.push({
+ name: name,
+ value: value[i]
+ });
+ }
+ }
+ }
+ else if (Ext.isObject(value)) {
+ for (i in value) {
+ if (value.hasOwnProperty(i)) {
+ if (recursive) {
+ objects = objects.concat(self(name + '[' + i + ']', value[i], true));
+ }
+ else {
+ objects.push({
+ name: name,
+ value: value[i]
+ });
+ }
+ }
+ }
+ }
+ else {
+ objects.push({
+ name: name,
+ value: value
+ });
+ }
+
+ return objects;
+ },
+
/**
- * @event keydown
- * Fires when a keydown is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Takes an object and converts it to an encoded query string
+
+- Non-recursive:
+
+ Ext.Object.toQueryString({foo: 1, bar: 2}); // returns "foo=1&bar=2"
+ Ext.Object.toQueryString({foo: null, bar: 2}); // returns "foo=&bar=2"
+ Ext.Object.toQueryString({'some price': '$300'}); // returns "some%20price=%24300"
+ Ext.Object.toQueryString({date: new Date(2011, 0, 1)}); // returns "date=%222011-01-01T00%3A00%3A00%22"
+ Ext.Object.toQueryString({colors: ['red', 'green', 'blue']}); // returns "colors=red&colors=green&colors=blue"
+
+- Recursive:
+
+ Ext.Object.toQueryString({
+ username: 'Jacky',
+ dateOfBirth: {
+ day: 1,
+ month: 2,
+ year: 1911
+ },
+ hobbies: ['coding', 'eating', 'sleeping', ['nested', 'stuff']]
+ }, true); // returns the following string (broken down and url-decoded for ease of reading purpose):
+ // username=Jacky
+ // &dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1911
+ // &hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&hobbies[3][0]=nested&hobbies[3][1]=stuff
+
+ *
+ * @param {Object} object The object to encode
+ * @param {Boolean} recursive (optional) Whether or not to interpret the object in recursive format.
+ * (PHP / Ruby on Rails servers and similar). Defaults to false
+ * @return {String} queryString
+ * @markdown
*/
+ toQueryString: function(object, recursive) {
+ var paramObjects = [],
+ params = [],
+ i, j, ln, paramObject, value;
+
+ for (i in object) {
+ if (object.hasOwnProperty(i)) {
+ paramObjects = paramObjects.concat(ExtObject.toQueryObjects(i, object[i], recursive));
+ }
+ }
+
+ for (j = 0, ln = paramObjects.length; j < ln; j++) {
+ paramObject = paramObjects[j];
+ value = paramObject.value;
+
+ if (Ext.isEmpty(value)) {
+ value = '';
+ }
+ else if (Ext.isDate(value)) {
+ value = Ext.Date.toString(value);
+ }
+
+ params.push(encodeURIComponent(paramObject.name) + '=' + encodeURIComponent(String(value)));
+ }
+
+ return params.join('&');
+ },
+
/**
- * @event keyup
- * Fires when a keyup is detected within the element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Converts a query string back into an object.
+ *
+- Non-recursive:
+
+ Ext.Object.fromQueryString(foo=1&bar=2); // returns {foo: 1, bar: 2}
+ Ext.Object.fromQueryString(foo=&bar=2); // returns {foo: null, bar: 2}
+ Ext.Object.fromQueryString(some%20price=%24300); // returns {'some price': '$300'}
+ Ext.Object.fromQueryString(colors=red&colors=green&colors=blue); // returns {colors: ['red', 'green', 'blue']}
+
+- Recursive:
+
+ Ext.Object.fromQueryString("username=Jacky&dateOfBirth[day]=1&dateOfBirth[month]=2&dateOfBirth[year]=1911&hobbies[0]=coding&hobbies[1]=eating&hobbies[2]=sleeping&hobbies[3][0]=nested&hobbies[3][1]=stuff", true);
+
+ // returns
+ {
+ username: 'Jacky',
+ dateOfBirth: {
+ day: '1',
+ month: '2',
+ year: '1911'
+ },
+ hobbies: ['coding', 'eating', 'sleeping', ['nested', 'stuff']]
+ }
+
+ * @param {String} queryString The query string to decode
+ * @param {Boolean} recursive (Optional) Whether or not to recursively decode the string. This format is supported by
+ * PHP / Ruby on Rails servers and similar. Defaults to false
+ * @return {Object}
*/
+ fromQueryString: function(queryString, recursive) {
+ var parts = queryString.replace(/^\?/, '').split('&'),
+ object = {},
+ temp, components, name, value, i, ln,
+ part, j, subLn, matchedKeys, matchedName,
+ keys, key, nextKey;
+
+ for (i = 0, ln = parts.length; i < ln; i++) {
+ part = parts[i];
+
+ if (part.length > 0) {
+ components = part.split('=');
+ name = decodeURIComponent(components[0]);
+ value = (components[1] !== undefined) ? decodeURIComponent(components[1]) : '';
+
+ if (!recursive) {
+ if (object.hasOwnProperty(name)) {
+ if (!Ext.isArray(object[name])) {
+ object[name] = [object[name]];
+ }
+
+ object[name].push(value);
+ }
+ else {
+ object[name] = value;
+ }
+ }
+ else {
+ matchedKeys = name.match(/(\[):?([^\]]*)\]/g);
+ matchedName = name.match(/^([^\[]+)/);
+
+
+ name = matchedName[0];
+ keys = [];
+
+ if (matchedKeys === null) {
+ object[name] = value;
+ continue;
+ }
+
+ for (j = 0, subLn = matchedKeys.length; j < subLn; j++) {
+ key = matchedKeys[j];
+ key = (key.length === 2) ? '' : key.substring(1, key.length - 1);
+ keys.push(key);
+ }
+
+ keys.unshift(name);
+
+ temp = object;
+
+ for (j = 0, subLn = keys.length; j < subLn; j++) {
+ key = keys[j];
+
+ if (j === subLn - 1) {
+ if (Ext.isArray(temp) && key === '') {
+ temp.push(value);
+ }
+ else {
+ temp[key] = value;
+ }
+ }
+ else {
+ if (temp[key] === undefined || typeof temp[key] === 'string') {
+ nextKey = keys[j+1];
+
+ temp[key] = (Ext.isNumeric(nextKey) || nextKey === '') ? [] : {};
+ }
+
+ temp = temp[key];
+ }
+ }
+ }
+ }
+ }
+ return object;
+ },
-// HTML frame/object events
/**
- * @event load
- * Fires when the user agent finishes loading all content within the element. Only supported by window, frames, objects and images.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Iterate through an object and invoke the given callback function for each iteration. The iteration can be stop
+ * by returning `false` in the callback function. For example:
+
+ var person = {
+ name: 'Jacky'
+ hairColor: 'black'
+ loves: ['food', 'sleeping', 'wife']
+ };
+
+ Ext.Object.each(person, function(key, value, myself) {
+ console.log(key + ":" + value);
+
+ if (key === 'hairColor') {
+ return false; // stop the iteration
+ }
+ });
+
+ * @param {Object} object The object to iterate
+ * @param {Function} fn The callback function. Passed arguments for each iteration are:
+
+- {String} `key`
+- {Mixed} `value`
+- {Object} `object` The object itself
+
+ * @param {Object} scope (Optional) The execution scope (`this`) of the callback function
+ * @markdown
*/
+ each: function(object, fn, scope) {
+ for (var property in object) {
+ if (object.hasOwnProperty(property)) {
+ if (fn.call(scope || object, property, object[property], object) === false) {
+ return;
+ }
+ }
+ }
+ },
+
/**
- * @event unload
- * Fires when the user agent removes all content from a window or frame. For elements, it fires when the target element or any of its content has been removed.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Merges any number of objects recursively without referencing them or their children.
+
+ var extjs = {
+ companyName: 'Ext JS',
+ products: ['Ext JS', 'Ext GWT', 'Ext Designer'],
+ isSuperCool: true
+ office: {
+ size: 2000,
+ location: 'Palo Alto',
+ isFun: true
+ }
+ };
+
+ var newStuff = {
+ companyName: 'Sencha Inc.',
+ products: ['Ext JS', 'Ext GWT', 'Ext Designer', 'Sencha Touch', 'Sencha Animator'],
+ office: {
+ size: 40000,
+ location: 'Redwood City'
+ }
+ };
+
+ var sencha = Ext.Object.merge(extjs, newStuff);
+
+ // extjs and sencha then equals to
+ {
+ companyName: 'Sencha Inc.',
+ products: ['Ext JS', 'Ext GWT', 'Ext Designer', 'Sencha Touch', 'Sencha Animator'],
+ isSuperCool: true
+ office: {
+ size: 30000,
+ location: 'Redwood City'
+ isFun: true
+ }
+ }
+
+ * @param {Object} object,...
+ * @return {Object} merged The object that is created as a result of merging all the objects passed in.
+ * @markdown
*/
+ merge: function(source, key, value) {
+ if (typeof key === 'string') {
+ if (value && value.constructor === Object) {
+ if (source[key] && source[key].constructor === Object) {
+ ExtObject.merge(source[key], value);
+ }
+ else {
+ source[key] = Ext.clone(value);
+ }
+ }
+ else {
+ source[key] = value;
+ }
+
+ return source;
+ }
+
+ var i = 1,
+ ln = arguments.length,
+ object, property;
+
+ for (; i < ln; i++) {
+ object = arguments[i];
+
+ for (property in object) {
+ if (object.hasOwnProperty(property)) {
+ ExtObject.merge(source, property, object[property]);
+ }
+ }
+ }
+
+ return source;
+ },
+
/**
- * @event abort
- * Fires when an object/image is stopped from loading before completely loaded.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Returns the first matching key corresponding to the given value.
+ * If no matching value is found, null is returned.
+
+ var person = {
+ name: 'Jacky',
+ loves: 'food'
+ };
+
+ alert(Ext.Object.getKey(sencha, 'loves')); // alerts 'food'
+
+ * @param {Object} object
+ * @param {Object} value The value to find
+ * @markdown
*/
+ getKey: function(object, value) {
+ for (var property in object) {
+ if (object.hasOwnProperty(property) && object[property] === value) {
+ return property;
+ }
+ }
+
+ return null;
+ },
+
/**
- * @event error
- * Fires when an object/image/frame cannot be loaded properly.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Gets all values of the given object as an array.
+
+ var values = Ext.Object.getValues({
+ name: 'Jacky',
+ loves: 'food'
+ }); // ['Jacky', 'food']
+
+ * @param {Object} object
+ * @return {Array} An array of values from the object
+ * @markdown
*/
+ getValues: function(object) {
+ var values = [],
+ property;
+
+ for (property in object) {
+ if (object.hasOwnProperty(property)) {
+ values.push(object[property]);
+ }
+ }
+
+ return values;
+ },
+
/**
- * @event resize
- * Fires when a document view is resized.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Gets all keys of the given object as an array.
+
+ var values = Ext.Object.getKeys({
+ name: 'Jacky',
+ loves: 'food'
+ }); // ['name', 'loves']
+
+ * @param {Object} object
+ * @return {Array} An array of keys from the object
+ * @method
*/
+ getKeys: ('keys' in Object.prototype) ? Object.keys : function(object) {
+ var keys = [],
+ property;
+
+ for (property in object) {
+ if (object.hasOwnProperty(property)) {
+ keys.push(property);
+ }
+ }
+
+ return keys;
+ },
+
/**
- * @event scroll
- * Fires when a document view is scrolled.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
+ * Gets the total number of this object's own properties
+
+ var size = Ext.Object.getSize({
+ name: 'Jacky',
+ loves: 'food'
+ }); // size equals 2
+
+ * @param {Object} object
+ * @return {Number} size
+ * @markdown
*/
+ getSize: function(object) {
+ var size = 0,
+ property;
-// Form events
- /**
- * @event select
- * Fires when a user selects some text in a text field, including input and textarea.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event change
- * Fires when a control loses the input focus and its value has been modified since gaining focus.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event submit
- * Fires when a form is submitted.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event reset
- * Fires when a form is reset.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event focus
- * Fires when an element receives focus either via the pointing device or by tab navigation.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event blur
- * Fires when an element loses focus either via the pointing device or by tabbing navigation.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
+ for (property in object) {
+ if (object.hasOwnProperty(property)) {
+ size++;
+ }
+ }
-// User Interface events
- /**
- * @event DOMFocusIn
- * Where supported. Similar to HTML focus event, but can be applied to any focusable element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMFocusOut
- * Where supported. Similar to HTML blur event, but can be applied to any focusable element.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMActivate
- * Where supported. Fires when an element is activated, for instance, through a mouse click or a keypress.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
+ return size;
+ }
+};
-// DOM Mutation events
- /**
- * @event DOMSubtreeModified
- * Where supported. Fires when the subtree is modified.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMNodeInserted
- * Where supported. Fires when a node has been added as a child of another node.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMNodeRemoved
- * Where supported. Fires when a descendant node of the element is removed.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMNodeRemovedFromDocument
- * Where supported. Fires when a node is being removed from a document.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMNodeInsertedIntoDocument
- * Where supported. Fires when a node is being inserted into a document.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMAttrModified
- * Where supported. Fires when an attribute has been modified.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * @event DOMCharacterDataModified
- * Where supported. Fires when the character data has been modified.
- * @param {Ext.EventObject} e The {@link Ext.EventObject} encapsulating the DOM event.
- * @param {HtmlElement} t The target of the event.
- * @param {Object} o The options configuration passed to the {@link #addListener} call.
- */
- /**
- * The default unit to append to CSS values where a unit isn't provided (defaults to px).
- * @type String
- */
- defaultUnit : "px",
+/**
+ * A convenient alias method for {@link Ext.Object#merge}
+ *
+ * @member Ext
+ * @method merge
+ */
+Ext.merge = Ext.Object.merge;
- /**
- * Returns true if this element matches the passed simple selector (e.g. div.some-class or span:first-child)
- * @param {String} selector The simple selector to test
- * @return {Boolean} True if this element matches the selector, else false
- */
- is : function(simpleSelector){
- return Ext.DomQuery.is(this.dom, simpleSelector);
- },
+/**
+ * A convenient alias method for {@link Ext.Object#toQueryString}
+ *
+ * @member Ext
+ * @method urlEncode
+ * @deprecated 4.0.0 Use {@link Ext.Object#toQueryString Ext.Object.toQueryString} instead
+ */
+Ext.urlEncode = function() {
+ var args = Ext.Array.from(arguments),
+ prefix = '';
+
+ // Support for the old `pre` argument
+ if ((typeof args[1] === 'string')) {
+ prefix = args[1] + '&';
+ args[1] = false;
+ }
- /**
- * Tries to focus the element. Any exceptions are caught and ignored.
- * @param {Number} defer (optional) Milliseconds to defer the focus
- * @return {Ext.Element} this
- */
- focus : function(defer, /* private */ dom) {
- var me = this,
- dom = dom || me.dom;
- try{
- if(Number(defer)){
- me.focus.defer(defer, null, [null, dom]);
- }else{
- dom.focus();
- }
- }catch(e){}
- return me;
- },
+ return prefix + Ext.Object.toQueryString.apply(Ext.Object, args);
+};
- /**
- * Tries to blur the element. Any exceptions are caught and ignored.
- * @return {Ext.Element} this
- */
- blur : function() {
- try{
- this.dom.blur();
- }catch(e){}
- return this;
- },
+/**
+ * A convenient alias method for {@link Ext.Object#fromQueryString}
+ *
+ * @member Ext
+ * @method urlDecode
+ * @deprecated 4.0.0 Use {@link Ext.Object#fromQueryString Ext.Object.fromQueryString} instead
+ */
+Ext.urlDecode = function() {
+ return Ext.Object.fromQueryString.apply(Ext.Object, arguments);
+};
- /**
- * Returns the value of the "value" attribute
- * @param {Boolean} asNumber true to parse the value as a number
- * @return {String/Number}
- */
- getValue : function(asNumber){
- var val = this.dom.value;
- return asNumber ? parseInt(val, 10) : val;
- },
+})();
+
+/**
+ * @class Ext.Date
+ * A set of useful static methods to deal with date
+ * Note that if Ext.Date is required and loaded, it will copy all methods / properties to
+ * this object for convenience
+ *
+ * The date parsing and formatting syntax contains a subset of
+ * PHP's date() function, and the formats that are
+ * supported will provide results equivalent to their PHP versions.
+ *
+ * The following is a list of all currently supported formats:
+ *
+Format Description Example returned values
+------ ----------------------------------------------------------------------- -----------------------
+ d Day of the month, 2 digits with leading zeros 01 to 31
+ D A short textual representation of the day of the week Mon to Sun
+ j Day of the month without leading zeros 1 to 31
+ l A full textual representation of the day of the week Sunday to Saturday
+ N ISO-8601 numeric representation of the day of the week 1 (for Monday) through 7 (for Sunday)
+ S English ordinal suffix for the day of the month, 2 characters st, nd, rd or th. Works well with j
+ w Numeric representation of the day of the week 0 (for Sunday) to 6 (for Saturday)
+ z The day of the year (starting from 0) 0 to 364 (365 in leap years)
+ W ISO-8601 week number of year, weeks starting on Monday 01 to 53
+ F A full textual representation of a month, such as January or March January to December
+ m Numeric representation of a month, with leading zeros 01 to 12
+ M A short textual representation of a month Jan to Dec
+ n Numeric representation of a month, without leading zeros 1 to 12
+ t Number of days in the given month 28 to 31
+ L Whether it's a leap year 1 if it is a leap year, 0 otherwise.
+ o ISO-8601 year number (identical to (Y), but if the ISO week number (W) Examples: 1998 or 2004
+ belongs to the previous or next year, that year is used instead)
+ Y A full numeric representation of a year, 4 digits Examples: 1999 or 2003
+ y A two digit representation of a year Examples: 99 or 03
+ a Lowercase Ante meridiem and Post meridiem am or pm
+ A Uppercase Ante meridiem and Post meridiem AM or PM
+ g 12-hour format of an hour without leading zeros 1 to 12
+ G 24-hour format of an hour without leading zeros 0 to 23
+ h 12-hour format of an hour with leading zeros 01 to 12
+ H 24-hour format of an hour with leading zeros 00 to 23
+ i Minutes, with leading zeros 00 to 59
+ s Seconds, with leading zeros 00 to 59
+ u Decimal fraction of a second Examples:
+ (minimum 1 digit, arbitrary number of digits allowed) 001 (i.e. 0.001s) or
+ 100 (i.e. 0.100s) or
+ 999 (i.e. 0.999s) or
+ 999876543210 (i.e. 0.999876543210s)
+ O Difference to Greenwich time (GMT) in hours and minutes Example: +1030
+ P Difference to Greenwich time (GMT) with colon between hours and minutes Example: -08:00
+ T Timezone abbreviation of the machine running the code Examples: EST, MDT, PDT ...
+ Z Timezone offset in seconds (negative if west of UTC, positive if east) -43200 to 50400
+ c ISO 8601 date
+ Notes: Examples:
+ 1) If unspecified, the month / day defaults to the current month / day, 1991 or
+ the time defaults to midnight, while the timezone defaults to the 1992-10 or
+ browser's timezone. If a time is specified, it must include both hours 1993-09-20 or
+ and minutes. The "T" delimiter, seconds, milliseconds and timezone 1994-08-19T16:20+01:00 or
+ are optional. 1995-07-18T17:21:28-02:00 or
+ 2) The decimal fraction of a second, if specified, must contain at 1996-06-17T18:22:29.98765+03:00 or
+ least 1 digit (there is no limit to the maximum number 1997-05-16T19:23:30,12345-0400 or
+ of digits allowed), and may be delimited by either a '.' or a ',' 1998-04-15T20:24:31.2468Z or
+ Refer to the examples on the right for the various levels of 1999-03-14T20:24:32Z or
+ date-time granularity which are supported, or see 2000-02-13T21:25:33
+ http://www.w3.org/TR/NOTE-datetime for more info. 2001-01-12 22:26:34
+ U Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT) 1193432466 or -2138434463
+ MS Microsoft AJAX serialized dates \/Date(1238606590509)\/ (i.e. UTC milliseconds since epoch) or
+ \/Date(1238606590509+0800)\/
+
+ *
+ * Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
+ *
+// Sample date:
+// 'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
+
+var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
+console.log(Ext.Date.format(dt, 'Y-m-d')); // 2007-01-10
+console.log(Ext.Date.format(dt, 'F j, Y, g:i a')); // January 10, 2007, 3:05 pm
+console.log(Ext.Date.format(dt, 'l, \\t\\he jS \\of F Y h:i:s A')); // Wednesday, the 10th of January 2007 03:05:01 PM
+
+ *
+ * Here are some standard date/time patterns that you might find helpful. They
+ * are not part of the source of Ext.Date, but to use them you can simply copy this
+ * block of code into any script that is included after Ext.Date and they will also become
+ * globally available on the Date object. Feel free to add or remove patterns as needed in your code.
+ *
+var dt = new Date();
+console.log(Ext.Date.format(dt, Ext.Date.patterns.ShortDate));
+
+ *
Developer-written, custom formats may be used by supplying both a formatting and a parsing function
+ * which perform to specialized requirements. The functions are stored in {@link #parseFunctions} and {@link #formatFunctions}.
+ * @singleton
+ */
+
+/*
+ * Most of the date-formatting functions below are the excellent work of Baron Schwartz.
+ * (see http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/)
+ * They generate precompiled functions from format patterns instead of parsing and
+ * processing each pattern every time a date is formatted. These functions are available
+ * on every Date object.
+ */
+
+(function() {
+
+// create private copy of Ext's Ext.util.Format.format() method
+// - to remove unnecessary dependency
+// - to resolve namespace conflict with MS-Ajax's implementation
+function xf(format) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ return format.replace(/\{(\d+)\}/g, function(m, i) {
+ return args[i];
+ });
+}
+Ext.Date = {
/**
- * Appends an event handler to this element. The shorthand version {@link #on} is equivalent.
- * @param {String} eventName The name of event to handle.
- * @param {Function} fn The handler function the event invokes. This function is passed
- * the following parameters:
- *
evt : EventObject
The {@link Ext.EventObject EventObject} describing the event.
- *
el : HtmlElement
The DOM element which was the target of the event.
- * Note that this may be filtered by using the delegate option.
- *
o : Object
The options object from the addListener call.
- *
- * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed.
- * If omitted, defaults to this Element..
- * @param {Object} options (optional) An object containing handler configuration properties.
- * This may contain any of the following properties:
- *
scope Object :
The scope (this reference) in which the handler function is executed.
- * If omitted, defaults to this Element.
- *
delegate String:
A simple selector to filter the target or look for a descendant of the target. See below for additional details.
- *
stopEvent Boolean:
True to stop the event. That is stop propagation, and prevent the default action.
- *
preventDefault Boolean:
True to prevent the default action
- *
stopPropagation Boolean:
True to prevent event propagation
- *
normalized Boolean:
False to pass a browser event to the handler function instead of an Ext.EventObject
- *
target Ext.Element:
Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node.
- *
delay Number:
The number of milliseconds to delay the invocation of the handler after the event fires.
- *
single Boolean:
True to add a handler to handle just the next firing of the event, and then remove itself.
- *
buffer Number:
Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
- * by the specified number of milliseconds. If the event fires again within that time, the original
- * handler is not invoked, but the new handler is scheduled in its place.
- *
- *
- * Combining Options
- * In the following examples, the shorthand form {@link #on} is used rather than the more verbose
- * addListener. The two are equivalent. Using the options argument, it is possible to combine different
- * types of listeners:
- *
- * A delayed, one-time listener that auto stops the event and adds a custom argument (forumId) to the
- * options object. The options object is available as the third parameter in the handler function.
- * Attaching multiple handlers in 1 call
- * The method also allows for a single argument to be passed which is a config object containing properties
- * which specify multiple handlers.
This is a configuration option that you can pass along when registering a handler for
- * an event to assist with event delegation. Event delegation is a technique that is used to
- * reduce memory consumption and prevent exposure to memory-leaks. By registering an event
- * for a container element as opposed to each element within a container. By setting this
- * configuration option to a simple selector, the target element will be filtered to look for
- * a descendant of the target.
- * For example:
-// using this markup:
-<div id='elId'>
- <p id='p1'>paragraph one</p>
- <p id='p2' class='clickable'>paragraph two</p>
- <p id='p3'>paragraph three</p>
-</div>
-// utilize event delegation to registering just one handler on the container element:
-el = Ext.get('elId');
-el.on(
- 'click',
- function(e,t) {
- // handle click
- console.info(t.id); // 'p2'
- },
- this,
- {
- // filter the target element to be a descendant with the class 'clickable'
- delegate: '.clickable'
- }
-);
- *
- * @return {Ext.Element} this
+ * Returns the current timestamp
+ * @return {Date} The current timestamp
+ * @method
*/
- addListener : function(eventName, fn, scope, options){
- Ext.EventManager.on(this.dom, eventName, fn, scope || this, options);
- return this;
+ now: Date.now || function() {
+ return +new Date();
},
/**
- * Removes an event handler from this element. The shorthand version {@link #un} is equivalent.
- * Note: if a scope was explicitly specified when {@link #addListener adding} the
- * listener, the same scope must be specified here.
- * Example:
- *
-el.removeListener('click', this.handlerFn);
-// or
-el.un('click', this.handlerFn);
-
- * @param {String} eventName The name of the event from which to remove the handler.
- * @param {Function} fn The handler function to remove. This must be a reference to the function passed into the {@link #addListener} call.
- * @param {Object} scope If a scope (this reference) was specified when the listener was added,
- * then this must refer to the same object.
- * @return {Ext.Element} this
+ * @private
+ * Private for now
*/
- removeListener : function(eventName, fn, scope){
- Ext.EventManager.removeListener(this.dom, eventName, fn, scope || this);
- return this;
+ toString: function(date) {
+ var pad = Ext.String.leftPad;
+
+ return date.getFullYear() + "-"
+ + pad(date.getMonth() + 1, 2, '0') + "-"
+ + pad(date.getDate(), 2, '0') + "T"
+ + pad(date.getHours(), 2, '0') + ":"
+ + pad(date.getMinutes(), 2, '0') + ":"
+ + pad(date.getSeconds(), 2, '0');
},
/**
- * Removes all previous added listeners from this element
- * @return {Ext.Element} this
+ * Returns the number of milliseconds between two dates
+ * @param {Date} dateA The first date
+ * @param {Date} dateB (optional) The second date, defaults to now
+ * @return {Number} The difference in milliseconds
*/
- removeAllListeners : function(){
- Ext.EventManager.removeAll(this.dom);
- return this;
+ getElapsed: function(dateA, dateB) {
+ return Math.abs(dateA - (dateB || new Date()));
},
/**
- * Recursively removes all previous added listeners from this element and its children
- * @return {Ext.Element} this
- */
- purgeAllListeners : function() {
- Ext.EventManager.purgeElement(this, true);
- return this;
+ * Global flag which determines if strict date parsing should be used.
+ * Strict date parsing will not roll-over invalid dates, which is the
+ * default behaviour of javascript Date objects.
+ * (see {@link #parse} for more information)
+ * Defaults to false.
+ * @static
+ * @type Boolean
+ */
+ useStrict: false,
+
+ // private
+ formatCodeToRegex: function(character, currentGroup) {
+ // Note: currentGroup - position in regex result array (see notes for Ext.Date.parseCodes below)
+ var p = utilDate.parseCodes[character];
+
+ if (p) {
+ p = typeof p == 'function'? p() : p;
+ utilDate.parseCodes[character] = p; // reassign function result to prevent repeated execution
+ }
+
+ return p ? Ext.applyIf({
+ c: p.c ? xf(p.c, currentGroup || "{0}") : p.c
+ }, p) : {
+ g: 0,
+ c: null,
+ s: Ext.String.escapeRegex(character) // treat unrecognised characters as literals
+ };
},
+
/**
- * @private Test if size has a unit, otherwise appends the default
+ *
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 #parse}.
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
*/
- addUnits : function(size){
- if(size === "" || size == "auto" || size === undefined){
- size = size || '';
- } else if(!isNaN(size) || !unitPattern.test(size)){
- size = size + (this.defaultUnit || 'px');
+ parseFunctions: {
+ "MS": function(input, strict) {
+ // note: the timezone offset is ignored since the MS 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;
}
- return size;
},
+ parseRegexes: [],
/**
- *
Updates the innerHTML of this Element
- * from a specified URL. Note that this is subject to the Same Origin Policy
- *
Updating innerHTML of an element will not execute embedded <script> elements. This is a browser restriction.
- * @param {Mixed} options. Either a sring containing the URL from which to load the HTML, or an {@link Ext.Ajax#request} options object specifying
- * exactly how to request the HTML.
- * @return {Ext.Element} this
+ *
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
*/
- load : function(url, params, cb){
- Ext.Ajax.request(Ext.apply({
- params: params,
- url: url.url || url,
- callback: cb,
- el: this.dom,
- indicatorText: url.indicatorText || ''
- }, Ext.isObject(url) ? url : {}));
- return this;
+ formatFunctions: {
+ "MS": function() {
+ // UTC milliseconds since Unix epoch (MS-AJAX serialized date format (MRSF))
+ return '\\/Date(' + this.getTime() + ')\\/';
+ }
},
+ y2kYear : 50,
+
/**
- * Tests various css rules/browsers to determine if this element uses a border box
- * @return {Boolean}
+ * Date interval constant
+ * @static
+ * @type String
*/
- isBorderBox : function(){
- return Ext.isBorderBox || Ext.isForcedBorderBox || noBoxAdjust[(this.dom.tagName || "").toLowerCase()];
- },
+ MILLI : "ms",
/**
- *
Removes this element's dom reference. Note that event and cache removal is handled at {@link Ext#removeNode}
+ * Date interval constant
+ * @static
+ * @type String
*/
- remove : function(){
- var me = this,
- dom = me.dom;
-
- if (dom) {
- delete me.dom;
- Ext.removeNode(dom);
- }
- },
+ SECOND : "s",
/**
- * Sets up event handlers to call the passed functions when the mouse is moved into and out of the Element.
- * @param {Function} overFn The function to call when the mouse enters the Element.
- * @param {Function} outFn The function to call when the mouse leaves the Element.
- * @param {Object} scope (optional) The scope (this reference) in which the functions are executed. Defaults to the Element's DOM element.
- * @param {Object} options (optional) Options for the listener. See {@link Ext.util.Observable#addListener the options parameter}.
- * @return {Ext.Element} this
+ * Date interval constant
+ * @static
+ * @type String
*/
- hover : function(overFn, outFn, scope, options){
- var me = this;
- me.on('mouseenter', overFn, scope || me.dom, options);
- me.on('mouseleave', outFn, scope || me.dom, options);
- return me;
- },
+ MINUTE : "mi",
- /**
- * Returns true if this element is an ancestor of the passed element
- * @param {HTMLElement/String} el The element to check
- * @return {Boolean} True if this element is an ancestor of el, else false
+ /** Date interval constant
+ * @static
+ * @type String
*/
- contains : function(el){
- return !el ? false : Ext.lib.Dom.isAncestor(this.dom, el.dom ? el.dom : el);
- },
+ HOUR : "h",
/**
- * Returns the value of a namespaced attribute from the element's underlying DOM node.
- * @param {String} namespace The namespace in which to look for the attribute
- * @param {String} name The attribute name
- * @return {String} The attribute value
- * @deprecated
+ * Date interval constant
+ * @static
+ * @type String
*/
- getAttributeNS : function(ns, name){
- return this.getAttribute(name, ns);
- },
+ DAY : "d",
/**
- * Returns the value of an attribute from the element's underlying DOM node.
- * @param {String} name The attribute name
- * @param {String} namespace (optional) The namespace in which to look for the attribute
- * @return {String} The attribute value
+ * Date interval constant
+ * @static
+ * @type String
*/
- getAttribute : Ext.isIE ? function(name, ns){
- var d = this.dom,
- type = typeof d[ns + ":" + name];
-
- if(['undefined', 'unknown'].indexOf(type) == -1){
- return d[ns + ":" + name];
- }
- return d[name];
- } : function(name, ns){
- var d = this.dom;
- return d.getAttributeNS(ns, name) || d.getAttribute(ns + ":" + name) || d.getAttribute(name) || d[name];
- },
+ MONTH : "mo",
/**
- * Update the innerHTML of this element
- * @param {String} html The new HTML
- * @return {Ext.Element} this
+ * Date interval constant
+ * @static
+ * @type String
*/
- update : function(html) {
- if (this.dom) {
- this.dom.innerHTML = html;
- }
- return this;
- }
-};
-
-var ep = El.prototype;
+ YEAR : "y",
-El.addMethods = function(o){
- Ext.apply(ep, o);
-};
+ /**
+ *
An object hash containing default date values used during date parsing.
+ *
The following properties are available:
+ *
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 #parse} 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.
+ * Example Usage:
+ *
+// set default day value to the first day of the month
+Ext.Date.defaults.d = 1;
-/**
- * Appends an event handler (shorthand for {@link #addListener}).
- * @param {String} eventName The name of event to handle.
- * @param {Function} fn The handler function the event invokes.
- * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed.
- * @param {Object} options (optional) An object containing standard {@link #addListener} options
- * @member Ext.Element
- * @method on
- */
-ep.on = ep.addListener;
+// parse a February date string containing only year and month values.
+// setting the default day value to 1 prevents weird date rollover issues
+// when attempting to parse the following date string on, for example, March 31st 2009.
+Ext.Date.parse('2009-02', 'Y-m'); // returns a Date object representing February 1st 2009
+
+ * @property defaults
+ * @static
+ * @type Object
+ */
+ defaults: {},
-/**
- * Removes an event handler from this element (see {@link #removeListener} for additional notes).
- * @param {String} eventName The name of the event from which to remove the handler.
- * @param {Function} fn The handler function to remove. This must be a reference to the function passed into the {@link #addListener} call.
- * @param {Object} scope If a scope (this reference) was specified when the listener was added,
- * then this must refer to the same object.
- * @return {Ext.Element} this
- * @member Ext.Element
- * @method un
- */
-ep.un = ep.removeListener;
+ /**
+ * An array of textual day names.
+ * Override these values for international dates.
+ * Example:
+ *
The date format string that the {@link Ext.util.Format#dateRenderer}
+ * and {@link Ext.util.Format#date} functions use. See {@link Ext.Date} for details.
+ *
This defaults to m/d/Y, but may be overridden in a locale file.
+ * @property defaultFormat
+ * @static
+ * @type String
+ */
+ defaultFormat : "m/d/Y",
+ /**
+ * Get the short month name for the given month number.
+ * Override this function for international dates.
+ * @param {Number} month A zero-based javascript month number.
+ * @return {String} The short month name.
+ * @static
+ */
+ getShortMonthName : function(month) {
+ return utilDate.monthNames[month].substring(0, 3);
+ },
-/**
- * @private
- */
+ /**
+ * Get the short day name for the given day number.
+ * Override this function for international dates.
+ * @param {Number} day A zero-based javascript day number.
+ * @return {String} The short day name.
+ * @static
+ */
+ getShortDayName : function(day) {
+ return utilDate.dayNames[day].substring(0, 3);
+ },
-/**
- * Retrieves Ext.Element objects.
- *
This method does not retrieve {@link Ext.Component Component}s. This method
- * retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
- * its ID, use {@link Ext.ComponentMgr#get}.
- *
Uses simple caching to consistently return the same object. Automatically fixes if an
- * object was recreated with the same id via AJAX or DOM.
- * @param {Mixed} el The id of the node, a DOM Node or an existing Element.
- * @return {Element} The Element object (or null if no matching element was found)
- * @static
- * @member Ext.Element
- * @method get
- */
-El.get = function(el){
- var ex,
- elm,
- id;
- if(!el){ return null; }
- if (typeof el == "string") { // element id
- if (!(elm = DOC.getElementById(el))) {
- return null;
- }
- if (EC[el] && EC[el].el) {
- ex = EC[el].el;
- ex.dom = elm;
- } else {
- ex = El.addToCache(new El(elm));
- }
- return ex;
- } else if (el.tagName) { // dom element
- if(!(id = el.id)){
- id = Ext.id(el);
- }
- if (EC[id] && EC[id].el) {
- ex = EC[id].el;
- ex.dom = el;
- } else {
- ex = El.addToCache(new El(el));
- }
- return ex;
- } else if (el instanceof El) {
- if(el != docEl){
- // refresh dom element in case no longer valid,
- // catch case where it hasn't been appended
+ /**
+ * Get the zero-based javascript month number for the given short/full month name.
+ * Override this function for international dates.
+ * @param {String} name The short/full month name.
+ * @return {Number} The zero-based javascript month number.
+ * @static
+ */
+ getMonthNumber : function(name) {
+ // handle camel casing for english month names (since the keys for the Ext.Date.monthNumbers hash are case sensitive)
+ return utilDate.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
+ },
- // If an el instance is passed, don't pass to getElementById without some kind of id
- if (Ext.isIE && (el.id == undefined || el.id == '')) {
- el.dom = el.dom;
- } else {
- el.dom = DOC.getElementById(el.id) || el.dom;
- }
- }
- return el;
- } else if(el.isComposite) {
- return el;
- } else if(Ext.isArray(el)) {
- return El.select(el);
- } else if(el == DOC) {
- // create a bogus element object representing the document object
- if(!docEl){
- var f = function(){};
- f.prototype = El.prototype;
- docEl = new f();
- docEl.dom = DOC;
- }
- return docEl;
- }
- return null;
-};
+ /**
+ * Checks if the specified format contains hour information
+ * @param {String} format The format to check
+ * @return {Boolean} True if the format contains hour information
+ * @static
+ * @method
+ */
+ formatContainsHourInfo : (function(){
+ var stripEscapeRe = /(\\.)/g,
+ hourInfoRe = /([gGhHisucUOPZ]|MS)/;
+ return function(format){
+ return hourInfoRe.test(format.replace(stripEscapeRe, ''));
+ };
+ })(),
-El.addToCache = function(el, id){
- id = id || el.id;
- EC[id] = {
- el: el,
- data: {},
- events: {}
- };
- return el;
-};
+ /**
+ * Checks if the specified format contains information about
+ * anything other than the time.
+ * @param {String} format The format to check
+ * @return {Boolean} True if the format contains information about
+ * date/day information.
+ * @static
+ * @method
+ */
+ formatContainsDateInfo : (function(){
+ var stripEscapeRe = /(\\.)/g,
+ dateInfoRe = /([djzmnYycU]|MS)/;
-// private method for getting and setting element data
-El.data = function(el, key, value){
- el = El.get(el);
- if (!el) {
- return null;
- }
- var c = EC[el.id].data;
- if(arguments.length == 2){
- return c[key];
- }else{
- return (c[key] = value);
- }
-};
+ return function(format){
+ return dateInfoRe.test(format.replace(stripEscapeRe, ''));
+ };
+ })(),
-// private
-// Garbage collection - uncache elements/purge listeners on orphaned elements
-// so we don't hold a reference and cause the browser to retain them
-function garbageCollect(){
- if(!Ext.enableGarbageCollector){
- clearInterval(El.collectorThreadId);
- } else {
- var eid,
- el,
- d,
- o;
+ /**
+ * The base format-code to formatting-function hashmap used by the {@link #format} method.
+ * Formatting functions are strings (or functions which return strings) which
+ * will return the appropriate value when evaluated in the context of the Date object
+ * from which the {@link #format} method is called.
+ * Add to / override these mappings for custom date formatting.
+ * Note: Ext.Date.format() treats characters as literals if an appropriate mapping cannot be found.
+ * Example:
+ *
+Ext.Date.formatCodes.x = "Ext.util.Format.leftPad(this.getDate(), 2, '0')";
+console.log(Ext.Date.format(new Date(), 'X'); // returns the current day of the month
+
+ * @type Object
+ * @static
+ */
+ formatCodes : {
+ d: "Ext.String.leftPad(this.getDate(), 2, '0')",
+ D: "Ext.Date.getShortDayName(this.getDay())", // get localised short day name
+ j: "this.getDate()",
+ l: "Ext.Date.dayNames[this.getDay()]",
+ N: "(this.getDay() ? this.getDay() : 7)",
+ S: "Ext.Date.getSuffix(this)",
+ w: "this.getDay()",
+ z: "Ext.Date.getDayOfYear(this)",
+ W: "Ext.String.leftPad(Ext.Date.getWeekOfYear(this), 2, '0')",
+ F: "Ext.Date.monthNames[this.getMonth()]",
+ m: "Ext.String.leftPad(this.getMonth() + 1, 2, '0')",
+ M: "Ext.Date.getShortMonthName(this.getMonth())", // get localised short month name
+ n: "(this.getMonth() + 1)",
+ t: "Ext.Date.getDaysInMonth(this)",
+ L: "(Ext.Date.isLeapYear(this) ? 1 : 0)",
+ o: "(this.getFullYear() + (Ext.Date.getWeekOfYear(this) == 1 && this.getMonth() > 0 ? +1 : (Ext.Date.getWeekOfYear(this) >= 52 && this.getMonth() < 11 ? -1 : 0)))",
+ Y: "Ext.String.leftPad(this.getFullYear(), 4, '0')",
+ y: "('' + this.getFullYear()).substring(2, 4)",
+ a: "(this.getHours() < 12 ? 'am' : 'pm')",
+ A: "(this.getHours() < 12 ? 'AM' : 'PM')",
+ g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
+ G: "this.getHours()",
+ h: "Ext.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
+ H: "Ext.String.leftPad(this.getHours(), 2, '0')",
+ i: "Ext.String.leftPad(this.getMinutes(), 2, '0')",
+ s: "Ext.String.leftPad(this.getSeconds(), 2, '0')",
+ u: "Ext.String.leftPad(this.getMilliseconds(), 3, '0')",
+ O: "Ext.Date.getGMTOffset(this)",
+ P: "Ext.Date.getGMTOffset(this, true)",
+ T: "Ext.Date.getTimezone(this)",
+ Z: "(this.getTimezoneOffset() * -60)",
- for(eid in EC){
- o = EC[eid];
- if(o.skipGC){
- continue;
- }
- el = o.el;
- d = el.dom;
- // -------------------------------------------------------
- // Determining what is garbage:
- // -------------------------------------------------------
- // !d
- // dom node is null, definitely garbage
- // -------------------------------------------------------
- // !d.parentNode
- // no parentNode == direct orphan, definitely garbage
- // -------------------------------------------------------
- // !d.offsetParent && !document.getElementById(eid)
- // display none elements have no offsetParent so we will
- // also try to look it up by it's id. However, check
- // offsetParent first so we don't do unneeded lookups.
- // This enables collection of elements that are not orphans
- // directly, but somewhere up the line they have an orphan
- // parent.
- // -------------------------------------------------------
- if(!d || !d.parentNode || (!d.offsetParent && !DOC.getElementById(eid))){
- if(Ext.enableListenerCollection){
- Ext.EventManager.removeAll(d);
- }
- delete EC[eid];
- }
- }
- // Cleanup IE Object leaks
- if (Ext.isIE) {
- var t = {};
- for (eid in EC) {
- t[eid] = EC[eid];
+ c: function() { // ISO-8601 -- GMT format
+ for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
+ var e = c.charAt(i);
+ code.push(e == "T" ? "'T'" : utilDate.getFormatCode(e)); // treat T as a character literal
}
- EC = Ext.elCache = t;
- }
- }
-}
-El.collectorThreadId = setInterval(garbageCollect, 30000);
+ return code.join(" + ");
+ },
+ /*
+ c: function() { // ISO-8601 -- UTC format
+ return [
+ "this.getUTCFullYear()", "'-'",
+ "Ext.util.Format.leftPad(this.getUTCMonth() + 1, 2, '0')", "'-'",
+ "Ext.util.Format.leftPad(this.getUTCDate(), 2, '0')",
+ "'T'",
+ "Ext.util.Format.leftPad(this.getUTCHours(), 2, '0')", "':'",
+ "Ext.util.Format.leftPad(this.getUTCMinutes(), 2, '0')", "':'",
+ "Ext.util.Format.leftPad(this.getUTCSeconds(), 2, '0')",
+ "'Z'"
+ ].join(" + ");
+ },
+ */
-var flyFn = function(){};
-flyFn.prototype = El.prototype;
+ U: "Math.round(this.getTime() / 1000)"
+ },
-// dom is optional
-El.Flyweight = function(dom){
- this.dom = dom;
-};
+ /**
+ * Checks if the passed Date parameters will cause a javascript Date "rollover".
+ * @param {Number} year 4-digit year
+ * @param {Number} month 1-based month-of-year
+ * @param {Number} day Day of month
+ * @param {Number} hour (optional) Hour
+ * @param {Number} minute (optional) Minute
+ * @param {Number} second (optional) Second
+ * @param {Number} millisecond (optional) Millisecond
+ * @return {Boolean} true if the passed parameters do not cause a Date "rollover", false otherwise.
+ * @static
+ */
+ isValid : function(y, m, d, h, i, s, ms) {
+ // setup defaults
+ h = h || 0;
+ i = i || 0;
+ s = s || 0;
+ ms = ms || 0;
-El.Flyweight.prototype = new flyFn();
-El.Flyweight.prototype.isFlyweight = true;
-El._flyweights = {};
+ // Special handling for year < 100
+ var dt = utilDate.add(new Date(y < 100 ? 100 : y, m - 1, d, h, i, s, ms), utilDate.YEAR, y < 100 ? y - 100 : 0);
-/**
- *
Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
- * the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}
- *
Use this to make one-time references to DOM elements which are not going to be accessed again either by
- * application code, or by Ext's classes. If accessing an element which will be processed regularly, then {@link Ext#get}
- * will be more appropriate to take advantage of the caching provided by the Ext.Element class.
- * @param {String/HTMLElement} el The dom node or id
- * @param {String} named (optional) Allows for creation of named reusable flyweights to prevent conflicts
- * (e.g. internally Ext uses "_global")
- * @return {Element} The shared Element object (or null if no matching element was found)
- * @member Ext.Element
- * @method fly
- */
-El.fly = function(el, named){
- var ret = null;
- named = named || '_global';
+ return y == dt.getFullYear() &&
+ m == dt.getMonth() + 1 &&
+ d == dt.getDate() &&
+ h == dt.getHours() &&
+ i == dt.getMinutes() &&
+ s == dt.getSeconds() &&
+ ms == dt.getMilliseconds();
+ },
- if (el = Ext.getDom(el)) {
- (El._flyweights[named] = El._flyweights[named] || new El.Flyweight()).dom = el;
- ret = El._flyweights[named];
- }
- return ret;
-};
+ /**
+ * Parses the passed string using the specified date format.
+ * Note that this function expects normal calendar dates, meaning that months are 1-based (i.e. 1 = January).
+ * The {@link #defaults} hash will be used for any date value (i.e. year, month, day, hour, minute, second or millisecond)
+ * which cannot be found in the passed string. If a corresponding default date value has not been specified in the {@link #defaults} hash,
+ * the current date's year, month, day or DST-adjusted zero-hour time value will be used instead.
+ * Keep in mind that the input date string must precisely match the specified format string
+ * in order for the parse operation to be successful (failed parse operations return a null value).
+ *
This method does not retrieve {@link Ext.Component Component}s. This method
- * retrieves Ext.Element objects which encapsulate DOM elements. To retrieve a Component by
- * its ID, use {@link Ext.ComponentMgr#get}.
- *
Uses simple caching to consistently return the same object. Automatically fixes if an
- * object was recreated with the same id via AJAX or DOM.
- * Shorthand of {@link Ext.Element#get}
- * @param {Mixed} el The id of the node, a DOM Node or an existing Element.
- * @return {Element} The Element object (or null if no matching element was found)
- * @member Ext
- * @method get
- */
-Ext.get = El.get;
+//dt = Thu May 25 2006 (today's month/day in 2006)
+dt = Ext.Date.parse("2006", "Y");
-/**
- *
Gets the globally shared flyweight Element, with the passed node as the active element. Do not store a reference to this element -
- * the dom node can be overwritten by other code. Shorthand of {@link Ext.Element#fly}
- *
Use this to make one-time references to DOM elements which are not going to be accessed again either by
- * application code, or by Ext's classes. If accessing an element which will be processed regularly, then {@link Ext#get}
- * will be more appropriate to take advantage of the caching provided by the Ext.Element class.
- * @param {String/HTMLElement} el The dom node or id
- * @param {String} named (optional) Allows for creation of named reusable flyweights to prevent conflicts
- * (e.g. internally Ext uses "_global")
- * @return {Element} The shared Element object (or null if no matching element was found)
- * @member Ext
- * @method fly
- */
-Ext.fly = El.fly;
+//dt = Sun Jan 15 2006 (all date parts specified)
+dt = Ext.Date.parse("2006-01-15", "Y-m-d");
-// speedy lookup for elements never to box adjust
-var noBoxAdjust = Ext.isStrict ? {
- select:1
-} : {
- input:1, select:1, textarea:1
-};
-if(Ext.isIE || Ext.isGecko){
- noBoxAdjust['button'] = 1;
-}
+//dt = Sun Jan 15 2006 15:20:01
+dt = Ext.Date.parse("2006-01-15 3:20:01 PM", "Y-m-d g:i:s A");
-})();
-/**
- * @class Ext.Element
- */
-Ext.Element.addMethods(function(){
- var PARENTNODE = 'parentNode',
- NEXTSIBLING = 'nextSibling',
- PREVIOUSSIBLING = 'previousSibling',
- DQ = Ext.DomQuery,
- GET = Ext.get;
-
- return {
- /**
- * Looks at this node and then at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)
- * @param {String} selector The simple selector to test
- * @param {Number/Mixed} maxDepth (optional) The max depth to search as a number or element (defaults to 50 || document.body)
- * @param {Boolean} returnEl (optional) True to return a Ext.Element object instead of DOM node
- * @return {HTMLElement} The matching DOM node (or null if no match was found)
- */
- findParent : function(simpleSelector, maxDepth, returnEl){
- var p = this.dom,
- b = document.body,
- depth = 0,
- stopEl;
- if(Ext.isGecko && Object.prototype.toString.call(p) == '[object XULElement]') {
- return null;
- }
- maxDepth = maxDepth || 50;
- if (isNaN(maxDepth)) {
- stopEl = Ext.getDom(maxDepth);
- maxDepth = Number.MAX_VALUE;
- }
- while(p && p.nodeType == 1 && depth < maxDepth && p != b && p != stopEl){
- if(DQ.is(p, simpleSelector)){
- return returnEl ? GET(p) : p;
- }
- depth++;
- p = p.parentNode;
- }
- return null;
- },
-
- /**
- * Looks at parent nodes for a match of the passed simple selector (e.g. div.some-class or span:first-child)
- * @param {String} selector The simple selector to test
- * @param {Number/Mixed} maxDepth (optional) The max depth to
- search as a number or element (defaults to 10 || document.body)
- * @param {Boolean} returnEl (optional) True to return a Ext.Element object instead of DOM node
- * @return {HTMLElement} The matching DOM node (or null if no match was found)
- */
- findParentNode : function(simpleSelector, maxDepth, returnEl){
- var p = Ext.fly(this.dom.parentNode, '_internal');
- return p ? p.findParent(simpleSelector, maxDepth, returnEl) : null;
- },
-
- /**
- * Walks up the dom looking for a parent node that matches the passed simple selector (e.g. div.some-class or span:first-child).
- * This is a shortcut for findParentNode() that always returns an Ext.Element.
- * @param {String} selector The simple selector to test
- * @param {Number/Mixed} maxDepth (optional) The max depth to
- search as a number or element (defaults to 10 || document.body)
- * @return {Ext.Element} The matching DOM node (or null if no match was found)
- */
- up : function(simpleSelector, maxDepth){
- return this.findParentNode(simpleSelector, maxDepth, true);
- },
-
- /**
- * Creates a {@link Ext.CompositeElement} for child nodes based on the passed CSS selector (the selector should not contain an id).
- * @param {String} selector The CSS selector
- * @return {CompositeElement/CompositeElementLite} The composite element
- */
- select : function(selector){
- return Ext.Element.select(selector, this.dom);
- },
-
- /**
- * Selects child nodes based on the passed CSS selector (the selector should not contain an id).
- * @param {String} selector The CSS selector
- * @return {Array} An array of the matched nodes
- */
- query : function(selector){
- return DQ.select(selector, this.dom);
- },
-
- /**
- * Selects a single child at any depth below this element based on the passed CSS selector (the selector should not contain an id).
- * @param {String} selector The CSS selector
- * @param {Boolean} returnDom (optional) True to return the DOM node instead of Ext.Element (defaults to false)
- * @return {HTMLElement/Ext.Element} The child Ext.Element (or DOM node if returnDom = true)
- */
- child : function(selector, returnDom){
- var n = DQ.selectNode(selector, this.dom);
- return returnDom ? n : GET(n);
- },
-
- /**
- * Selects a single *direct* child based on the passed CSS selector (the selector should not contain an id).
- * @param {String} selector The CSS selector
- * @param {Boolean} returnDom (optional) True to return the DOM node instead of Ext.Element (defaults to false)
- * @return {HTMLElement/Ext.Element} The child Ext.Element (or DOM node if returnDom = true)
- */
- down : function(selector, returnDom){
- var n = DQ.selectNode(" > " + selector, this.dom);
- return returnDom ? n : GET(n);
- },
-
- /**
- * Gets the parent node for this element, optionally chaining up trying to match a selector
- * @param {String} selector (optional) Find a parent node that matches the passed simple selector
- * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an Ext.Element
- * @return {Ext.Element/HTMLElement} The parent node or null
- */
- parent : function(selector, returnDom){
- return this.matchNode(PARENTNODE, PARENTNODE, selector, returnDom);
- },
-
- /**
- * Gets the next sibling, skipping text nodes
- * @param {String} selector (optional) Find the next sibling that matches the passed simple selector
- * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an Ext.Element
- * @return {Ext.Element/HTMLElement} The next sibling or null
- */
- next : function(selector, returnDom){
- return this.matchNode(NEXTSIBLING, NEXTSIBLING, selector, returnDom);
- },
-
- /**
- * Gets the previous sibling, skipping text nodes
- * @param {String} selector (optional) Find the previous sibling that matches the passed simple selector
- * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an Ext.Element
- * @return {Ext.Element/HTMLElement} The previous sibling or null
- */
- prev : function(selector, returnDom){
- return this.matchNode(PREVIOUSSIBLING, PREVIOUSSIBLING, selector, returnDom);
- },
-
-
- /**
- * Gets the first child, skipping text nodes
- * @param {String} selector (optional) Find the next sibling that matches the passed simple selector
- * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an Ext.Element
- * @return {Ext.Element/HTMLElement} The first child or null
- */
- first : function(selector, returnDom){
- return this.matchNode(NEXTSIBLING, 'firstChild', selector, returnDom);
- },
-
- /**
- * Gets the last child, skipping text nodes
- * @param {String} selector (optional) Find the previous sibling that matches the passed simple selector
- * @param {Boolean} returnDom (optional) True to return a raw dom node instead of an Ext.Element
- * @return {Ext.Element/HTMLElement} The last child or null
- */
- last : function(selector, returnDom){
- return this.matchNode(PREVIOUSSIBLING, 'lastChild', selector, returnDom);
- },
-
- matchNode : function(dir, start, selector, returnDom){
- var n = this.dom[start];
- while(n){
- if(n.nodeType == 1 && (!selector || DQ.is(n, selector))){
- return !returnDom ? GET(n) : n;
- }
- n = n[dir];
- }
- return null;
- }
- };
-}());/**
- * @class Ext.Element
- */
-Ext.Element.addMethods(
-function() {
- var GETDOM = Ext.getDom,
- GET = Ext.get,
- DH = Ext.DomHelper;
-
- return {
- /**
- * Appends the passed element(s) to this element
- * @param {String/HTMLElement/Array/Element/CompositeElement} el
- * @return {Ext.Element} this
- */
- appendChild: function(el){
- return GET(el).appendTo(this);
- },
-
- /**
- * Appends this element to the passed element
- * @param {Mixed} el The new parent element
- * @return {Ext.Element} this
- */
- appendTo: function(el){
- GETDOM(el).appendChild(this.dom);
- return this;
- },
-
- /**
- * Inserts this element before the passed element in the DOM
- * @param {Mixed} el The element before which this element will be inserted
- * @return {Ext.Element} this
- */
- insertBefore: function(el){
- (el = GETDOM(el)).parentNode.insertBefore(this.dom, el);
- return this;
- },
-
- /**
- * Inserts this element after the passed element in the DOM
- * @param {Mixed} el The element to insert after
- * @return {Ext.Element} this
- */
- insertAfter: function(el){
- (el = GETDOM(el)).parentNode.insertBefore(this.dom, el.nextSibling);
- return this;
- },
-
- /**
- * Inserts (or creates) an element (or DomHelper config) as the first child of this element
- * @param {Mixed/Object} el The id or element to insert or a DomHelper config to create and insert
- * @return {Ext.Element} The new child
- */
- insertFirst: function(el, returnDom){
- el = el || {};
- if(el.nodeType || el.dom || typeof el == 'string'){ // element
- el = GETDOM(el);
- this.dom.insertBefore(el, this.dom.firstChild);
- return !returnDom ? GET(el) : el;
- }else{ // dh config
- return this.createChild(el, this.dom.firstChild, returnDom);
- }
- },
-
- /**
- * Replaces the passed element with this element
- * @param {Mixed} el The element to replace
- * @return {Ext.Element} this
- */
- replace: function(el){
- el = GET(el);
- this.insertBefore(el);
- el.remove();
- return this;
- },
-
- /**
- * Replaces this element with the passed element
- * @param {Mixed/Object} el The new element or a DomHelper config of an element to create
- * @return {Ext.Element} this
- */
- replaceWith: function(el){
- var me = this;
-
- if(el.nodeType || el.dom || typeof el == 'string'){
- el = GETDOM(el);
- me.dom.parentNode.insertBefore(el, me.dom);
- }else{
- el = DH.insertBefore(me.dom, el);
- }
-
- delete Ext.elCache[me.id];
- Ext.removeNode(me.dom);
- me.id = Ext.id(me.dom = el);
- Ext.Element.addToCache(me.isFlyweight ? new Ext.Element(me.dom) : me);
- return me;
- },
-
- /**
- * Creates the passed DomHelper config and appends it to this element or optionally inserts it before the passed child element.
- * @param {Object} config DomHelper element config object. If no tag is specified (e.g., {tag:'input'}) then a div will be
- * automatically generated with the specified attributes.
- * @param {HTMLElement} insertBefore (optional) a child element of this element
- * @param {Boolean} returnDom (optional) true to return the dom node instead of creating an Element
- * @return {Ext.Element} The new child element
- */
- createChild: function(config, insertBefore, returnDom){
- config = config || {tag:'div'};
- return insertBefore ?
- DH.insertBefore(insertBefore, config, returnDom !== true) :
- DH[!this.dom.firstChild ? 'overwrite' : 'append'](this.dom, config, returnDom !== true);
- },
-
- /**
- * Creates and wraps this element with another element
- * @param {Object} config (optional) DomHelper element config object for the wrapper element or null for an empty div
- * @param {Boolean} returnDom (optional) True to return the raw DOM element instead of Ext.Element
- * @return {HTMLElement/Element} The newly created wrapper element
- */
- wrap: function(config, returnDom){
- var newEl = DH.insertBefore(this.dom, config || {tag: "div"}, !returnDom);
- newEl.dom ? newEl.dom.appendChild(this.dom) : newEl.appendChild(this.dom);
- return newEl;
- },
-
- /**
- * Inserts an html fragment into this element
- * @param {String} where Where to insert the html in relation to this element - beforeBegin, afterBegin, beforeEnd, afterEnd.
- * @param {String} html The HTML fragment
- * @param {Boolean} returnEl (optional) True to return an Ext.Element (defaults to false)
- * @return {HTMLElement/Ext.Element} The inserted node (or nearest related if more than 1 inserted)
- */
- insertHtml : function(where, html, returnEl){
- var el = DH.insertHtml(where, this.dom, html);
- return returnEl ? Ext.get(el) : el;
- }
- };
-}());/**
- * @class Ext.Element
- */
-Ext.Element.addMethods(function(){
- // local style camelizing for speed
- var supports = Ext.supports,
- propCache = {},
- camelRe = /(-[a-z])/gi,
- view = document.defaultView,
- opacityRe = /alpha\(opacity=(.*)\)/i,
- trimRe = /^\s+|\s+$/g,
- EL = Ext.Element,
- spacesRe = /\s+/,
- wordsRe = /\w/g,
- PADDING = "padding",
- MARGIN = "margin",
- BORDER = "border",
- LEFT = "-left",
- RIGHT = "-right",
- TOP = "-top",
- BOTTOM = "-bottom",
- WIDTH = "-width",
- MATH = Math,
- HIDDEN = 'hidden',
- ISCLIPPED = 'isClipped',
- OVERFLOW = 'overflow',
- OVERFLOWX = 'overflow-x',
- OVERFLOWY = 'overflow-y',
- ORIGINALCLIP = 'originalClip',
- // special markup used throughout Ext when box wrapping elements
- borders = {l: BORDER + LEFT + WIDTH, r: BORDER + RIGHT + WIDTH, t: BORDER + TOP + WIDTH, b: BORDER + BOTTOM + WIDTH},
- paddings = {l: PADDING + LEFT, r: PADDING + RIGHT, t: PADDING + TOP, b: PADDING + BOTTOM},
- margins = {l: MARGIN + LEFT, r: MARGIN + RIGHT, t: MARGIN + TOP, b: MARGIN + BOTTOM},
- data = Ext.Element.data;
+// attempt to parse Sun Feb 29 2006 03:20:01 in strict mode
+dt = Ext.Date.parse("2006-02-29 03:20:01", "Y-m-d H:i:s", true); // returns null
+
+ * @param {String} input The raw date string.
+ * @param {String} format The expected date string format.
+ * @param {Boolean} strict (optional) True to validate date strings while parsing (i.e. prevents javascript Date "rollover")
+ (defaults to false). Invalid date strings will return null when parsed.
+ * @return {Date} The parsed Date.
+ * @static
+ */
+ parse : function(input, format, strict) {
+ var p = utilDate.parseFunctions;
+ if (p[format] == null) {
+ utilDate.createParser(format);
+ }
+ return p[format](input, Ext.isDefined(strict) ? strict : utilDate.useStrict);
+ },
+ // Backwards compat
+ parseDate: function(input, format, strict){
+ return utilDate.parse(input, format, strict);
+ },
- // private
- function camelFn(m, a) {
- return a.charAt(1).toUpperCase();
- }
- function chkCache(prop) {
- return propCache[prop] || (propCache[prop] = prop == 'float' ? (supports.cssFloat ? 'cssFloat' : 'styleFloat') : prop.replace(camelRe, camelFn));
- }
+ // private
+ getFormatCode : function(character) {
+ var f = utilDate.formatCodes[character];
- return {
- // private ==> used by Fx
- adjustWidth : function(width) {
- var me = this;
- var isNum = (typeof width == "number");
- if(isNum && me.autoBoxAdjust && !me.isBorderBox()){
- width -= (me.getBorderWidth("lr") + me.getPadding("lr"));
- }
- return (isNum && width < 0) ? 0 : width;
- },
+ if (f) {
+ f = typeof f == 'function'? f() : f;
+ utilDate.formatCodes[character] = f; // reassign function result to prevent repeated execution
+ }
- // private ==> used by Fx
- adjustHeight : function(height) {
- var me = this;
- var isNum = (typeof height == "number");
- if(isNum && me.autoBoxAdjust && !me.isBorderBox()){
- height -= (me.getBorderWidth("tb") + me.getPadding("tb"));
- }
- return (isNum && height < 0) ? 0 : height;
- },
+ // note: unknown characters are treated as literals
+ return f || ("'" + Ext.String.escape(character) + "'");
+ },
+ // private
+ createFormat : function(format) {
+ var code = [],
+ special = false,
+ ch = '';
- /**
- * Adds one or more CSS classes to the element. Duplicate classes are automatically filtered out.
- * @param {String/Array} className The CSS class to add, or an array of classes
- * @return {Ext.Element} this
- */
- addClass : function(className){
- var me = this,
- i,
- len,
- v,
- cls = [];
- // Separate case is for speed
- if (!Ext.isArray(className)) {
- if (typeof className == 'string' && !this.hasClass(className)) {
- me.dom.className += " " + className;
- }
- }
- else {
- for (i = 0, len = className.length; i < len; i++) {
- v = className[i];
- if (typeof v == 'string' && (' ' + me.dom.className + ' ').indexOf(' ' + v + ' ') == -1) {
- cls.push(v);
- }
- }
- if (cls.length) {
- me.dom.className += " " + cls.join(" ");
- }
+ for (var i = 0; i < format.length; ++i) {
+ ch = format.charAt(i);
+ if (!special && ch == "\\") {
+ special = true;
+ } else if (special) {
+ special = false;
+ code.push("'" + Ext.String.escape(ch) + "'");
+ } else {
+ code.push(utilDate.getFormatCode(ch));
}
- return me;
- },
+ }
+ utilDate.formatFunctions[format] = Ext.functionFactory("return " + code.join('+'));
+ },
- /**
- * Removes one or more CSS classes from the element.
- * @param {String/Array} className The CSS class to remove, or an array of classes
- * @return {Ext.Element} this
- */
- removeClass : function(className){
- var me = this,
- i,
- idx,
- len,
- cls,
- elClasses;
- if (!Ext.isArray(className)){
- className = [className];
- }
- if (me.dom && me.dom.className) {
- elClasses = me.dom.className.replace(trimRe, '').split(spacesRe);
- for (i = 0, len = className.length; i < len; i++) {
- cls = className[i];
- if (typeof cls == 'string') {
- cls = cls.replace(trimRe, '');
- idx = elClasses.indexOf(cls);
- if (idx != -1) {
- elClasses.splice(idx, 1);
- }
- }
- }
- me.dom.className = elClasses.join(" ");
- }
- return me;
- },
+ // private
+ createParser : (function() {
+ var code = [
+ "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
+ "def = Ext.Date.defaults,",
+ "results = String(input).match(Ext.Date.parseRegexes[{0}]);", // either null, or an array of matched strings
- /**
- * Adds one or more CSS classes to this element and removes the same class(es) from all siblings.
- * @param {String/Array} className The CSS class to add, or an array of classes
- * @return {Ext.Element} this
- */
- radioClass : function(className){
- var cn = this.dom.parentNode.childNodes,
- v,
- i,
- len;
- className = Ext.isArray(className) ? className : [className];
- for (i = 0, len = cn.length; i < len; i++) {
- v = cn[i];
- if (v && v.nodeType == 1) {
- Ext.fly(v, '_internal').removeClass(className);
- }
- };
- return this.addClass(className);
- },
+ "if(results){",
+ "{1}",
- /**
- * Toggles the specified CSS class on this element (removes it if it already exists, otherwise adds it).
- * @param {String} className The CSS class to toggle
- * @return {Ext.Element} this
- */
- toggleClass : function(className){
- return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
- },
+ "if(u != null){", // i.e. unix time is defined
+ "v = new Date(u * 1000);", // give top priority to UNIX time
+ "}else{",
+ // create Date object representing midnight of the current day;
+ // this will provide us with our date defaults
+ // (note: clearTime() handles Daylight Saving Time automatically)
+ "dt = Ext.Date.clearTime(new Date);",
- /**
- * Checks if the specified CSS class exists on this element's DOM node.
- * @param {String} className The CSS class to check for
- * @return {Boolean} True if the class exists, else false
- */
- hasClass : function(className){
- return className && (' '+this.dom.className+' ').indexOf(' '+className+' ') != -1;
- },
+ // date calculations (note: these calculations create a dependency on Ext.Number.from())
+ "y = Ext.Number.from(y, Ext.Number.from(def.y, dt.getFullYear()));",
+ "m = Ext.Number.from(m, Ext.Number.from(def.m - 1, dt.getMonth()));",
+ "d = Ext.Number.from(d, Ext.Number.from(def.d, dt.getDate()));",
- /**
- * Replaces a CSS class on the element with another. If the old name does not exist, the new name will simply be added.
- * @param {String} oldClassName The CSS class to replace
- * @param {String} newClassName The replacement CSS class
- * @return {Ext.Element} this
- */
- replaceClass : function(oldClassName, newClassName){
- return this.removeClass(oldClassName).addClass(newClassName);
- },
+ // time calculations (note: these calculations create a dependency on Ext.Number.from())
+ "h = Ext.Number.from(h, Ext.Number.from(def.h, dt.getHours()));",
+ "i = Ext.Number.from(i, Ext.Number.from(def.i, dt.getMinutes()));",
+ "s = Ext.Number.from(s, Ext.Number.from(def.s, dt.getSeconds()));",
+ "ms = Ext.Number.from(ms, Ext.Number.from(def.ms, dt.getMilliseconds()));",
- isStyle : function(style, val) {
- return this.getStyle(style) == val;
- },
+ "if(z >= 0 && y >= 0){",
+ // both the year and zero-based day of year are defined and >= 0.
+ // these 2 values alone provide sufficient info to create a full date object
- /**
- * Normalizes currentStyle and computedStyle.
- * @param {String} property The style property whose value is returned.
- * @return {String} The current value of the style property for this element.
- */
- getStyle : function(){
- return view && view.getComputedStyle ?
- function(prop){
- var el = this.dom,
- v,
- cs,
- out,
- display;
+ // create Date object representing January 1st for the given year
+ // handle years < 100 appropriately
+ "v = Ext.Date.add(new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
- if(el == document){
- return null;
- }
- prop = chkCache(prop);
- out = (v = el.style[prop]) ? v :
- (cs = view.getComputedStyle(el, "")) ? cs[prop] : null;
-
- // Ignore cases when the margin is correctly reported as 0, the bug only shows
- // numbers larger.
- if(prop == 'marginRight' && out != '0px' && !supports.correctRightMargin){
- display = el.style.display;
- el.style.display = 'inline-block';
- out = view.getComputedStyle(el, '').marginRight;
- el.style.display = display;
- }
-
- if(prop == 'backgroundColor' && out == 'rgba(0, 0, 0, 0)' && !supports.correctTransparentColor){
- out = 'transparent';
- }
- return out;
- } :
- function(prop){
- var el = this.dom,
- m,
- cs;
+ // then add day of year, checking for Date "rollover" if necessary
+ "v = !strict? v : (strict === true && (z <= 364 || (Ext.Date.isLeapYear(v) && z <= 365))? Ext.Date.add(v, Ext.Date.DAY, z) : null);",
+ "}else if(strict === true && !Ext.Date.isValid(y, m + 1, d, h, i, s, ms)){", // check for Date "rollover"
+ "v = null;", // invalid date, so return null
+ "}else{",
+ // plain old Date object
+ // handle years < 100 properly
+ "v = Ext.Date.add(new Date(y < 100 ? 100 : y, m, d, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
+ "}",
+ "}",
+ "}",
- if(el == document) return null;
- if (prop == 'opacity') {
- if (el.style.filter.match) {
- if(m = el.style.filter.match(opacityRe)){
- var fv = parseFloat(m[1]);
- if(!isNaN(fv)){
- return fv ? fv / 100 : 0;
- }
- }
- }
- return 1;
- }
- prop = chkCache(prop);
- return el.style[prop] || ((cs = el.currentStyle) ? cs[prop] : null);
- };
- }(),
-
- /**
- * Return the CSS color for the specified CSS attribute. rgb, 3 digit (like #fff) and valid values
- * are convert to standard 6 digit hex color.
- * @param {String} attr The css attribute
- * @param {String} defaultValue The default value to use when a valid color isn't found
- * @param {String} prefix (optional) defaults to #. Use an empty string when working with
- * color anims.
- */
- getColor : function(attr, defaultValue, prefix){
- var v = this.getStyle(attr),
- color = (typeof prefix != 'undefined') ? prefix : '#',
- h;
-
- if(!v || (/transparent|inherit/.test(v))) {
- return defaultValue;
- }
- if(/^r/.test(v)){
- Ext.each(v.slice(4, v.length -1).split(','), function(s){
- h = parseInt(s, 10);
- color += (h < 16 ? '0' : '') + h.toString(16);
- });
- }else{
- v = v.replace('#', '');
- color += v.length == 3 ? v.replace(/^(\w)(\w)(\w)$/, '$1$1$2$2$3$3') : v;
- }
- return(color.length > 5 ? color.toLowerCase() : defaultValue);
- },
-
- /**
- * Wrapper for setting style properties, also takes single object parameter of multiple styles.
- * @param {String/Object} property The style property to be set, or an object of multiple styles.
- * @param {String} value (optional) The value to apply to the given property, or null if an object was passed.
- * @return {Ext.Element} this
- */
- setStyle : function(prop, value){
- var tmp, style;
-
- if (typeof prop != 'object') {
- tmp = {};
- tmp[prop] = value;
- prop = tmp;
- }
- for (style in prop) {
- value = prop[style];
- style == 'opacity' ?
- this.setOpacity(value) :
- this.dom.style[chkCache(style)] = value;
- }
- return this;
- },
+ "if(v){",
+ // favour UTC offset over GMT offset
+ "if(zz != null){",
+ // reset to UTC, then add offset
+ "v = Ext.Date.add(v, Ext.Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
+ "}else if(o){",
+ // reset to GMT, then add offset
+ "v = Ext.Date.add(v, Ext.Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
+ "}",
+ "}",
- /**
- * Set the opacity of the element
- * @param {Float} opacity The new opacity. 0 = transparent, .5 = 50% visibile, 1 = fully visible, etc
- * @param {Boolean/Object} animate (optional) a standard Element animation config object or true for
- * the default animation ({duration: .35, easing: 'easeIn'})
- * @return {Ext.Element} this
- */
- setOpacity : function(opacity, animate){
- var me = this,
- s = me.dom.style;
+ "return v;"
+ ].join('\n');
- if(!animate || !me.anim){
- if(Ext.isIE){
- var opac = opacity < 1 ? 'alpha(opacity=' + opacity * 100 + ')' : '',
- val = s.filter.replace(opacityRe, '').replace(trimRe, '');
+ return function(format) {
+ var regexNum = utilDate.parseRegexes.length,
+ currentGroup = 1,
+ calc = [],
+ regex = [],
+ special = false,
+ ch = "";
- s.zoom = 1;
- s.filter = val + (val.length > 0 ? ' ' : '') + opac;
- }else{
- s.opacity = opacity;
+ for (var i = 0; i < format.length; ++i) {
+ ch = format.charAt(i);
+ if (!special && ch == "\\") {
+ special = true;
+ } else if (special) {
+ special = false;
+ regex.push(Ext.String.escape(ch));
+ } else {
+ var obj = utilDate.formatCodeToRegex(ch, currentGroup);
+ currentGroup += obj.g;
+ regex.push(obj.s);
+ if (obj.g && obj.c) {
+ calc.push(obj.c);
+ }
}
- }else{
- me.anim({opacity: {to: opacity}}, me.preanim(arguments, 1), null, .35, 'easeIn');
}
- return me;
- },
- /**
- * Clears any opacity settings from this element. Required in some cases for IE.
- * @return {Ext.Element} this
- */
- clearOpacity : function(){
- var style = this.dom.style;
- if(Ext.isIE){
- if(!Ext.isEmpty(style.filter)){
- style.filter = style.filter.replace(opacityRe, '').replace(trimRe, '');
- }
- }else{
- style.opacity = style['-moz-opacity'] = style['-khtml-opacity'] = '';
- }
- return this;
- },
+ utilDate.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", 'i');
+ utilDate.parseFunctions[format] = Ext.functionFactory("input", "strict", xf(code, regexNum, calc.join('')));
+ };
+ })(),
- /**
- * Returns the offset height of the element
- * @param {Boolean} contentHeight (optional) true to get the height minus borders and padding
- * @return {Number} The element's height
+ // private
+ parseCodes : {
+ /*
+ * Notes:
+ * g = {Number} calculation group (0 or 1. only group 1 contributes to date calculations.)
+ * c = {String} calculation method (required for group 1. null for group 0. {0} = currentGroup - position in regex result array)
+ * s = {String} regex pattern. all matches are stored in results[], and are accessible by the calculation mapped to 'c'
*/
- getHeight : function(contentHeight){
- var me = this,
- dom = me.dom,
- hidden = Ext.isIE && me.isStyle('display', 'none'),
- h = MATH.max(dom.offsetHeight, hidden ? 0 : dom.clientHeight) || 0;
-
- h = !contentHeight ? h : h - me.getBorderWidth("tb") - me.getPadding("tb");
- return h < 0 ? 0 : h;
+ d: {
+ g:1,
+ c:"d = parseInt(results[{0}], 10);\n",
+ s:"(\\d{2})" // day of month with leading zeroes (01 - 31)
},
-
- /**
- * Returns the offset width of the element
- * @param {Boolean} contentWidth (optional) true to get the width minus borders and padding
- * @return {Number} The element's width
- */
- getWidth : function(contentWidth){
- var me = this,
- dom = me.dom,
- hidden = Ext.isIE && me.isStyle('display', 'none'),
- w = MATH.max(dom.offsetWidth, hidden ? 0 : dom.clientWidth) || 0;
- w = !contentWidth ? w : w - me.getBorderWidth("lr") - me.getPadding("lr");
- return w < 0 ? 0 : w;
+ j: {
+ g:1,
+ c:"d = parseInt(results[{0}], 10);\n",
+ s:"(\\d{1,2})" // day of month without leading zeroes (1 - 31)
},
-
- /**
- * Set the width of this Element.
- * @param {Mixed} width The new width. This may be one of:
- *
A Number specifying the new width in this Element's {@link #defaultUnit}s (by default, pixels).
- *
A String used to set the CSS width style. Animation may not be used.
- *
- * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
- * @return {Ext.Element} this
- */
- setWidth : function(width, animate){
- var me = this;
- width = me.adjustWidth(width);
- !animate || !me.anim ?
- me.dom.style.width = me.addUnits(width) :
- me.anim({width : {to : width}}, me.preanim(arguments, 1));
- return me;
+ D: function() {
+ for (var a = [], i = 0; i < 7; a.push(utilDate.getShortDayName(i)), ++i); // get localised short day names
+ return {
+ g:0,
+ c:null,
+ s:"(?:" + a.join("|") +")"
+ };
},
-
- /**
- * Set the height of this Element.
- *
-// change the height to 200px and animate with default configuration
-Ext.fly('elementId').setHeight(200, true);
-
-// change the height to 150px and animate with a custom configuration
-Ext.fly('elId').setHeight(150, {
- duration : .5, // animation will have a duration of .5 seconds
- // will change the content to "finished"
- callback: function(){ this.{@link #update}("finished"); }
-});
- *
- * @param {Mixed} height The new height. This may be one of:
- *
A Number specifying the new height in this Element's {@link #defaultUnit}s (by default, pixels.)
- *
A String used to set the CSS height style. Animation may not be used.
- *
- * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
- * @return {Ext.Element} this
- */
- setHeight : function(height, animate){
- var me = this;
- height = me.adjustHeight(height);
- !animate || !me.anim ?
- me.dom.style.height = me.addUnits(height) :
- me.anim({height : {to : height}}, me.preanim(arguments, 1));
- return me;
+ l: function() {
+ return {
+ g:0,
+ c:null,
+ s:"(?:" + utilDate.dayNames.join("|") + ")"
+ };
},
-
- /**
- * Gets the width of the border(s) for the specified side(s)
- * @param {String} side Can be t, l, r, b or any combination of those to add multiple values. For example,
- * passing 'lr' would get the border left width + the border right width.
- * @return {Number} The width of the sides passed added together
- */
- getBorderWidth : function(side){
- return this.addStyles(side, borders);
+ N: {
+ g:0,
+ c:null,
+ s:"[1-7]" // ISO-8601 day number (1 (monday) - 7 (sunday))
},
-
- /**
- * Gets the width of the padding(s) for the specified side(s)
- * @param {String} side Can be t, l, r, b or any combination of those to add multiple values. For example,
- * passing 'lr' would get the padding left + the padding right.
- * @return {Number} The padding of the sides passed added together
- */
- getPadding : function(side){
- return this.addStyles(side, paddings);
+ S: {
+ g:0,
+ c:null,
+ s:"(?:st|nd|rd|th)"
},
-
- /**
- * Store the current overflow setting and clip overflow on the element - use {@link #unclip} to remove
- * @return {Ext.Element} this
- */
- clip : function(){
- var me = this,
- dom = me.dom;
-
- if(!data(dom, ISCLIPPED)){
- data(dom, ISCLIPPED, true);
- data(dom, ORIGINALCLIP, {
- o: me.getStyle(OVERFLOW),
- x: me.getStyle(OVERFLOWX),
- y: me.getStyle(OVERFLOWY)
- });
- me.setStyle(OVERFLOW, HIDDEN);
- me.setStyle(OVERFLOWX, HIDDEN);
- me.setStyle(OVERFLOWY, HIDDEN);
- }
- return me;
+ w: {
+ g:0,
+ c:null,
+ s:"[0-6]" // javascript day number (0 (sunday) - 6 (saturday))
},
-
- /**
- * Return clipping (overflow) to original clipping before {@link #clip} was called
- * @return {Ext.Element} this
+ z: {
+ g:1,
+ c:"z = parseInt(results[{0}], 10);\n",
+ s:"(\\d{1,3})" // day of the year (0 - 364 (365 in leap years))
+ },
+ W: {
+ g:0,
+ c:null,
+ s:"(?:\\d{2})" // ISO-8601 week number (with leading zero)
+ },
+ F: function() {
+ return {
+ g:1,
+ c:"m = parseInt(Ext.Date.getMonthNumber(results[{0}]), 10);\n", // get localised month number
+ s:"(" + utilDate.monthNames.join("|") + ")"
+ };
+ },
+ M: function() {
+ for (var a = [], i = 0; i < 12; a.push(utilDate.getShortMonthName(i)), ++i); // get localised short month names
+ return Ext.applyIf({
+ s:"(" + a.join("|") + ")"
+ }, utilDate.formatCodeToRegex("F"));
+ },
+ m: {
+ g:1,
+ c:"m = parseInt(results[{0}], 10) - 1;\n",
+ s:"(\\d{2})" // month number with leading zeros (01 - 12)
+ },
+ n: {
+ g:1,
+ c:"m = parseInt(results[{0}], 10) - 1;\n",
+ s:"(\\d{1,2})" // month number without leading zeros (1 - 12)
+ },
+ t: {
+ g:0,
+ c:null,
+ s:"(?:\\d{2})" // no. of days in the month (28 - 31)
+ },
+ L: {
+ g:0,
+ c:null,
+ s:"(?:1|0)"
+ },
+ o: function() {
+ return utilDate.formatCodeToRegex("Y");
+ },
+ Y: {
+ g:1,
+ c:"y = parseInt(results[{0}], 10);\n",
+ s:"(\\d{4})" // 4-digit year
+ },
+ y: {
+ g:1,
+ c:"var ty = parseInt(results[{0}], 10);\n"
+ + "y = ty > Ext.Date.y2kYear ? 1900 + ty : 2000 + ty;\n", // 2-digit year
+ s:"(\\d{1,2})"
+ },
+ /*
+ * In the am/pm parsing routines, we allow both upper and lower case
+ * even though it doesn't exactly match the spec. It gives much more flexibility
+ * in being able to specify case insensitive regexes.
*/
- unclip : function(){
- var me = this,
- dom = me.dom;
-
- if(data(dom, ISCLIPPED)){
- data(dom, ISCLIPPED, false);
- var o = data(dom, ORIGINALCLIP);
- if(o.o){
- me.setStyle(OVERFLOW, o.o);
- }
- if(o.x){
- me.setStyle(OVERFLOWX, o.x);
- }
- if(o.y){
- me.setStyle(OVERFLOWY, o.y);
- }
- }
- return me;
+ a: {
+ g:1,
+ c:"if (/(am)/i.test(results[{0}])) {\n"
+ + "if (!h || h == 12) { h = 0; }\n"
+ + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
+ s:"(am|pm|AM|PM)"
},
-
- // private
- addStyles : function(sides, styles){
- var ttlSize = 0,
- sidesArr = sides.match(wordsRe),
- side,
- size,
- i,
- len = sidesArr.length;
- for (i = 0; i < len; i++) {
- side = sidesArr[i];
- size = side && parseInt(this.getStyle(styles[side]), 10);
- if (size) {
- ttlSize += MATH.abs(size);
- }
- }
- return ttlSize;
+ A: {
+ g:1,
+ c:"if (/(am)/i.test(results[{0}])) {\n"
+ + "if (!h || h == 12) { h = 0; }\n"
+ + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
+ s:"(AM|PM|am|pm)"
+ },
+ g: function() {
+ return utilDate.formatCodeToRegex("G");
+ },
+ G: {
+ g:1,
+ c:"h = parseInt(results[{0}], 10);\n",
+ s:"(\\d{1,2})" // 24-hr format of an hour without leading zeroes (0 - 23)
+ },
+ h: function() {
+ return utilDate.formatCodeToRegex("H");
+ },
+ H: {
+ g:1,
+ c:"h = parseInt(results[{0}], 10);\n",
+ s:"(\\d{2})" // 24-hr format of an hour with leading zeroes (00 - 23)
+ },
+ i: {
+ g:1,
+ c:"i = parseInt(results[{0}], 10);\n",
+ s:"(\\d{2})" // minutes with leading zeros (00 - 59)
+ },
+ s: {
+ g:1,
+ c:"s = parseInt(results[{0}], 10);\n",
+ s:"(\\d{2})" // seconds with leading zeros (00 - 59)
+ },
+ u: {
+ g:1,
+ c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
+ s:"(\\d+)" // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
+ },
+ O: {
+ g:1,
+ c:[
+ "o = results[{0}];",
+ "var sn = o.substring(0,1),", // get + / - sign
+ "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", // get hours (performs minutes-to-hour conversion also, just in case)
+ "mn = o.substring(3,5) % 60;", // get minutes
+ "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs
+ ].join("\n"),
+ s: "([+\-]\\d{4})" // GMT offset in hrs and mins
+ },
+ P: {
+ g:1,
+ c:[
+ "o = results[{0}];",
+ "var sn = o.substring(0,1),", // get + / - sign
+ "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", // get hours (performs minutes-to-hour conversion also, just in case)
+ "mn = o.substring(4,6) % 60;", // get minutes
+ "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" // -12hrs <= GMT offset <= 14hrs
+ ].join("\n"),
+ s: "([+\-]\\d{2}:\\d{2})" // GMT offset in hrs and mins (with colon separator)
+ },
+ T: {
+ g:0,
+ c:null,
+ s:"[A-Z]{1,4}" // timezone abbrev. may be between 1 - 4 chars
+ },
+ Z: {
+ g:1,
+ c:"zz = results[{0}] * 1;\n" // -43200 <= UTC offset <= 50400
+ + "zz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
+ s:"([+\-]?\\d{1,5})" // leading '+' sign is optional for UTC offset
},
+ c: function() {
+ var calc = [],
+ arr = [
+ utilDate.formatCodeToRegex("Y", 1), // year
+ utilDate.formatCodeToRegex("m", 2), // month
+ utilDate.formatCodeToRegex("d", 3), // day
+ utilDate.formatCodeToRegex("h", 4), // hour
+ utilDate.formatCodeToRegex("i", 5), // minute
+ utilDate.formatCodeToRegex("s", 6), // second
+ {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"}, // decimal fraction of a second (minimum = 1 digit, maximum = unlimited)
+ {c:[ // allow either "Z" (i.e. UTC) or "-0530" or "+08:00" (i.e. UTC offset) timezone delimiters. assumes local timezone if no timezone is specified
+ "if(results[8]) {", // timezone specified
+ "if(results[8] == 'Z'){",
+ "zz = 0;", // UTC
+ "}else if (results[8].indexOf(':') > -1){",
+ utilDate.formatCodeToRegex("P", 8).c, // timezone offset with colon separator
+ "}else{",
+ utilDate.formatCodeToRegex("O", 8).c, // timezone offset without colon separator
+ "}",
+ "}"
+ ].join('\n')}
+ ];
- margins : margins
- };
-}()
-);
-/**
- * @class Ext.Element
- */
-(function(){
-var D = Ext.lib.Dom,
- LEFT = "left",
- RIGHT = "right",
- TOP = "top",
- BOTTOM = "bottom",
- POSITION = "position",
- STATIC = "static",
- RELATIVE = "relative",
- AUTO = "auto",
- ZINDEX = "z-index";
-
-Ext.Element.addMethods({
- /**
- * Gets the current X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @return {Number} The X position of the element
- */
- getX : function(){
- return D.getX(this.dom);
- },
+ for (var i = 0, l = arr.length; i < l; ++i) {
+ calc.push(arr[i].c);
+ }
- /**
- * Gets the current Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @return {Number} The Y position of the element
- */
- getY : function(){
- return D.getY(this.dom);
+ return {
+ g:1,
+ c:calc.join(""),
+ s:[
+ arr[0].s, // year (required)
+ "(?:", "-", arr[1].s, // month (optional)
+ "(?:", "-", arr[2].s, // day (optional)
+ "(?:",
+ "(?:T| )?", // time delimiter -- either a "T" or a single blank space
+ arr[3].s, ":", arr[4].s, // hour AND minute, delimited by a single colon (optional). MUST be preceded by either a "T" or a single blank space
+ "(?::", arr[5].s, ")?", // seconds (optional)
+ "(?:(?:\\.|,)(\\d+))?", // decimal fraction of a second (e.g. ",12345" or ".98765") (optional)
+ "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?", // "Z" (UTC) or "-0530" (UTC offset without colon delimiter) or "+08:00" (UTC offset with colon delimiter) (optional)
+ ")?",
+ ")?",
+ ")?"
+ ].join("")
+ };
+ },
+ U: {
+ g:1,
+ c:"u = parseInt(results[{0}], 10);\n",
+ s:"(-?\\d+)" // leading minus sign indicates seconds before UNIX epoch
+ }
},
- /**
- * Gets the current position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @return {Array} The XY position of the element
- */
- getXY : function(){
- return D.getXY(this.dom);
+ //Old Ext.Date prototype methods.
+ // private
+ dateFormat: function(date, format) {
+ return utilDate.format(date, format);
},
/**
- * Returns the offsets of this element from the passed element. Both element must be part of the DOM tree and not have display:none to have page coordinates.
- * @param {Mixed} element The element to get the offsets from.
- * @return {Array} The XY page offsets (e.g. [100, -200])
- */
- getOffsetsTo : function(el){
- var o = this.getXY(),
- e = Ext.fly(el, '_internal').getXY();
- return [o[0]-e[0],o[1]-e[1]];
+ * Formats a date given the supplied format string.
+ * @param {Date} date The date to format
+ * @param {String} format The format string
+ * @return {String} The formatted date
+ */
+ format: function(date, format) {
+ if (utilDate.formatFunctions[format] == null) {
+ utilDate.createFormat(format);
+ }
+ var result = utilDate.formatFunctions[format].call(date);
+ return result + '';
},
/**
- * Sets the X position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @param {Number} The X position of the element
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Get the timezone abbreviation of the current date (equivalent to the format specifier 'T').
+ *
+ * Note: The date string returned by the javascript Date object's toString() method varies
+ * between browsers (e.g. FF vs IE) and system region settings (e.g. IE in Asia vs IE in America).
+ * For a given date string e.g. "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)",
+ * getTimezone() first tries to get the timezone abbreviation from between a pair of parentheses
+ * (which may or may not be present), failing which it proceeds to get the timezone abbreviation
+ * from the GMT offset portion of the date string.
+ * @param {Date} date The date
+ * @return {String} The abbreviated timezone name (e.g. 'CST', 'PDT', 'EDT', 'MPST' ...).
*/
- setX : function(x, animate){
- return this.setXY([x, this.getY()], this.animTest(arguments, animate, 1));
+ getTimezone : function(date) {
+ // the following list shows the differences between date strings from different browsers on a WinXP SP2 machine from an Asian locale:
+ //
+ // Opera : "Thu, 25 Oct 2007 22:53:45 GMT+0800" -- shortest (weirdest) date string of the lot
+ // Safari : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone (same as FF)
+ // FF : "Thu Oct 25 2007 22:55:35 GMT+0800 (Malay Peninsula Standard Time)" -- value in parentheses always gives the correct timezone
+ // IE : "Thu Oct 25 22:54:35 UTC+0800 2007" -- (Asian system setting) look for 3-4 letter timezone abbrev
+ // IE : "Thu Oct 25 17:06:37 PDT 2007" -- (American system setting) look for 3-4 letter timezone abbrev
+ //
+ // this crazy regex attempts to guess the correct timezone abbreviation despite these differences.
+ // step 1: (?:\((.*)\) -- find timezone in parentheses
+ // step 2: ([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?) -- if nothing was found in step 1, find timezone from timezone offset portion of date string
+ // step 3: remove all non uppercase characters found in step 1 and 2
+ return date.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
},
/**
- * Sets the Y position of the element based on page coordinates. Element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @param {Number} The Y position of the element
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Get the offset from GMT of the current date (equivalent to the format specifier 'O').
+ * @param {Date} date The date
+ * @param {Boolean} colon (optional) true to separate the hours and minutes with a colon (defaults to false).
+ * @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600').
*/
- setY : function(y, animate){
- return this.setXY([this.getX(), y], this.animTest(arguments, animate, 1));
+ getGMTOffset : function(date, colon) {
+ var offset = date.getTimezoneOffset();
+ return (offset > 0 ? "-" : "+")
+ + Ext.String.leftPad(Math.floor(Math.abs(offset) / 60), 2, "0")
+ + (colon ? ":" : "")
+ + Ext.String.leftPad(Math.abs(offset % 60), 2, "0");
},
/**
- * Sets the element's left position directly using CSS style (instead of {@link #setX}).
- * @param {String} left The left CSS property value
- * @return {Ext.Element} this
+ * Get the numeric day number of the year, adjusted for leap year.
+ * @param {Date} date The date
+ * @return {Number} 0 to 364 (365 in leap years).
*/
- setLeft : function(left){
- this.setStyle(LEFT, this.addUnits(left));
- return this;
+ getDayOfYear: function(date) {
+ var num = 0,
+ d = Ext.Date.clone(date),
+ m = date.getMonth(),
+ i;
+
+ for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
+ num += utilDate.getDaysInMonth(d);
+ }
+ return num + date.getDate() - 1;
},
/**
- * Sets the element's top position directly using CSS style (instead of {@link #setY}).
- * @param {String} top The top CSS property value
- * @return {Ext.Element} this
+ * Get the numeric ISO-8601 week number of the year.
+ * (equivalent to the format specifier 'W', but without a leading zero).
+ * @param {Date} date The date
+ * @return {Number} 1 to 53
+ * @method
*/
- setTop : function(top){
- this.setStyle(TOP, this.addUnits(top));
- return this;
- },
+ getWeekOfYear : (function() {
+ // adapted from http://www.merlyn.demon.co.uk/weekcalc.htm
+ var ms1d = 864e5, // milliseconds in a day
+ ms7d = 7 * ms1d; // milliseconds in a week
- /**
- * Sets the element's CSS right style.
- * @param {String} right The right CSS property value
- * @return {Ext.Element} this
- */
- setRight : function(right){
- this.setStyle(RIGHT, this.addUnits(right));
- return this;
- },
+ return function(date) { // return a closure so constants get calculated only once
+ var DC3 = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate() + 3) / ms1d, // an Absolute Day Number
+ AWN = Math.floor(DC3 / 7), // an Absolute Week Number
+ Wyr = new Date(AWN * ms7d).getUTCFullYear();
- /**
- * Sets the element's CSS bottom style.
- * @param {String} bottom The bottom CSS property value
- * @return {Ext.Element} this
- */
- setBottom : function(bottom){
- this.setStyle(BOTTOM, this.addUnits(bottom));
- return this;
- },
+ return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
+ };
+ })(),
/**
- * Sets the position of the element in page coordinates, regardless of how the element is positioned.
- * The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @param {Array} pos Contains X & Y [x, y] values for new position (coordinates are page-based)
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Checks if the current date falls within a leap year.
+ * @param {Date} date The date
+ * @return {Boolean} True if the current date falls within a leap year, false otherwise.
*/
- setXY : function(pos, animate){
- var me = this;
- if(!animate || !me.anim){
- D.setXY(me.dom, pos);
- }else{
- me.anim({points: {to: pos}}, me.preanim(arguments, 1), 'motion');
- }
- return me;
+ isLeapYear : function(date) {
+ var year = date.getFullYear();
+ return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
},
/**
- * Sets the position of the element in page coordinates, regardless of how the element is positioned.
- * The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @param {Number} x X value for new position (coordinates are page-based)
- * @param {Number} y Y value for new position (coordinates are page-based)
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Get the first day of the current month, adjusted for leap year. The returned value
+ * is the numeric day index within the week (0-6) which can be used in conjunction with
+ * the {@link #monthNames} array to retrieve the textual day name.
+ * Example:
+ *
+ * @param {Date} date The date
+ * @return {Number} The day number (0-6).
*/
- setLocation : function(x, y, animate){
- return this.setXY([x, y], this.animTest(arguments, animate, 2));
+ getFirstDayOfMonth : function(date) {
+ var day = (date.getDay() - (date.getDate() - 1)) % 7;
+ return (day < 0) ? (day + 7) : day;
},
/**
- * Sets the position of the element in page coordinates, regardless of how the element is positioned.
- * The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false).
- * @param {Number} x X value for new position (coordinates are page-based)
- * @param {Number} y Y value for new position (coordinates are page-based)
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
- */
- moveTo : function(x, y, animate){
- return this.setXY([x, y], this.animTest(arguments, animate, 2));
- },
-
- /**
- * Gets the left X coordinate
- * @param {Boolean} local True to get the local css position instead of page coordinate
- * @return {Number}
+ * Get the last day of the current month, adjusted for leap year. The returned value
+ * is the numeric day index within the week (0-6) which can be used in conjunction with
+ * the {@link #monthNames} array to retrieve the textual day name.
+ * Example:
+ *
+ * @param {Date} date The date
+ * @return {Number} The day number (0-6).
*/
- getLeft : function(local){
- return !local ? this.getX() : parseInt(this.getStyle(LEFT), 10) || 0;
+ getLastDayOfMonth : function(date) {
+ return utilDate.getLastDateOfMonth(date).getDay();
},
+
/**
- * Gets the right X coordinate of the element (element X position + element width)
- * @param {Boolean} local True to get the local css position instead of page coordinate
- * @return {Number}
+ * Get the date of the first day of the month in which this date resides.
+ * @param {Date} date The date
+ * @return {Date}
*/
- getRight : function(local){
- var me = this;
- return !local ? me.getX() + me.getWidth() : (me.getLeft(true) + me.getWidth()) || 0;
+ getFirstDateOfMonth : function(date) {
+ return new Date(date.getFullYear(), date.getMonth(), 1);
},
/**
- * Gets the top Y coordinate
- * @param {Boolean} local True to get the local css position instead of page coordinate
- * @return {Number}
+ * Get the date of the last day of the month in which this date resides.
+ * @param {Date} date The date
+ * @return {Date}
*/
- getTop : function(local) {
- return !local ? this.getY() : parseInt(this.getStyle(TOP), 10) || 0;
+ getLastDateOfMonth : function(date) {
+ return new Date(date.getFullYear(), date.getMonth(), utilDate.getDaysInMonth(date));
},
/**
- * Gets the bottom Y coordinate of the element (element Y position + element height)
- * @param {Boolean} local True to get the local css position instead of page coordinate
- * @return {Number}
+ * Get the number of days in the current month, adjusted for leap year.
+ * @param {Date} date The date
+ * @return {Number} The number of days in the month.
+ * @method
*/
- getBottom : function(local){
- var me = this;
- return !local ? me.getY() + me.getHeight() : (me.getTop(true) + me.getHeight()) || 0;
- },
+ getDaysInMonth: (function() {
+ var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+ return function(date) { // return a closure for efficiency
+ var m = date.getMonth();
+
+ return m == 1 && utilDate.isLeapYear(date) ? 29 : daysInMonth[m];
+ };
+ })(),
/**
- * Initializes positioning on this element. If a desired position is not passed, it will make the
- * the element positioned relative IF it is not already positioned.
- * @param {String} pos (optional) Positioning to use "relative", "absolute" or "fixed"
- * @param {Number} zIndex (optional) The zIndex to apply
- * @param {Number} x (optional) Set the page X position
- * @param {Number} y (optional) Set the page Y position
- */
- position : function(pos, zIndex, x, y){
- var me = this;
-
- if(!pos && me.isStyle(POSITION, STATIC)){
- me.setStyle(POSITION, RELATIVE);
- } else if(pos) {
- me.setStyle(POSITION, pos);
- }
- if(zIndex){
- me.setStyle(ZINDEX, zIndex);
+ * Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').
+ * @param {Date} date The date
+ * @return {String} 'st, 'nd', 'rd' or 'th'.
+ */
+ getSuffix : function(date) {
+ switch (date.getDate()) {
+ case 1:
+ case 21:
+ case 31:
+ return "st";
+ case 2:
+ case 22:
+ return "nd";
+ case 3:
+ case 23:
+ return "rd";
+ default:
+ return "th";
}
- if(x || y) me.setXY([x || false, y || false]);
},
/**
- * Clear positioning back to the default when the document was loaded
- * @param {String} value (optional) The value to use for the left,right,top,bottom, defaults to '' (empty string). You could use 'auto'.
- * @return {Ext.Element} this
+ * Creates and returns a new Date instance with the exact same date value as the called instance.
+ * Dates are copied and passed by reference, so if a copied date variable is modified later, the original
+ * variable will also be changed. When the intention is to create a new variable that will not
+ * modify the original instance, you should create a clone.
+ *
+ * Example of correctly cloning a date:
+ *
+//wrong way:
+var orig = new Date('10/1/2006');
+var copy = orig;
+copy.setDate(5);
+console.log(orig); //returns 'Thu Oct 05 2006'!
+
+//correct way:
+var orig = new Date('10/1/2006'),
+ copy = Ext.Date.clone(orig);
+copy.setDate(5);
+console.log(orig); //returns 'Thu Oct 01 2006'
+ *
+ * @param {Date} date The date
+ * @return {Date} The new Date instance.
*/
- clearPositioning : function(value){
- value = value || '';
- this.setStyle({
- left : value,
- right : value,
- top : value,
- bottom : value,
- "z-index" : "",
- position : STATIC
- });
- return this;
+ clone : function(date) {
+ return new Date(date.getTime());
},
/**
- * Gets an object with all CSS positioning properties. Useful along with setPostioning to get
- * snapshot before performing an update and then restoring the element.
- * @return {Object}
- */
- getPositioning : function(){
- var l = this.getStyle(LEFT);
- var t = this.getStyle(TOP);
- return {
- "position" : this.getStyle(POSITION),
- "left" : l,
- "right" : l ? "" : this.getStyle(RIGHT),
- "top" : t,
- "bottom" : t ? "" : this.getStyle(BOTTOM),
- "z-index" : this.getStyle(ZINDEX)
- };
+ * Checks if the current date is affected by Daylight Saving Time (DST).
+ * @param {Date} date The date
+ * @return {Boolean} True if the current date is affected by DST.
+ */
+ isDST : function(date) {
+ // adapted from http://sencha.com/forum/showthread.php?p=247172#post247172
+ // courtesy of @geoffrey.mcgill
+ return new Date(date.getFullYear(), 0, 1).getTimezoneOffset() != date.getTimezoneOffset();
},
-
+
/**
- * Set positioning with an object returned by getPositioning().
- * @param {Object} posCfg
- * @return {Ext.Element} this
+ * Attempts to clear all time information from this Date by setting the time to midnight of the same day,
+ * automatically adjusting for Daylight Saving Time (DST) where applicable.
+ * (note: DST timezone information for the browser's host operating system is assumed to be up-to-date)
+ * @param {Date} date The date
+ * @param {Boolean} clone true to create a clone of this date, clear the time and return it (defaults to false).
+ * @return {Date} this or the clone.
*/
- setPositioning : function(pc){
- var me = this,
- style = me.dom.style;
-
- me.setStyle(pc);
-
- if(pc.right == AUTO){
- style.right = "";
+ clearTime : function(date, clone) {
+ if (clone) {
+ return Ext.Date.clearTime(Ext.Date.clone(date));
}
- if(pc.bottom == AUTO){
- style.bottom = "";
+
+ // get current date before clearing time
+ var d = date.getDate();
+
+ // clear time
+ date.setHours(0);
+ date.setMinutes(0);
+ date.setSeconds(0);
+ date.setMilliseconds(0);
+
+ if (date.getDate() != d) { // account for DST (i.e. day of month changed when setting hour = 0)
+ // note: DST adjustments are assumed to occur in multiples of 1 hour (this is almost always the case)
+ // refer to http://www.timeanddate.com/time/aboutdst.html for the (rare) exceptions to this rule
+
+ // increment hour until cloned date == current date
+ for (var hr = 1, c = utilDate.add(date, Ext.Date.HOUR, hr); c.getDate() != d; hr++, c = utilDate.add(date, Ext.Date.HOUR, hr));
+
+ date.setDate(d);
+ date.setHours(c.getHours());
}
-
- return me;
- },
-
- /**
- * Translates the passed page coordinates into left/top css values for this element
- * @param {Number/Array} x The page x or an array containing [x, y]
- * @param {Number} y (optional) The page y, required if x is not an array
- * @return {Object} An object with left and top properties. e.g. {left: (value), top: (value)}
- */
- translatePoints : function(x, y){
- y = isNaN(x[1]) ? y : x[1];
- x = isNaN(x[0]) ? x : x[0];
- var me = this,
- relative = me.isStyle(POSITION, RELATIVE),
- o = me.getXY(),
- l = parseInt(me.getStyle(LEFT), 10),
- t = parseInt(me.getStyle(TOP), 10);
-
- l = !isNaN(l) ? l : (relative ? 0 : me.dom.offsetLeft);
- t = !isNaN(t) ? t : (relative ? 0 : me.dom.offsetTop);
- return {left: (x - o[0] + l), top: (y - o[1] + t)};
+ return date;
},
-
- animTest : function(args, animate, i) {
- return !!animate && this.preanim ? this.preanim(args, i) : false;
- }
-});
-})();/**
- * @class Ext.Element
- */
-Ext.Element.addMethods({
+
/**
- * Returns true if this element is scrollable.
- * @return {Boolean}
+ * Provides a convenient method for performing basic date arithmetic. This method
+ * does not modify the Date instance being called - it creates and returns
+ * a new Date instance containing the resulting date value.
+ *
+ * Examples:
+ *
+ *
+ * @param {Date} date The date to modify
+ * @param {String} interval A valid date interval enum value.
+ * @param {Number} value The amount to add to the current date.
+ * @return {Date} The new Date instance.
*/
- isScrollable : function(){
- var dom = this.dom;
- return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
+ add : function(date, interval, value) {
+ var d = Ext.Date.clone(date),
+ Date = Ext.Date;
+ if (!interval || value === 0) return d;
+
+ switch(interval.toLowerCase()) {
+ case Ext.Date.MILLI:
+ d.setMilliseconds(d.getMilliseconds() + value);
+ break;
+ case Ext.Date.SECOND:
+ d.setSeconds(d.getSeconds() + value);
+ break;
+ case Ext.Date.MINUTE:
+ d.setMinutes(d.getMinutes() + value);
+ break;
+ case Ext.Date.HOUR:
+ d.setHours(d.getHours() + value);
+ break;
+ case Ext.Date.DAY:
+ d.setDate(d.getDate() + value);
+ break;
+ case Ext.Date.MONTH:
+ var day = date.getDate();
+ if (day > 28) {
+ day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), 'mo', value)).getDate());
+ }
+ d.setDate(day);
+ d.setMonth(date.getMonth() + value);
+ break;
+ case Ext.Date.YEAR:
+ d.setFullYear(date.getFullYear() + value);
+ break;
+ }
+ return d;
},
/**
- * Scrolls this element the specified scroll point. It does NOT do bounds checking so if you scroll to a weird value it will try to do it. For auto bounds checking, use scroll().
- * @param {String} side Either "left" for scrollLeft values or "top" for scrollTop values.
- * @param {Number} value The new scroll value.
- * @return {Element} this
+ * Checks if a date falls on or between the given start and end dates.
+ * @param {Date} date The date to check
+ * @param {Date} start Start date
+ * @param {Date} end End date
+ * @return {Boolean} true if this date falls on or between the given start and end dates.
*/
- scrollTo : function(side, value){
- this.dom["scroll" + (/top/i.test(side) ? "Top" : "Left")] = value;
- return this;
+ between : function(date, start, end) {
+ var t = date.getTime();
+ return start.getTime() <= t && t <= end.getTime();
},
- /**
- * Returns the current scroll position of the element.
- * @return {Object} An object containing the scroll position in the format {left: (scrollLeft), top: (scrollTop)}
- */
- getScroll : function(){
- var d = this.dom,
- doc = document,
- body = doc.body,
- docElement = doc.documentElement,
- l,
- t,
- ret;
+ //Maintains compatibility with old static and prototype window.Date methods.
+ compat: function() {
+ var nativeDate = window.Date,
+ p, u,
+ statics = ['useStrict', 'formatCodeToRegex', 'parseFunctions', 'parseRegexes', 'formatFunctions', 'y2kYear', 'MILLI', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'MONTH', 'YEAR', 'defaults', 'dayNames', 'monthNames', 'monthNumbers', 'getShortMonthName', 'getShortDayName', 'getMonthNumber', 'formatCodes', 'isValid', 'parseDate', 'getFormatCode', 'createFormat', 'createParser', 'parseCodes'],
+ proto = ['dateFormat', 'format', 'getTimezone', 'getGMTOffset', 'getDayOfYear', 'getWeekOfYear', 'isLeapYear', 'getFirstDayOfMonth', 'getLastDayOfMonth', 'getDaysInMonth', 'getSuffix', 'clone', 'isDST', 'clearTime', 'add', 'between'];
- if(d == doc || d == body){
- if(Ext.isIE && Ext.isStrict){
- l = docElement.scrollLeft;
- t = docElement.scrollTop;
- }else{
- l = window.pageXOffset;
- t = window.pageYOffset;
- }
- ret = {left: l || (body ? body.scrollLeft : 0), top: t || (body ? body.scrollTop : 0)};
- }else{
- ret = {left: d.scrollLeft, top: d.scrollTop};
- }
- return ret;
- }
-});/**
- * @class Ext.Element
- */
-/**
- * Visibility mode constant for use with {@link #setVisibilityMode}. Use visibility to hide element
- * @static
- * @type Number
- */
-Ext.Element.VISIBILITY = 1;
-/**
- * Visibility mode constant for use with {@link #setVisibilityMode}. Use display to hide element
- * @static
- * @type Number
- */
-Ext.Element.DISPLAY = 2;
+ //Append statics
+ Ext.Array.forEach(statics, function(s) {
+ nativeDate[s] = utilDate[s];
+ });
-/**
- * Visibility mode constant for use with {@link #setVisibilityMode}. Use offsets (x and y positioning offscreen)
- * to hide element.
- * @static
- * @type Number
- */
-Ext.Element.OFFSETS = 3;
+ //Append to prototype
+ Ext.Array.forEach(proto, function(s) {
+ nativeDate.prototype[s] = function() {
+ var args = Array.prototype.slice.call(arguments);
+ args.unshift(this);
+ return utilDate[s].apply(utilDate, args);
+ };
+ });
+ }
+};
+var utilDate = Ext.Date;
-Ext.Element.ASCLASS = 4;
+})();
/**
- * Defaults to 'x-hide-nosize'
- * @static
- * @type String
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.Base
+ *
+ * The root of all classes created with {@link Ext#define}
+ * All prototype and static members of this class are inherited by any other class
+ *
*/
-Ext.Element.visibilityCls = 'x-hide-nosize';
+(function(flexSetter) {
-Ext.Element.addMethods(function(){
- var El = Ext.Element,
- OPACITY = "opacity",
- VISIBILITY = "visibility",
- DISPLAY = "display",
- HIDDEN = "hidden",
- OFFSETS = "offsets",
- ASCLASS = "asclass",
- NONE = "none",
- NOSIZE = 'nosize',
- ORIGINALDISPLAY = 'originalDisplay',
- VISMODE = 'visibilityMode',
- ISVISIBLE = 'isVisible',
- data = El.data,
- getDisplay = function(dom){
- var d = data(dom, ORIGINALDISPLAY);
- if(d === undefined){
- data(dom, ORIGINALDISPLAY, d = '');
- }
- return d;
- },
- getVisMode = function(dom){
- var m = data(dom, VISMODE);
- if(m === undefined){
- data(dom, VISMODE, m = 1);
- }
- return m;
- };
+var Base = Ext.Base = function() {};
+ Base.prototype = {
+ $className: 'Ext.Base',
- return {
- /**
- * The element's default display mode (defaults to "")
- * @type String
- */
- originalDisplay : "",
- visibilityMode : 1,
+ $class: Base,
/**
- * Sets the element's visibility mode. When setVisible() is called it
- * will use this to determine whether to set the visibility or the display property.
- * @param {Number} visMode Ext.Element.VISIBILITY or Ext.Element.DISPLAY
- * @return {Ext.Element} this
+ * Get the reference to the current class from which this object was instantiated. Unlike {@link Ext.Base#statics},
+ * `this.self` is scope-dependent and it's meant to be used for dynamic inheritance. See {@link Ext.Base#statics}
+ * for a detailed comparison
+ *
+ * Ext.define('My.Cat', {
+ * statics: {
+ * speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
+ * },
+ *
+ * constructor: function() {
+ * alert(this.self.speciesName); / dependent on 'this'
+ *
+ * return this;
+ * },
+ *
+ * clone: function() {
+ * return new this.self();
+ * }
+ * });
+ *
+ *
+ * Ext.define('My.SnowLeopard', {
+ * extend: 'My.Cat',
+ * statics: {
+ * speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
+ * }
+ * });
+ *
+ * var cat = new My.Cat(); // alerts 'Cat'
+ * var snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard'
+ *
+ * var clone = snowLeopard.clone();
+ * alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
+ *
+ * @type Class
+ * @protected
*/
- setVisibilityMode : function(visMode){
- data(this.dom, VISMODE, visMode);
+ self: Base,
+
+ // Default constructor, simply returns `this`
+ constructor: function() {
return this;
},
/**
- * Perform custom animation on this element.
- *
- *
Animation Properties
- *
- *
The Animation Control Object enables gradual transitions for any member of an
- * element's style object that takes a numeric value including but not limited to
- * these properties:
- *
bottom, top, left, right
- *
height, width
- *
margin, padding
- *
borderWidth
- *
opacity
- *
fontSize
- *
lineHeight
- *
- *
+ * Initialize configuration for this class. a typical example:
*
- *
Animation Property Attributes
- *
- *
Each Animation Property is a config object with optional properties:
- *
- *
by* : relative change - start at current value, change by this value
- *
from : ignore current value, start from this value
- *
to* : start at current value, go to this value
- *
unit : any allowable unit specification
- *
* do not specify both to and by for an animation property
+ * var awesome = new My.awesome.Class({
+ * name: 'Super Awesome'
+ * });
*
- *
+ * alert(awesome.getName()); // 'Super Awesome'
*
- * @param {Object} args The animation control args
- * @param {Float} duration (optional) How long the animation lasts in seconds (defaults to .35)
- * @param {Function} onComplete (optional) Function to call when animation completes
- * @param {String} easing (optional) {@link Ext.Fx#easing} method to use (defaults to 'easeOut')
- * @param {String} animType (optional) 'run' is the default. Can also be 'color',
- * 'motion', or 'scroll'
- * @return {Ext.Element} this
+ * @protected
+ * @param {Object} config
+ * @return {Object} mixins The mixin prototypes as key - value pairs
*/
- animate : function(args, duration, onComplete, easing, animType){
- this.anim(args, {duration: duration, callback: onComplete, easing: easing}, animType);
+ initConfig: function(config) {
+ if (!this.$configInited) {
+ this.config = Ext.Object.merge({}, this.config || {}, config || {});
+
+ this.applyConfig(this.config);
+
+ this.$configInited = true;
+ }
+
return this;
},
- /*
- * @private Internal animation call
+ /**
+ * @private
*/
- anim : function(args, opt, animType, defaultDur, defaultEase, cb){
- animType = animType || 'run';
- opt = opt || {};
- var me = this,
- anim = Ext.lib.Anim[animType](
- me.dom,
- args,
- (opt.duration || defaultDur) || .35,
- (opt.easing || defaultEase) || 'easeOut',
- function(){
- if(cb) cb.call(me);
- if(opt.callback) opt.callback.call(opt.scope || me, me, opt);
- },
- me
- );
- opt.anim = anim;
- return anim;
- },
+ setConfig: function(config) {
+ this.applyConfig(config || {});
- // private legacy anim prep
- preanim : function(a, i){
- return !a[i] ? false : (typeof a[i] == 'object' ? a[i]: {duration: a[i+1], callback: a[i+2], easing: a[i+3]});
+ return this;
},
/**
- * Checks whether the element is currently visible using both visibility and display properties.
- * @return {Boolean} True if the element is currently visible, else false
+ * @private
*/
- isVisible : function() {
- var me = this,
- dom = me.dom,
- visible = data(dom, ISVISIBLE);
+ applyConfig: flexSetter(function(name, value) {
+ var setter = 'set' + Ext.String.capitalize(name);
- if(typeof visible == 'boolean'){ //return the cached value if registered
- return visible;
+ if (typeof this[setter] === 'function') {
+ this[setter].call(this, value);
}
- //Determine the current state based on display states
- visible = !me.isStyle(VISIBILITY, HIDDEN) &&
- !me.isStyle(DISPLAY, NONE) &&
- !((getVisMode(dom) == El.ASCLASS) && me.hasClass(me.visibilityCls || El.visibilityCls));
- data(dom, ISVISIBLE, visible);
- return visible;
- },
+ return this;
+ }),
/**
- * Sets the visibility of the element (see details). If the visibilityMode is set to Element.DISPLAY, it will use
- * the display property to hide the element, otherwise it uses visibility. The default is to hide and show using the visibility property.
- * @param {Boolean} visible Whether the element is visible
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Call the parent's overridden method. For example:
+ *
+ * Ext.define('My.own.A', {
+ * constructor: function(test) {
+ * alert(test);
+ * }
+ * });
+ *
+ * Ext.define('My.own.B', {
+ * extend: 'My.own.A',
+ *
+ * constructor: function(test) {
+ * alert(test);
+ *
+ * this.callParent([test + 1]);
+ * }
+ * });
+ *
+ * Ext.define('My.own.C', {
+ * extend: 'My.own.B',
+ *
+ * constructor: function() {
+ * alert("Going to call parent's overriden constructor...");
+ *
+ * this.callParent(arguments);
+ * }
+ * });
+ *
+ * var a = new My.own.A(1); // alerts '1'
+ * var b = new My.own.B(1); // alerts '1', then alerts '2'
+ * var c = new My.own.C(2); // alerts "Going to call parent's overriden constructor..."
+ * // alerts '2', then alerts '3'
+ *
+ * @protected
+ * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
+ * from the current method, for example: `this.callParent(arguments)`
+ * @return {Mixed} Returns the result from the superclass' method
*/
- setVisible : function(visible, animate){
- var me = this, isDisplay, isVisibility, isOffsets, isNosize,
- dom = me.dom,
- visMode = getVisMode(dom);
+ callParent: function(args) {
+ var method = this.callParent.caller,
+ parentClass, methodName;
+ if (!method.$owner) {
- // hideMode string override
- if (typeof animate == 'string'){
- switch (animate) {
- case DISPLAY:
- visMode = El.DISPLAY;
- break;
- case VISIBILITY:
- visMode = El.VISIBILITY;
- break;
- case OFFSETS:
- visMode = El.OFFSETS;
- break;
- case NOSIZE:
- case ASCLASS:
- visMode = El.ASCLASS;
- break;
- }
- me.setVisibilityMode(visMode);
- animate = false;
+ method = method.caller;
}
- if (!animate || !me.anim) {
- if(visMode == El.ASCLASS ){
-
- me[visible?'removeClass':'addClass'](me.visibilityCls || El.visibilityCls);
+ parentClass = method.$owner.superclass;
+ methodName = method.$name;
- } else if (visMode == El.DISPLAY){
- return me.setDisplayed(visible);
+ return parentClass[methodName].apply(this, args || []);
+ },
- } else if (visMode == El.OFFSETS){
- if (!visible){
- me.hideModeStyles = {
- position: me.getStyle('position'),
- top: me.getStyle('top'),
- left: me.getStyle('left')
- };
- me.applyStyles({position: 'absolute', top: '-10000px', left: '-10000px'});
- } else {
- me.applyStyles(me.hideModeStyles || {position: '', top: '', left: ''});
- delete me.hideModeStyles;
- }
+ /**
+ * Get the reference to the class from which this object was instantiated. Note that unlike {@link Ext.Base#self},
+ * `this.statics()` is scope-independent and it always returns the class from which it was called, regardless of what
+ * `this` points to during run-time
+ *
+ * Ext.define('My.Cat', {
+ * statics: {
+ * totalCreated: 0,
+ * speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
+ * },
+ *
+ * constructor: function() {
+ * var statics = this.statics();
+ *
+ * alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to
+ * // equivalent to: My.Cat.speciesName
+ *
+ * alert(this.self.speciesName); // dependent on 'this'
+ *
+ * statics.totalCreated++;
+ *
+ * return this;
+ * },
+ *
+ * clone: function() {
+ * var cloned = new this.self; // dependent on 'this'
+ *
+ * cloned.groupName = this.statics().speciesName; // equivalent to: My.Cat.speciesName
+ *
+ * return cloned;
+ * }
+ * });
+ *
+ *
+ * Ext.define('My.SnowLeopard', {
+ * extend: 'My.Cat',
+ *
+ * statics: {
+ * speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
+ * },
+ *
+ * constructor: function() {
+ * this.callParent();
+ * }
+ * });
+ *
+ * var cat = new My.Cat(); // alerts 'Cat', then alerts 'Cat'
+ *
+ * var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts 'Snow Leopard'
+ *
+ * var clone = snowLeopard.clone();
+ * alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
+ * alert(clone.groupName); // alerts 'Cat'
+ *
+ * alert(My.Cat.totalCreated); // alerts 3
+ *
+ * @protected
+ * @return {Class}
+ */
+ statics: function() {
+ var method = this.statics.caller,
+ self = this.self;
- }else{
- me.fixDisplay();
- dom.style.visibility = visible ? "visible" : HIDDEN;
- }
- }else{
- // closure for composites
- if(visible){
- me.setOpacity(.01);
- me.setVisible(true);
- }
- me.anim({opacity: { to: (visible?1:0) }},
- me.preanim(arguments, 1),
- null,
- .35,
- 'easeIn',
- function(){
- visible || me.setVisible(false).setOpacity(1);
- });
+ if (!method) {
+ return self;
}
- data(dom, ISVISIBLE, visible); //set logical visibility state
- return me;
- },
+ return method.$owner;
+ },
/**
- * @private
- * Determine if the Element has a relevant height and width available based
- * upon current logical visibility state
+ * Call the original method that was previously overridden with {@link Ext.Base#override}
+ *
+ * Ext.define('My.Cat', {
+ * constructor: function() {
+ * alert("I'm a cat!");
+ *
+ * return this;
+ * }
+ * });
+ *
+ * My.Cat.override({
+ * constructor: function() {
+ * alert("I'm going to be a cat!");
+ *
+ * var instance = this.callOverridden();
+ *
+ * alert("Meeeeoooowwww");
+ *
+ * return instance;
+ * }
+ * });
+ *
+ * var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
+ * // alerts "I'm a cat!"
+ * // alerts "Meeeeoooowwww"
+ *
+ * @param {Array/Arguments} args The arguments, either an array or the `arguments` object
+ * @return {Mixed} Returns the result after calling the overridden method
*/
- hasMetrics : function(){
- var dom = this.dom;
- return this.isVisible() || (getVisMode(dom) == El.VISIBILITY);
+ callOverridden: function(args) {
+ var method = this.callOverridden.caller;
+
+
+ return method.$previous.apply(this, args || []);
},
+ destroy: function() {}
+ };
+
+ // These static properties will be copied to every newly created class with {@link Ext#define}
+ Ext.apply(Ext.Base, {
/**
- * Toggles the element's visibility or display, depending on visibility mode.
- * @param {Boolean/Object} animate (optional) True for the default animation, or a standard Element animation config object
- * @return {Ext.Element} this
+ * Create a new instance of this Class.
+ *
+ * Ext.define('My.cool.Class', {
+ * ...
+ * });
+ *
+ * My.cool.Class.create({
+ * someConfig: true
+ * });
+ *
+ * All parameters are passed to the constructor of the class.
+ *
+ * @return {Object} the created instance.
+ * @static
*/
- toggle : function(animate){
- var me = this;
- me.setVisible(!me.isVisible(), me.preanim(arguments, 0));
- return me;
+ create: function() {
+ return Ext.create.apply(Ext, [this].concat(Array.prototype.slice.call(arguments, 0)));
},
/**
- * Sets the CSS display property. Uses originalDisplay if the specified value is a boolean true.
- * @param {Mixed} value Boolean value to display the element using its default display, or a string to set the display directly.
- * @return {Ext.Element} this
+ * @private
*/
- setDisplayed : function(value) {
- if(typeof value == "boolean"){
- value = value ? getDisplay(this.dom) : NONE;
+ own: flexSetter(function(name, value) {
+ if (typeof value === 'function') {
+ this.ownMethod(name, value);
}
- this.setStyle(DISPLAY, value);
+ else {
+ this.prototype[name] = value;
+ }
+ }),
+
+ /**
+ * @private
+ */
+ ownMethod: function(name, fn) {
+ var originalFn;
+
+ if (fn.$owner !== undefined && fn !== Ext.emptyFn) {
+ originalFn = fn;
+
+ fn = function() {
+ return originalFn.apply(this, arguments);
+ };
+ }
+
+ fn.$owner = this;
+ fn.$name = name;
+
+ this.prototype[name] = fn;
+ },
+
+ /**
+ * Add / override static properties of this class.
+ *
+ * Ext.define('My.cool.Class', {
+ * ...
+ * });
+ *
+ * My.cool.Class.addStatics({
+ * someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
+ * method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
+ * method2: function() { ... } // My.cool.Class.method2 = function() { ... };
+ * });
+ *
+ * @param {Object} members
+ * @return {Ext.Base} this
+ * @static
+ */
+ addStatics: function(members) {
+ for (var name in members) {
+ if (members.hasOwnProperty(name)) {
+ this[name] = members[name];
+ }
+ }
+
return this;
},
- // private
- fixDisplay : function(){
- var me = this;
- if(me.isStyle(DISPLAY, NONE)){
- me.setStyle(VISIBILITY, HIDDEN);
- me.setStyle(DISPLAY, getDisplay(this.dom)); // first try reverting to default
- if(me.isStyle(DISPLAY, NONE)){ // if that fails, default to block
- me.setStyle(DISPLAY, "block");
+ /**
+ * Add methods / properties to the prototype of this class.
+ *
+ * Ext.define('My.awesome.Cat', {
+ * constructor: function() {
+ * ...
+ * }
+ * });
+ *
+ * My.awesome.Cat.implement({
+ * meow: function() {
+ * alert('Meowww...');
+ * }
+ * });
+ *
+ * var kitty = new My.awesome.Cat;
+ * kitty.meow();
+ *
+ * @param {Object} members
+ * @static
+ */
+ implement: function(members) {
+ var prototype = this.prototype,
+ name, i, member, previous;
+ for (name in members) {
+ if (members.hasOwnProperty(name)) {
+ member = members[name];
+
+ if (typeof member === 'function') {
+ member.$owner = this;
+ member.$name = name;
+ }
+
+ prototype[name] = member;
+ }
+ }
+
+ if (Ext.enumerables) {
+ var enumerables = Ext.enumerables;
+
+ for (i = enumerables.length; i--;) {
+ name = enumerables[i];
+
+ if (members.hasOwnProperty(name)) {
+ member = members[name];
+ member.$owner = this;
+ member.$name = name;
+ prototype[name] = member;
+ }
}
}
},
/**
- * Hide this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}.
- * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
- * @return {Ext.Element} this
+ * Borrow another class' members to the prototype of this class.
+ *
+ * Ext.define('Bank', {
+ * money: '$$$',
+ * printMoney: function() {
+ * alert('$$$$$$$');
+ * }
+ * });
+ *
+ * Ext.define('Thief', {
+ * ...
+ * });
+ *
+ * Thief.borrow(Bank, ['money', 'printMoney']);
+ *
+ * var steve = new Thief();
+ *
+ * alert(steve.money); // alerts '$$$'
+ * steve.printMoney(); // alerts '$$$$$$$'
+ *
+ * @param {Ext.Base} fromClass The class to borrow members from
+ * @param {Array/String} members The names of the members to borrow
+ * @return {Ext.Base} this
+ * @static
+ * @private
*/
- hide : function(animate){
- // hideMode override
- if (typeof animate == 'string'){
- this.setVisible(false, animate);
- return this;
+ borrow: function(fromClass, members) {
+ var fromPrototype = fromClass.prototype,
+ i, ln, member;
+
+ members = Ext.Array.from(members);
+
+ for (i = 0, ln = members.length; i < ln; i++) {
+ member = members[i];
+
+ this.own(member, fromPrototype[member]);
}
- this.setVisible(false, this.preanim(arguments, 0));
+
return this;
},
/**
- * Show this element - Uses display mode to determine whether to use "display" or "visibility". See {@link #setVisible}.
- * @param {Boolean/Object} animate (optional) true for the default animation or a standard Element animation config object
- * @return {Ext.Element} this
+ * Override prototype members of this class. Overridden methods can be invoked via
+ * {@link Ext.Base#callOverridden}
+ *
+ * Ext.define('My.Cat', {
+ * constructor: function() {
+ * alert("I'm a cat!");
+ *
+ * return this;
+ * }
+ * });
+ *
+ * My.Cat.override({
+ * constructor: function() {
+ * alert("I'm going to be a cat!");
+ *
+ * var instance = this.callOverridden();
+ *
+ * alert("Meeeeoooowwww");
+ *
+ * return instance;
+ * }
+ * });
+ *
+ * var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
+ * // alerts "I'm a cat!"
+ * // alerts "Meeeeoooowwww"
+ *
+ * @param {Object} members
+ * @return {Ext.Base} this
+ * @static
*/
- show : function(animate){
- // hideMode override
- if (typeof animate == 'string'){
- this.setVisible(true, animate);
- return this;
+ override: function(members) {
+ var prototype = this.prototype,
+ name, i, member, previous;
+
+ for (name in members) {
+ if (members.hasOwnProperty(name)) {
+ member = members[name];
+
+ if (typeof member === 'function') {
+ if (typeof prototype[name] === 'function') {
+ previous = prototype[name];
+ member.$previous = previous;
+ }
+
+ this.ownMethod(name, member);
+ }
+ else {
+ prototype[name] = member;
+ }
+ }
+ }
+
+ if (Ext.enumerables) {
+ var enumerables = Ext.enumerables;
+
+ for (i = enumerables.length; i--;) {
+ name = enumerables[i];
+
+ if (members.hasOwnProperty(name)) {
+ if (prototype[name] !== undefined) {
+ previous = prototype[name];
+ members[name].$previous = previous;
+ }
+
+ this.ownMethod(name, members[name]);
+ }
+ }
}
- this.setVisible(true, this.preanim(arguments, 0));
+
return this;
- }
- };
-}());(function(){
- // contants
- var NULL = null,
- UNDEFINED = undefined,
- TRUE = true,
- FALSE = false,
- SETX = "setX",
- SETY = "setY",
- SETXY = "setXY",
- LEFT = "left",
- BOTTOM = "bottom",
- TOP = "top",
- RIGHT = "right",
- HEIGHT = "height",
- WIDTH = "width",
- POINTS = "points",
- HIDDEN = "hidden",
- ABSOLUTE = "absolute",
- VISIBLE = "visible",
- MOTION = "motion",
- POSITION = "position",
- EASEOUT = "easeOut",
- /*
- * Use a light flyweight here since we are using so many callbacks and are always assured a DOM element
- */
- flyEl = new Ext.Element.Flyweight(),
- queues = {},
- getObject = function(o){
- return o || {};
- },
- fly = function(dom){
- flyEl.dom = dom;
- flyEl.id = Ext.id(dom);
- return flyEl;
},
- /*
- * Queueing now stored outside of the element due to closure issues
+
+ /**
+ * Used internally by the mixins pre-processor
+ * @private
*/
- getQueue = function(id){
- if(!queues[id]){
- queues[id] = [];
+ mixin: flexSetter(function(name, cls) {
+ var mixin = cls.prototype,
+ my = this.prototype,
+ i, fn;
+
+ for (i in mixin) {
+ if (mixin.hasOwnProperty(i)) {
+ if (my[i] === undefined) {
+ if (typeof mixin[i] === 'function') {
+ fn = mixin[i];
+
+ if (fn.$owner === undefined) {
+ this.ownMethod(i, fn);
+ }
+ else {
+ my[i] = fn;
+ }
+ }
+ else {
+ my[i] = mixin[i];
+ }
+ }
+ else if (i === 'config' && my.config && mixin.config) {
+ Ext.Object.merge(my.config, mixin.config);
+ }
+ }
+ }
+
+ if (my.mixins === undefined) {
+ my.mixins = {};
}
- return queues[id];
+
+ my.mixins[name] = mixin;
+ }),
+
+ /**
+ * Get the current class' name in string format.
+ *
+ * Ext.define('My.cool.Class', {
+ * constructor: function() {
+ * alert(this.self.getName()); // alerts 'My.cool.Class'
+ * }
+ * });
+ *
+ * My.cool.Class.getName(); // 'My.cool.Class'
+ *
+ * @return {String} className
+ */
+ getName: function() {
+ return Ext.getClassName(this);
},
- setQueue = function(id, value){
- queues[id] = value;
- };
-
-//Notifies Element that fx methods are available
-Ext.enableFx = TRUE;
+
+ /**
+ * Create aliases for existing prototype methods. Example:
+ *
+ * Ext.define('My.cool.Class', {
+ * method1: function() { ... },
+ * method2: function() { ... }
+ * });
+ *
+ * var test = new My.cool.Class();
+ *
+ * My.cool.Class.createAlias({
+ * method3: 'method1',
+ * method4: 'method2'
+ * });
+ *
+ * test.method3(); // test.method1()
+ *
+ * My.cool.Class.createAlias('method5', 'method3');
+ *
+ * test.method5(); // test.method3() -> test.method1()
+ *
+ * @param {String/Object} alias The new method name, or an object to set multiple aliases. See
+ * {@link Ext.Function#flexSetter flexSetter}
+ * @param {String/Object} origin The original method name
+ * @static
+ * @method
+ */
+ createAlias: flexSetter(function(alias, origin) {
+ this.prototype[alias] = this.prototype[origin];
+ })
+ });
+
+})(Ext.Function.flexSetter);
/**
- * @class Ext.Fx
- *
A class to provide basic animation and visual effects support. Note: This class is automatically applied
- * to the {@link Ext.Element} interface when included, so all effects calls should be performed via {@link Ext.Element}.
- * Conversely, since the effects are not actually defined in {@link Ext.Element}, Ext.Fx must be
- * {@link Ext#enableFx included} in order for the Element effects to work.
- *
- *
Method Chaining
- *
It is important to note that although the Fx methods and many non-Fx Element methods support "method chaining" in that
- * they return the Element object itself as the method return value, it is not always possible to mix the two in a single
- * method chain. The Fx methods use an internal effects queue so that each effect can be properly timed and sequenced.
- * Non-Fx methods, on the other hand, have no such internal queueing and will always execute immediately. For this reason,
- * while it may be possible to mix certain Fx and non-Fx method calls in a single chain, it may not always provide the
- * expected results and should be done with care. Also see {@link #callback}.
- *
- *
Anchor Options for Motion Effects
- *
Motion effects support 8-way anchoring, meaning that you can choose one of 8 different anchor points on the Element
- * that will serve as either the start or end point of the animation. Following are all of the supported anchor positions:
-
-Value Description
------ -----------------------------
-tl The top left corner
-t The center of the top edge
-tr The top right corner
-l The center of the left edge
-r The center of the right edge
-bl The bottom left corner
-b The center of the bottom edge
-br The bottom right corner
-
- * Note: some Fx methods accept specific custom config parameters. The options shown in the Config Options
- * section below are common options that can be passed to any Fx method unless otherwise noted.
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.Class
*
- * @cfg {Function} callback A function called when the effect is finished. Note that effects are queued internally by the
- * Fx class, so a callback is not required to specify another effect -- effects can simply be chained together
- * and called in sequence (see note for Method Chaining above), for example:
- * el.slideIn().highlight();
- *
- * The callback is intended for any additional code that should run once a particular effect has completed. The Element
- * being operated upon is passed as the first parameter.
- *
- * @cfg {Object} scope The scope (this reference) in which the {@link #callback} function is executed. Defaults to the browser window.
- *
- * @cfg {String} easing A valid Ext.lib.Easing value for the effect:
- *
backBoth
- *
backIn
- *
backOut
- *
bounceBoth
- *
bounceIn
- *
bounceOut
- *
easeBoth
- *
easeBothStrong
- *
easeIn
- *
easeInStrong
- *
easeNone
- *
easeOut
- *
easeOutStrong
- *
elasticBoth
- *
elasticIn
- *
elasticOut
- *
- *
- * @cfg {String} afterCls A css class to apply after the effect
- * @cfg {Number} duration The length of time (in seconds) that the effect should last
+ * Handles class creation throughout the whole framework. Note that most of the time {@link Ext#define Ext.define} should
+ * be used instead, since it's a higher level wrapper that aliases to {@link Ext.ClassManager#create}
+ * to enable namespacing and dynamic dependency resolution.
*
- * @cfg {Number} endOpacity Only applicable for {@link #fadeIn} or {@link #fadeOut}, a number between
- * 0 and 1 inclusive to configure the ending opacity value.
- *
- * @cfg {Boolean} remove Whether the Element should be removed from the DOM and destroyed after the effect finishes
- * @cfg {Boolean} useDisplay Whether to use the display CSS property instead of visibility when hiding Elements (only applies to
- * effects that end with the element being visually hidden, ignored otherwise)
- * @cfg {String/Object/Function} afterStyle A style specification string, e.g. "width:100px", or an object
- * in the form {width:"100px"}, or a function which returns such a specification that will be applied to the
- * Element after the effect finishes.
- * @cfg {Boolean} block Whether the effect should block other effects from queueing while it runs
- * @cfg {Boolean} concurrent Whether to allow subsequently-queued effects to run at the same time as the current effect, or to ensure that they run in sequence
- * @cfg {Boolean} stopFx Whether preceding effects should be stopped and removed before running current effect (only applies to non blocking effects)
+ * # Basic syntax: #
+ *
+ * Ext.define(className, properties);
+ *
+ * in which `properties` is an object represent a collection of properties that apply to the class. See
+ * {@link Ext.ClassManager#create} for more detailed instructions.
+ *
+ * Ext.define('Person', {
+ * name: 'Unknown',
+ *
+ * constructor: function(name) {
+ * if (name) {
+ * this.name = name;
+ * }
+ *
+ * return this;
+ * },
+ *
+ * eat: function(foodType) {
+ * alert("I'm eating: " + foodType);
+ *
+ * return this;
+ * }
+ * });
+ *
+ * var aaron = new Person("Aaron");
+ * aaron.eat("Sandwich"); // alert("I'm eating: Sandwich");
+ *
+ * Ext.Class has a powerful set of extensible {@link Ext.Class#registerPreprocessor pre-processors} which takes care of
+ * everything related to class creation, including but not limited to inheritance, mixins, configuration, statics, etc.
+ *
+ * # Inheritance: #
+ *
+ * Ext.define('Developer', {
+ * extend: 'Person',
+ *
+ * constructor: function(name, isGeek) {
+ * this.isGeek = isGeek;
+ *
+ * // Apply a method from the parent class' prototype
+ * this.callParent([name]);
+ *
+ * return this;
+ *
+ * },
+ *
+ * code: function(language) {
+ * alert("I'm coding in: " + language);
+ *
+ * this.eat("Bugs");
+ *
+ * return this;
+ * }
+ * });
+ *
+ * var jacky = new Developer("Jacky", true);
+ * jacky.code("JavaScript"); // alert("I'm coding in: JavaScript");
+ * // alert("I'm eating: Bugs");
+ *
+ * See {@link Ext.Base#callParent} for more details on calling superclass' methods
+ *
+ * # Mixins: #
+ *
+ * Ext.define('CanPlayGuitar', {
+ * playGuitar: function() {
+ * alert("F#...G...D...A");
+ * }
+ * });
+ *
+ * Ext.define('CanComposeSongs', {
+ * composeSongs: function() { ... }
+ * });
+ *
+ * Ext.define('CanSing', {
+ * sing: function() {
+ * alert("I'm on the highway to hell...")
+ * }
+ * });
+ *
+ * Ext.define('Musician', {
+ * extend: 'Person',
+ *
+ * mixins: {
+ * canPlayGuitar: 'CanPlayGuitar',
+ * canComposeSongs: 'CanComposeSongs',
+ * canSing: 'CanSing'
+ * }
+ * })
+ *
+ * Ext.define('CoolPerson', {
+ * extend: 'Person',
+ *
+ * mixins: {
+ * canPlayGuitar: 'CanPlayGuitar',
+ * canSing: 'CanSing'
+ * },
+ *
+ * sing: function() {
+ * alert("Ahem....");
+ *
+ * this.mixins.canSing.sing.call(this);
+ *
+ * alert("[Playing guitar at the same time...]");
+ *
+ * this.playGuitar();
+ * }
+ * });
+ *
+ * var me = new CoolPerson("Jacky");
+ *
+ * me.sing(); // alert("Ahem...");
+ * // alert("I'm on the highway to hell...");
+ * // alert("[Playing guitar at the same time...]");
+ * // alert("F#...G...D...A");
+ *
+ * # Config: #
+ *
+ * Ext.define('SmartPhone', {
+ * config: {
+ * hasTouchScreen: false,
+ * operatingSystem: 'Other',
+ * price: 500
+ * },
+ *
+ * isExpensive: false,
+ *
+ * constructor: function(config) {
+ * this.initConfig(config);
+ *
+ * return this;
+ * },
+ *
+ * applyPrice: function(price) {
+ * this.isExpensive = (price > 500);
+ *
+ * return price;
+ * },
+ *
+ * applyOperatingSystem: function(operatingSystem) {
+ * if (!(/^(iOS|Android|BlackBerry)$/i).test(operatingSystem)) {
+ * return 'Other';
+ * }
+ *
+ * return operatingSystem;
+ * }
+ * });
+ *
+ * var iPhone = new SmartPhone({
+ * hasTouchScreen: true,
+ * operatingSystem: 'iOS'
+ * });
+ *
+ * iPhone.getPrice(); // 500;
+ * iPhone.getOperatingSystem(); // 'iOS'
+ * iPhone.getHasTouchScreen(); // true;
+ * iPhone.hasTouchScreen(); // true
+ *
+ * iPhone.isExpensive; // false;
+ * iPhone.setPrice(600);
+ * iPhone.getPrice(); // 600
+ * iPhone.isExpensive; // true;
+ *
+ * iPhone.setOperatingSystem('AlienOS');
+ * iPhone.getOperatingSystem(); // 'Other'
+ *
+ * # Statics: #
+ *
+ * Ext.define('Computer', {
+ * statics: {
+ * factory: function(brand) {
+ * // 'this' in static methods refer to the class itself
+ * return new this(brand);
+ * }
+ * },
+ *
+ * constructor: function() { ... }
+ * });
+ *
+ * var dellComputer = Computer.factory('Dell');
+ *
+ * Also see {@link Ext.Base#statics} and {@link Ext.Base#self} for more details on accessing
+ * static properties within class methods
+ *
*/
-Ext.Fx = {
-
- // private - calls the function taking arguments from the argHash based on the key. Returns the return value of the function.
- // this is useful for replacing switch statements (for example).
- switchStatements : function(key, fn, argHash){
- return fn.apply(this, argHash[key]);
- },
-
- /**
- * Slides the element into view. An anchor point can be optionally passed to set the point of
- * origin for the slide effect. This function automatically handles wrapping the element with
- * a fixed-size container if needed. See the Fx class overview for valid anchor point options.
- * Usage:
- *
-// default: slide the element in from the top
-el.slideIn();
+(function() {
-// custom: slide the element in from the right with a 2-second duration
-el.slideIn('r', { duration: 2 });
+ var Class,
+ Base = Ext.Base,
+ baseStaticProperties = [],
+ baseStaticProperty;
-// common config options shown with default values
-el.slideIn('t', {
- easing: 'easeOut',
- duration: .5
-});
-
- * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't')
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- slideIn : function(anchor, o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- st = dom.style,
- xy,
- r,
- b,
- wrap,
- after,
- st,
- args,
- pt,
- bw,
- bh;
-
- anchor = anchor || "t";
+ for (baseStaticProperty in Base) {
+ if (Base.hasOwnProperty(baseStaticProperty)) {
+ baseStaticProperties.push(baseStaticProperty);
+ }
+ }
- me.queueFx(o, function(){
- xy = fly(dom).getXY();
- // fix display to visibility
- fly(dom).fixDisplay();
-
- // restore values after effect
- r = fly(dom).getFxRestore();
- b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
- b.right = b.x + b.width;
- b.bottom = b.y + b.height;
-
- // fixed size for slide
- fly(dom).setWidth(b.width).setHeight(b.height);
-
- // wrap if needed
- wrap = fly(dom).fxWrap(r.pos, o, HIDDEN);
-
- st.visibility = VISIBLE;
- st.position = ABSOLUTE;
-
- // clear out temp styles after slide and unwrap
- function after(){
- fly(dom).fxUnwrap(wrap, r.pos, o);
- st.width = r.width;
- st.height = r.height;
- fly(dom).afterFx(o);
- }
-
- // time to calculate the positions
- pt = {to: [b.x, b.y]};
- bw = {to: b.width};
- bh = {to: b.height};
-
- function argCalc(wrap, style, ww, wh, sXY, sXYval, s1, s2, w, h, p){
- var ret = {};
- fly(wrap).setWidth(ww).setHeight(wh);
- if(fly(wrap)[sXY]){
- fly(wrap)[sXY](sXYval);
- }
- style[s1] = style[s2] = "0";
- if(w){
- ret.width = w;
- }
- if(h){
- ret.height = h;
- }
- if(p){
- ret.points = p;
- }
- return ret;
+ /**
+ * @method constructor
+ * Creates new class.
+ * @param {Object} classData An object represent the properties of this class
+ * @param {Function} createdFn Optional, the callback function to be executed when this class is fully created.
+ * Note that the creation process can be asynchronous depending on the pre-processors used.
+ * @return {Ext.Base} The newly created class
+ */
+ Ext.Class = Class = function(newClass, classData, onClassCreated) {
+ if (typeof newClass !== 'function') {
+ onClassCreated = classData;
+ classData = newClass;
+ newClass = function() {
+ return this.constructor.apply(this, arguments);
};
+ }
- args = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
- t : [wrap, st, b.width, 0, NULL, NULL, LEFT, BOTTOM, NULL, bh, NULL],
- l : [wrap, st, 0, b.height, NULL, NULL, RIGHT, TOP, bw, NULL, NULL],
- r : [wrap, st, b.width, b.height, SETX, b.right, LEFT, TOP, NULL, NULL, pt],
- b : [wrap, st, b.width, b.height, SETY, b.bottom, LEFT, TOP, NULL, bh, pt],
- tl : [wrap, st, 0, 0, NULL, NULL, RIGHT, BOTTOM, bw, bh, pt],
- bl : [wrap, st, 0, 0, SETY, b.y + b.height, RIGHT, TOP, bw, bh, pt],
- br : [wrap, st, 0, 0, SETXY, [b.right, b.bottom], LEFT, TOP, bw, bh, pt],
- tr : [wrap, st, 0, 0, SETX, b.x + b.width, LEFT, BOTTOM, bw, bh, pt]
- });
-
- st.visibility = VISIBLE;
- fly(wrap).show();
-
- arguments.callee.anim = fly(wrap).fxanim(args,
- o,
- MOTION,
- .5,
- EASEOUT,
- after);
- });
- return me;
- },
-
- /**
- * Slides the element out of view. An anchor point can be optionally passed to set the end point
- * for the slide effect. When the effect is completed, the element will be hidden (visibility =
- * 'hidden') but block elements will still take up space in the document. The element must be removed
- * from the DOM using the 'remove' config option if desired. This function automatically handles
- * wrapping the element with a fixed-size container if needed. See the Fx class overview for valid anchor point options.
- * Usage:
- *
-// default: slide the element out to the top
-el.slideOut();
+ if (!classData) {
+ classData = {};
+ }
-// custom: slide the element out to the right with a 2-second duration
-el.slideOut('r', { duration: 2 });
+ var preprocessorStack = classData.preprocessors || Class.getDefaultPreprocessors(),
+ registeredPreprocessors = Class.getPreprocessors(),
+ index = 0,
+ preprocessors = [],
+ preprocessor, preprocessors, staticPropertyName, process, i, j, ln;
-// common config options shown with default values
-el.slideOut('t', {
- easing: 'easeOut',
- duration: .5,
- remove: false,
- useDisplay: false
-});
-
- * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to top: 't')
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- slideOut : function(anchor, o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- st = dom.style,
- xy = me.getXY(),
- wrap,
- r,
- b,
- a,
- zero = {to: 0};
-
- anchor = anchor || "t";
+ for (i = 0, ln = baseStaticProperties.length; i < ln; i++) {
+ staticPropertyName = baseStaticProperties[i];
+ newClass[staticPropertyName] = Base[staticPropertyName];
+ }
- me.queueFx(o, function(){
-
- // restore values after effect
- r = fly(dom).getFxRestore();
- b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight};
- b.right = b.x + b.width;
- b.bottom = b.y + b.height;
-
- // fixed size for slide
- fly(dom).setWidth(b.width).setHeight(b.height);
+ delete classData.preprocessors;
- // wrap if needed
- wrap = fly(dom).fxWrap(r.pos, o, VISIBLE);
-
- st.visibility = VISIBLE;
- st.position = ABSOLUTE;
- fly(wrap).setWidth(b.width).setHeight(b.height);
-
- function after(){
- o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();
- fly(dom).fxUnwrap(wrap, r.pos, o);
- st.width = r.width;
- st.height = r.height;
- fly(dom).afterFx(o);
- }
-
- function argCalc(style, s1, s2, p1, v1, p2, v2, p3, v3){
- var ret = {};
-
- style[s1] = style[s2] = "0";
- ret[p1] = v1;
- if(p2){
- ret[p2] = v2;
+ for (j = 0, ln = preprocessorStack.length; j < ln; j++) {
+ preprocessor = preprocessorStack[j];
+
+ if (typeof preprocessor === 'string') {
+ preprocessor = registeredPreprocessors[preprocessor];
+
+ if (!preprocessor.always) {
+ if (classData.hasOwnProperty(preprocessor.name)) {
+ preprocessors.push(preprocessor.fn);
+ }
}
- if(p3){
- ret[p3] = v3;
+ else {
+ preprocessors.push(preprocessor.fn);
}
-
- return ret;
- };
-
- a = fly(dom).switchStatements(anchor.toLowerCase(), argCalc, {
- t : [st, LEFT, BOTTOM, HEIGHT, zero],
- l : [st, RIGHT, TOP, WIDTH, zero],
- r : [st, LEFT, TOP, WIDTH, zero, POINTS, {to : [b.right, b.y]}],
- b : [st, LEFT, TOP, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
- tl : [st, RIGHT, BOTTOM, WIDTH, zero, HEIGHT, zero],
- bl : [st, RIGHT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x, b.bottom]}],
- br : [st, LEFT, TOP, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.x + b.width, b.bottom]}],
- tr : [st, LEFT, BOTTOM, WIDTH, zero, HEIGHT, zero, POINTS, {to : [b.right, b.y]}]
- });
-
- arguments.callee.anim = fly(wrap).fxanim(a,
- o,
- MOTION,
- .5,
- EASEOUT,
- after);
- });
- return me;
- },
+ }
+ else {
+ preprocessors.push(preprocessor);
+ }
+ }
- /**
- * Fades the element out while slowly expanding it in all directions. When the effect is completed, the
- * element will be hidden (visibility = 'hidden') but block elements will still take up space in the document.
- * The element must be removed from the DOM using the 'remove' config option if desired.
- * Usage:
- *
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- puff : function(o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- st = dom.style,
- width,
- height,
- r;
+ classData.onBeforeClassCreated = function(cls, data) {
+ onClassCreated = data.onClassCreated;
- me.queueFx(o, function(){
- width = fly(dom).getWidth();
- height = fly(dom).getHeight();
- fly(dom).clearOpacity();
- fly(dom).show();
+ delete data.onBeforeClassCreated;
+ delete data.onClassCreated;
- // restore values after effect
- r = fly(dom).getFxRestore();
-
- function after(){
- o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();
- fly(dom).clearOpacity();
- fly(dom).setPositioning(r.pos);
- st.width = r.width;
- st.height = r.height;
- st.fontSize = '';
- fly(dom).afterFx(o);
- }
-
- arguments.callee.anim = fly(dom).fxanim({
- width : {to : fly(dom).adjustWidth(width * 2)},
- height : {to : fly(dom).adjustHeight(height * 2)},
- points : {by : [-width * .5, -height * .5]},
- opacity : {to : 0},
- fontSize: {to : 200, unit: "%"}
- },
- o,
- MOTION,
- .5,
- EASEOUT,
- after);
- });
- return me;
- },
+ cls.implement(data);
- /**
- * Blinks the element as if it was clicked and then collapses on its center (similar to switching off a television).
- * When the effect is completed, the element will be hidden (visibility = 'hidden') but block elements will still
- * take up space in the document. The element must be removed from the DOM using the 'remove' config option if desired.
- * Usage:
- *
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- switchOff : function(o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- st = dom.style,
- r;
+ process = function(cls, data) {
+ preprocessor = preprocessors[index++];
- me.queueFx(o, function(){
- fly(dom).clearOpacity();
- fly(dom).clip();
+ if (!preprocessor) {
+ data.onBeforeClassCreated.apply(this, arguments);
+ return;
+ }
- // restore values after effect
- r = fly(dom).getFxRestore();
-
- function after(){
- o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();
- fly(dom).clearOpacity();
- fly(dom).setPositioning(r.pos);
- st.width = r.width;
- st.height = r.height;
- fly(dom).afterFx(o);
+ if (preprocessor.call(this, cls, data, process) !== false) {
+ process.apply(this, arguments);
+ }
+ };
+
+ process.call(Class, newClass, classData);
+
+ return newClass;
+ };
+
+ Ext.apply(Class, {
+
+ /** @private */
+ preprocessors: {},
+
+ /**
+ * Register a new pre-processor to be used during the class creation process
+ *
+ * @member Ext.Class registerPreprocessor
+ * @param {String} name The pre-processor's name
+ * @param {Function} fn The callback function to be executed. Typical format:
+
+ function(cls, data, fn) {
+ // Your code here
+
+ // Execute this when the processing is finished.
+ // Asynchronous processing is perfectly ok
+ if (fn) {
+ fn.call(this, cls, data);
+ }
+ });
+
+ * Passed arguments for this function are:
+ *
+ * - `{Function} cls`: The created class
+ * - `{Object} data`: The set of properties passed in {@link Ext.Class} constructor
+ * - `{Function} fn`: The callback function that must to be executed when this pre-processor finishes,
+ * regardless of whether the processing is synchronous or aynchronous
+ *
+ * @return {Ext.Class} this
+ * @markdown
+ */
+ registerPreprocessor: function(name, fn, always) {
+ this.preprocessors[name] = {
+ name: name,
+ always: always || false,
+ fn: fn
};
- fly(dom).fxanim({opacity : {to : 0.3}},
- NULL,
- NULL,
- .1,
- NULL,
- function(){
- fly(dom).clearOpacity();
- (function(){
- fly(dom).fxanim({
- height : {to : 1},
- points : {by : [0, fly(dom).getHeight() * .5]}
- },
- o,
- MOTION,
- 0.3,
- 'easeIn',
- after);
- }).defer(100);
- });
- });
- return me;
- },
+ return this;
+ },
- /**
- * Highlights the Element by setting a color (applies to the background-color by default, but can be
- * changed using the "attr" config option) and then fading back to the original color. If no original
- * color is available, you should provide the "endColor" config option which will be cleared after the animation.
- * Usage:
-
-// default: highlight background to yellow
-el.highlight();
+ /**
+ * Retrieve a pre-processor callback function by its name, which has been registered before
+ *
+ * @param {String} name
+ * @return {Function} preprocessor
+ */
+ getPreprocessor: function(name) {
+ return this.preprocessors[name];
+ },
-// custom: highlight foreground text to blue for 2 seconds
-el.highlight("0000ff", { attr: 'color', duration: 2 });
+ getPreprocessors: function() {
+ return this.preprocessors;
+ },
-// common config options shown with default values
-el.highlight("ffff9c", {
- attr: "background-color", //can be any valid CSS property (attribute) that supports a color value
- endColor: (current color) or "ffffff",
- easing: 'easeIn',
- duration: 1
-});
-
- * @param {String} color (optional) The highlight color. Should be a 6 char hex color without the leading # (defaults to yellow: 'ffff9c')
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- highlight : function(color, o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- attr = o.attr || "backgroundColor",
- a = {},
- restore;
+ /**
+ * Retrieve the array stack of default pre-processors
+ *
+ * @return {Function} defaultPreprocessors
+ */
+ getDefaultPreprocessors: function() {
+ return this.defaultPreprocessors || [];
+ },
- me.queueFx(o, function(){
- fly(dom).clearOpacity();
- fly(dom).show();
+ /**
+ * Set the default array stack of default pre-processors
+ *
+ * @param {Array} preprocessors
+ * @return {Ext.Class} this
+ */
+ setDefaultPreprocessors: function(preprocessors) {
+ this.defaultPreprocessors = Ext.Array.from(preprocessors);
- function after(){
- dom.style[attr] = restore;
- fly(dom).afterFx(o);
- }
- restore = dom.style[attr];
- a[attr] = {from: color || "ffff9c", to: o.endColor || fly(dom).getColor(attr) || "ffffff"};
- arguments.callee.anim = fly(dom).fxanim(a,
- o,
- 'color',
- 1,
- 'easeIn',
- after);
- });
- return me;
- },
+ return this;
+ },
- /**
- * Shows a ripple of exploding, attenuating borders to draw attention to an Element.
- * Usage:
-
-// default: a single light blue ripple
-el.frame();
+ /**
+ * Insert this pre-processor at a specific position in the stack, optionally relative to
+ * any existing pre-processor. For example:
-// custom: 3 red ripples lasting 3 seconds total
-el.frame("ff0000", 3, { duration: 3 });
+ Ext.Class.registerPreprocessor('debug', function(cls, data, fn) {
+ // Your code here
-// common config options shown with default values
-el.frame("C3DAF9", 1, {
- duration: 1 //duration of each individual ripple.
- // Note: Easing is not configurable and will be ignored if included
-});
-
- * @param {String} color (optional) The color of the border. Should be a 6 char hex color without the leading # (defaults to light blue: 'C3DAF9').
- * @param {Number} count (optional) The number of ripples to display (defaults to 1)
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- frame : function(color, count, o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- proxy,
- active;
+ if (fn) {
+ fn.call(this, cls, data);
+ }
+ }).insertDefaultPreprocessor('debug', 'last');
- me.queueFx(o, function(){
- color = color || '#C3DAF9';
- if(color.length == 6){
- color = '#' + color;
- }
- count = count || 1;
- fly(dom).show();
-
- var xy = fly(dom).getXY(),
- b = {x: xy[0], y: xy[1], 0: xy[0], 1: xy[1], width: dom.offsetWidth, height: dom.offsetHeight},
- queue = function(){
- proxy = fly(document.body || document.documentElement).createChild({
- style:{
- position : ABSOLUTE,
- 'z-index': 35000, // yee haw
- border : '0px solid ' + color
- }
- });
- return proxy.queueFx({}, animFn);
- };
-
-
- arguments.callee.anim = {
- isAnimated: true,
- stop: function() {
- count = 0;
- proxy.stopFx();
- }
- };
-
- function animFn(){
- var scale = Ext.isBorderBox ? 2 : 1;
- active = proxy.anim({
- top : {from : b.y, to : b.y - 20},
- left : {from : b.x, to : b.x - 20},
- borderWidth : {from : 0, to : 10},
- opacity : {from : 1, to : 0},
- height : {from : b.height, to : b.height + 20 * scale},
- width : {from : b.width, to : b.width + 20 * scale}
- },{
- duration: o.duration || 1,
- callback: function() {
- proxy.remove();
- --count > 0 ? queue() : fly(dom).afterFx(o);
- }
- });
- arguments.callee.anim = {
- isAnimated: true,
- stop: function(){
- active.stop();
- }
- };
- };
- queue();
- });
- return me;
- },
+ * @param {String} name The pre-processor name. Note that it needs to be registered with
+ * {@link Ext#registerPreprocessor registerPreprocessor} before this
+ * @param {String} offset The insertion position. Four possible values are:
+ * 'first', 'last', or: 'before', 'after' (relative to the name provided in the third argument)
+ * @param {String} relativeName
+ * @return {Ext.Class} this
+ * @markdown
+ */
+ setDefaultPreprocessorPosition: function(name, offset, relativeName) {
+ var defaultPreprocessors = this.defaultPreprocessors,
+ index;
- /**
- * Creates a pause before any subsequent queued effects begin. If there are
- * no effects queued after the pause it will have no effect.
- * Usage:
-
-el.pause(1);
-
- * @param {Number} seconds The length of time to pause (in seconds)
- * @return {Ext.Element} The Element
- */
- pause : function(seconds){
- var dom = this.dom,
- t;
+ if (typeof offset === 'string') {
+ if (offset === 'first') {
+ defaultPreprocessors.unshift(name);
- this.queueFx({}, function(){
- t = setTimeout(function(){
- fly(dom).afterFx({});
- }, seconds * 1000);
- arguments.callee.anim = {
- isAnimated: true,
- stop: function(){
- clearTimeout(t);
- fly(dom).afterFx({});
+ return this;
}
- };
- });
- return this;
- },
+ else if (offset === 'last') {
+ defaultPreprocessors.push(name);
- /**
- * Fade an element in (from transparent to opaque). The ending opacity can be specified
- * using the {@link #endOpacity} config option.
- * Usage:
-
-// default: fade in from opacity 0 to 100%
-el.fadeIn();
+ return this;
+ }
-// custom: fade in from opacity 0 to 75% over 2 seconds
-el.fadeIn({ endOpacity: .75, duration: 2});
+ offset = (offset === 'after') ? 1 : -1;
+ }
-// common config options shown with default values
-el.fadeIn({
- endOpacity: 1, //can be any value between 0 and 1 (e.g. .5)
- easing: 'easeOut',
- duration: .5
-});
-
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- fadeIn : function(o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- to = o.endOpacity || 1;
-
- me.queueFx(o, function(){
- fly(dom).setOpacity(0);
- fly(dom).fixDisplay();
- dom.style.visibility = VISIBLE;
- arguments.callee.anim = fly(dom).fxanim({opacity:{to:to}},
- o, NULL, .5, EASEOUT, function(){
- if(to == 1){
- fly(dom).clearOpacity();
- }
- fly(dom).afterFx(o);
- });
- });
- return me;
- },
-
- /**
- * Fade an element out (from opaque to transparent). The ending opacity can be specified
- * using the {@link #endOpacity} config option. Note that IE may require
- * {@link #useDisplay}:true in order to redisplay correctly.
- * Usage:
-
-// default: fade out from the element's current opacity to 0
-el.fadeOut();
+ index = Ext.Array.indexOf(defaultPreprocessors, relativeName);
-// custom: fade out from the element's current opacity to 25% over 2 seconds
-el.fadeOut({ endOpacity: .25, duration: 2});
+ if (index !== -1) {
+ Ext.Array.splice(defaultPreprocessors, Math.max(0, index + offset), 0, name);
+ }
-// common config options shown with default values
-el.fadeOut({
- endOpacity: 0, //can be any value between 0 and 1 (e.g. .5)
- easing: 'easeOut',
- duration: .5,
- remove: false,
- useDisplay: false
-});
-
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- fadeOut : function(o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- style = dom.style,
- to = o.endOpacity || 0;
-
- me.queueFx(o, function(){
- arguments.callee.anim = fly(dom).fxanim({
- opacity : {to : to}},
- o,
- NULL,
- .5,
- EASEOUT,
- function(){
- if(to == 0){
- Ext.Element.data(dom, 'visibilityMode') == Ext.Element.DISPLAY || o.useDisplay ?
- style.display = "none" :
- style.visibility = HIDDEN;
-
- fly(dom).clearOpacity();
- }
- fly(dom).afterFx(o);
- });
- });
- return me;
- },
+ return this;
+ }
+ });
- /**
- * Animates the transition of an element's dimensions from a starting height/width
- * to an ending height/width. This method is a convenience implementation of {@link shift}.
- * Usage:
-
-// change height and width to 100x100 pixels
-el.scale(100, 100);
+ /**
+ * @cfg {String} extend
+ * The parent class that this class extends. For example:
+ *
+ * Ext.define('Person', {
+ * say: function(text) { alert(text); }
+ * });
+ *
+ * Ext.define('Developer', {
+ * extend: 'Person',
+ * say: function(text) { this.callParent(["print "+text]); }
+ * });
+ */
+ Class.registerPreprocessor('extend', function(cls, data) {
+ var extend = data.extend,
+ base = Ext.Base,
+ basePrototype = base.prototype,
+ prototype = function() {},
+ parent, i, k, ln, staticName, parentStatics,
+ parentPrototype, clsPrototype;
+
+ if (extend && extend !== Object) {
+ parent = extend;
+ }
+ else {
+ parent = base;
+ }
-// common config options shown with default values. The height and width will default to
-// the element's existing values if passed as null.
-el.scale(
- [element's width],
- [element's height], {
- easing: 'easeOut',
- duration: .35
- }
-);
-
- * @param {Number} width The new width (pass undefined to keep the original width)
- * @param {Number} height The new height (pass undefined to keep the original height)
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- scale : function(w, h, o){
- this.shift(Ext.apply({}, o, {
- width: w,
- height: h
- }));
- return this;
- },
+ parentPrototype = parent.prototype;
- /**
- * Animates the transition of any combination of an element's dimensions, xy position and/or opacity.
- * Any of these properties not specified in the config object will not be changed. This effect
- * requires that at least one new dimension, position or opacity setting must be passed in on
- * the config object in order for the function to have any effect.
- * Usage:
-
-// slide the element horizontally to x position 200 while changing the height and opacity
-el.shift({ x: 200, height: 50, opacity: .8 });
+ prototype.prototype = parentPrototype;
+ clsPrototype = cls.prototype = new prototype();
-// common config options shown with default values.
-el.shift({
- width: [element's width],
- height: [element's height],
- x: [element's x position],
- y: [element's y position],
- opacity: [element's opacity],
- easing: 'easeOut',
- duration: .35
-});
-
- * @param {Object} options Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- shift : function(o){
- o = getObject(o);
- var dom = this.dom,
- a = {};
-
- this.queueFx(o, function(){
- for (var prop in o) {
- if (o[prop] != UNDEFINED) {
- a[prop] = {to : o[prop]};
+ if (!('$class' in parent)) {
+ for (i in basePrototype) {
+ if (!parentPrototype[i]) {
+ parentPrototype[i] = basePrototype[i];
}
- }
-
- a.width ? a.width.to = fly(dom).adjustWidth(o.width) : a;
- a.height ? a.height.to = fly(dom).adjustWidth(o.height) : a;
-
- if (a.x || a.y || a.xy) {
- a.points = a.xy ||
- {to : [ a.x ? a.x.to : fly(dom).getX(),
- a.y ? a.y.to : fly(dom).getY()]};
}
+ }
- arguments.callee.anim = fly(dom).fxanim(a,
- o,
- MOTION,
- .35,
- EASEOUT,
- function(){
- fly(dom).afterFx(o);
- });
- });
- return this;
- },
+ clsPrototype.self = cls;
- /**
- * Slides the element while fading it out of view. An anchor point can be optionally passed to set the
- * ending point of the effect.
- * Usage:
- *
-// default: slide the element downward while fading out
-el.ghost();
+ cls.superclass = clsPrototype.superclass = parentPrototype;
-// custom: slide the element out to the right with a 2-second duration
-el.ghost('r', { duration: 2 });
+ delete data.extend;
-// common config options shown with default values
-el.ghost('b', {
- easing: 'easeOut',
- duration: .5,
- remove: false,
- useDisplay: false
-});
-
- * @param {String} anchor (optional) One of the valid Fx anchor positions (defaults to bottom: 'b')
- * @param {Object} options (optional) Object literal with any of the Fx config options
- * @return {Ext.Element} The Element
- */
- ghost : function(anchor, o){
- o = getObject(o);
- var me = this,
- dom = me.dom,
- st = dom.style,
- a = {opacity: {to: 0}, points: {}},
- pt = a.points,
- r,
- w,
- h;
-
- anchor = anchor || "b";
+ // Statics inheritance
+ parentStatics = parentPrototype.$inheritableStatics;
- me.queueFx(o, function(){
- // restore values after effect
- r = fly(dom).getFxRestore();
- w = fly(dom).getWidth();
- h = fly(dom).getHeight();
-
- function after(){
- o.useDisplay ? fly(dom).setDisplayed(FALSE) : fly(dom).hide();
- fly(dom).clearOpacity();
- fly(dom).setPositioning(r.pos);
- st.width = r.width;
- st.height = r.height;
- fly(dom).afterFx(o);
+ if (parentStatics) {
+ for (k = 0, ln = parentStatics.length; k < ln; k++) {
+ staticName = parentStatics[k];
+
+ if (!cls.hasOwnProperty(staticName)) {
+ cls[staticName] = parent[staticName];
+ }
}
-
- pt.by = fly(dom).switchStatements(anchor.toLowerCase(), function(v1,v2){ return [v1, v2];}, {
- t : [0, -h],
- l : [-w, 0],
- r : [w, 0],
- b : [0, h],
- tl : [-w, -h],
- bl : [-w, h],
- br : [w, h],
- tr : [w, -h]
- });
-
- arguments.callee.anim = fly(dom).fxanim(a,
- o,
- MOTION,
- .5,
- EASEOUT, after);
- });
- return me;
- },
+ }
- /**
- * Ensures that all effects queued after syncFx is called on the element are
- * run concurrently. This is the opposite of {@link #sequenceFx}.
- * @return {Ext.Element} The Element
- */
- syncFx : function(){
- var me = this;
- me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
- block : FALSE,
- concurrent : TRUE,
- stopFx : FALSE
- });
- return me;
- },
+ // Merge the parent class' config object without referencing it
+ if (parentPrototype.config) {
+ clsPrototype.config = Ext.Object.merge({}, parentPrototype.config);
+ }
+ else {
+ clsPrototype.config = {};
+ }
- /**
- * Ensures that all effects queued after sequenceFx is called on the element are
- * run in sequence. This is the opposite of {@link #syncFx}.
- * @return {Ext.Element} The Element
- */
- sequenceFx : function(){
- var me = this;
- me.fxDefaults = Ext.apply(me.fxDefaults || {}, {
- block : FALSE,
- concurrent : FALSE,
- stopFx : FALSE
- });
- return me;
- },
+ if (clsPrototype.$onExtended) {
+ clsPrototype.$onExtended.call(cls, cls, data);
+ }
- /* @private */
- nextFx : function(){
- var ef = getQueue(this.dom.id)[0];
- if(ef){
- ef.call(this);
+ if (data.onClassExtended) {
+ clsPrototype.$onExtended = data.onClassExtended;
+ delete data.onClassExtended;
}
- },
- /**
- * Returns true if the element has any effects actively running or queued, else returns false.
- * @return {Boolean} True if element has active effects, else false
- */
- hasActiveFx : function(){
- return getQueue(this.dom.id)[0];
- },
+ }, true);
/**
- * Stops any running effects and clears the element's internal effects queue if it contains
- * any additional effects that haven't started yet.
- * @return {Ext.Element} The Element
+ * @cfg {Object} statics
+ * List of static methods for this class. For example:
+ *
+ * Ext.define('Computer', {
+ * statics: {
+ * factory: function(brand) {
+ * // 'this' in static methods refer to the class itself
+ * return new this(brand);
+ * }
+ * },
+ *
+ * constructor: function() { ... }
+ * });
+ *
+ * var dellComputer = Computer.factory('Dell');
*/
- stopFx : function(finish){
- var me = this,
- id = me.dom.id;
- if(me.hasActiveFx()){
- var cur = getQueue(id)[0];
- if(cur && cur.anim){
- if(cur.anim.isAnimated){
- setQueue(id, [cur]); //clear
- cur.anim.stop(finish !== undefined ? finish : TRUE);
- }else{
- setQueue(id, []);
- }
+ Class.registerPreprocessor('statics', function(cls, data) {
+ var statics = data.statics,
+ name;
+
+ for (name in statics) {
+ if (statics.hasOwnProperty(name)) {
+ cls[name] = statics[name];
}
}
- return me;
- },
- /* @private */
- beforeFx : function(o){
- if(this.hasActiveFx() && !o.concurrent){
- if(o.stopFx){
- this.stopFx();
- return TRUE;
- }
- return FALSE;
- }
- return TRUE;
- },
+ delete data.statics;
+ });
/**
- * Returns true if the element is currently blocking so that no other effect can be queued
- * until this effect is finished, else returns false if blocking is not set. This is commonly
- * used to ensure that an effect initiated by a user action runs to completion prior to the
- * same effect being restarted (e.g., firing only one effect even if the user clicks several times).
- * @return {Boolean} True if blocking, else false
+ * @cfg {Object} inheritableStatics
+ * List of inheritable static methods for this class.
+ * Otherwise just like {@link #statics} but subclasses inherit these methods.
*/
- hasFxBlock : function(){
- var q = getQueue(this.dom.id);
- return q && q[0] && q[0].block;
- },
+ Class.registerPreprocessor('inheritableStatics', function(cls, data) {
+ var statics = data.inheritableStatics,
+ inheritableStatics,
+ prototype = cls.prototype,
+ name;
- /* @private */
- queueFx : function(o, fn){
- var me = fly(this.dom);
- if(!me.hasFxBlock()){
- Ext.applyIf(o, me.fxDefaults);
- if(!o.concurrent){
- var run = me.beforeFx(o);
- fn.block = o.block;
- getQueue(me.dom.id).push(fn);
- if(run){
- me.nextFx();
- }
- }else{
- fn.call(me);
+ inheritableStatics = prototype.$inheritableStatics;
+
+ if (!inheritableStatics) {
+ inheritableStatics = prototype.$inheritableStatics = [];
+ }
+
+ for (name in statics) {
+ if (statics.hasOwnProperty(name)) {
+ cls[name] = statics[name];
+ inheritableStatics.push(name);
}
}
- return me;
- },
- /* @private */
- fxWrap : function(pos, o, vis){
- var dom = this.dom,
- wrap,
- wrapXY;
- if(!o.wrap || !(wrap = Ext.getDom(o.wrap))){
- if(o.fixPosition){
- wrapXY = fly(dom).getXY();
+ delete data.inheritableStatics;
+ });
+
+ /**
+ * @cfg {Object} mixins
+ * List of classes to mix into this class. For example:
+ *
+ * Ext.define('CanSing', {
+ * sing: function() {
+ * alert("I'm on the highway to hell...")
+ * }
+ * });
+ *
+ * Ext.define('Musician', {
+ * extend: 'Person',
+ *
+ * mixins: {
+ * canSing: 'CanSing'
+ * }
+ * })
+ */
+ Class.registerPreprocessor('mixins', function(cls, data) {
+ cls.mixin(data.mixins);
+
+ delete data.mixins;
+ });
+
+ /**
+ * @cfg {Object} config
+ * List of configuration options with their default values, for which automatically
+ * accessor methods are generated. For example:
+ *
+ * Ext.define('SmartPhone', {
+ * config: {
+ * hasTouchScreen: false,
+ * operatingSystem: 'Other',
+ * price: 500
+ * },
+ * constructor: function(cfg) {
+ * this.initConfig(cfg);
+ * }
+ * });
+ *
+ * var iPhone = new SmartPhone({
+ * hasTouchScreen: true,
+ * operatingSystem: 'iOS'
+ * });
+ *
+ * iPhone.getPrice(); // 500;
+ * iPhone.getOperatingSystem(); // 'iOS'
+ * iPhone.getHasTouchScreen(); // true;
+ * iPhone.hasTouchScreen(); // true
+ */
+ Class.registerPreprocessor('config', function(cls, data) {
+ var prototype = cls.prototype;
+
+ Ext.Object.each(data.config, function(name) {
+ var cName = name.charAt(0).toUpperCase() + name.substr(1),
+ pName = name,
+ apply = 'apply' + cName,
+ setter = 'set' + cName,
+ getter = 'get' + cName;
+
+ if (!(apply in prototype) && !data.hasOwnProperty(apply)) {
+ data[apply] = function(val) {
+ return val;
+ };
}
- var div = document.createElement("div");
- div.style.visibility = vis;
- wrap = dom.parentNode.insertBefore(div, dom);
- fly(wrap).setPositioning(pos);
- if(fly(wrap).isStyle(POSITION, "static")){
- fly(wrap).position("relative");
+
+ if (!(setter in prototype) && !data.hasOwnProperty(setter)) {
+ data[setter] = function(val) {
+ var ret = this[apply].call(this, val, this[pName]);
+
+ if (ret !== undefined) {
+ this[pName] = ret;
+ }
+
+ return this;
+ };
}
- fly(dom).clearPositioning('auto');
- fly(wrap).clip();
- wrap.appendChild(dom);
- if(wrapXY){
- fly(wrap).setXY(wrapXY);
+
+ if (!(getter in prototype) && !data.hasOwnProperty(getter)) {
+ data[getter] = function() {
+ return this[pName];
+ };
}
- }
- return wrap;
- },
+ });
- /* @private */
- fxUnwrap : function(wrap, pos, o){
- var dom = this.dom;
- fly(dom).clearPositioning();
- fly(dom).setPositioning(pos);
- if(!o.wrap){
- var pn = fly(wrap).dom.parentNode;
- pn.insertBefore(dom, wrap);
- fly(wrap).remove();
- }
- },
+ Ext.Object.merge(prototype.config, data.config);
+ delete data.config;
+ });
- /* @private */
- getFxRestore : function(){
- var st = this.dom.style;
- return {pos: this.getPositioning(), width: st.width, height : st.height};
- },
+ Class.setDefaultPreprocessors(['extend', 'statics', 'inheritableStatics', 'mixins', 'config']);
- /* @private */
- afterFx : function(o){
- var dom = this.dom,
- id = dom.id;
- if(o.afterStyle){
- fly(dom).setStyle(o.afterStyle);
+ // Backwards compatible
+ Ext.extend = function(subclass, superclass, members) {
+ if (arguments.length === 2 && Ext.isObject(superclass)) {
+ members = superclass;
+ superclass = subclass;
+ subclass = null;
}
- if(o.afterCls){
- fly(dom).addClass(o.afterCls);
- }
- if(o.remove == TRUE){
- fly(dom).remove();
+
+ var cls;
+
+ if (!superclass) {
+ Ext.Error.raise("Attempting to extend from a class which has not been loaded on the page.");
}
- if(o.callback){
- o.callback.call(o.scope, fly(dom));
+
+ members.extend = superclass;
+ members.preprocessors = ['extend', 'mixins', 'config', 'statics'];
+
+ if (subclass) {
+ cls = new Class(subclass, members);
}
- if(!o.concurrent){
- getQueue(id).shift();
- fly(dom).nextFx();
+ else {
+ cls = new Class(members);
}
- },
- /* @private */
- fxanim : function(args, opt, animType, defaultDur, defaultEase, cb){
- animType = animType || 'run';
- opt = opt || {};
- var anim = Ext.lib.Anim[animType](
- this.dom,
- args,
- (opt.duration || defaultDur) || .35,
- (opt.easing || defaultEase) || EASEOUT,
- cb,
- this
- );
- opt.anim = anim;
- return anim;
- }
-};
+ cls.prototype.override = function(o) {
+ for (var m in o) {
+ if (o.hasOwnProperty(m)) {
+ this[m] = o[m];
+ }
+ }
+ };
-// backwards compat
-Ext.Fx.resize = Ext.Fx.scale;
+ return cls;
+ };
-//When included, Ext.Fx is automatically applied to Element so that all basic
-//effects are available directly via the Element API
-Ext.Element.addMethods(Ext.Fx);
})();
-/**
- * @class Ext.CompositeElementLite
- *
This class encapsulates a collection of DOM elements, providing methods to filter
- * members, or to perform collective actions upon the whole set.
- *
Although they are not listed, this class supports all of the methods of {@link Ext.Element} and
- * {@link Ext.Fx}. The methods from these classes will be performed on all the elements in this collection.
- * Example:
-var els = Ext.select("#some-el div.some-class");
-// or select directly from an existing element
-var el = Ext.get('some-el');
-el.select('div.some-class');
-els.setWidth(100); // all elements become 100 width
-els.hide(true); // all elements fade out and hide
-// or
-els.setWidth(100).hide(true);
-
+/**
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ * @class Ext.ClassManager
+ *
+ * Ext.ClassManager manages all classes and handles mapping from string class name to
+ * actual class objects throughout the whole framework. It is not generally accessed directly, rather through
+ * these convenient shorthands:
+ *
+ * - {@link Ext#define Ext.define}
+ * - {@link Ext#create Ext.create}
+ * - {@link Ext#widget Ext.widget}
+ * - {@link Ext#getClass Ext.getClass}
+ * - {@link Ext#getClassName Ext.getClassName}
+ *
+ * @singleton
*/
-Ext.CompositeElementLite = function(els, root){
- /**
- *
The Array of DOM elements which this CompositeElement encapsulates. Read-only.
- *
This will not usually be accessed in developers' code, but developers wishing
- * to augment the capabilities of the CompositeElementLite class may use it when adding
- * methods to the class.
- *
For example to add the nextAll method to the class to add all
- * following siblings of selected elements, the code would be
-Ext.override(Ext.CompositeElementLite, {
- nextAll: function() {
- var els = this.elements, i, l = els.length, n, r = [], ri = -1;
+(function(Class, alias) {
-// Loop through all elements in this Composite, accumulating
-// an Array of all siblings.
- for (i = 0; i < l; i++) {
- for (n = els[i].nextSibling; n; n = n.nextSibling) {
- r[++ri] = n;
- }
- }
+ var slice = Array.prototype.slice;
-// Add all found siblings to this Composite
- return this.add(r);
- }
-});
- * @type Array
- * @property elements
- */
- this.elements = [];
- this.add(els, root);
- this.el = new Ext.Element.Flyweight();
-};
+ var Manager = Ext.ClassManager = {
-Ext.CompositeElementLite.prototype = {
- isComposite: true,
+ /**
+ * @property {Object} classes
+ * All classes which were defined through the ClassManager. Keys are the
+ * name of the classes and the values are references to the classes.
+ * @private
+ */
+ classes: {},
- // private
- getElement : function(el){
- // Set the shared flyweight dom property to the current element
- var e = this.el;
- e.dom = el;
- e.id = el.id;
- return e;
- },
+ /**
+ * @private
+ */
+ existCache: {},
- // private
- transformElement : function(el){
- return Ext.getDom(el);
- },
+ /**
+ * @private
+ */
+ namespaceRewrites: [{
+ from: 'Ext.',
+ to: Ext
+ }],
- /**
- * Returns the number of elements in this Composite.
- * @return Number
- */
- getCount : function(){
- return this.elements.length;
- },
- /**
- * Adds elements to this Composite object.
- * @param {Mixed} els Either an Array of DOM elements to add, or another Composite object who's elements should be added.
- * @return {CompositeElement} This Composite object.
- */
- add : function(els, root){
- var me = this,
- elements = me.elements;
- if(!els){
- return this;
- }
- if(typeof els == "string"){
- els = Ext.Element.selectorFunction(els, root);
- }else if(els.isComposite){
- els = els.elements;
- }else if(!Ext.isIterable(els)){
- els = [els];
- }
+ /**
+ * @private
+ */
+ maps: {
+ alternateToName: {},
+ aliasToName: {},
+ nameToAliases: {}
+ },
- for(var i = 0, len = els.length; i < len; ++i){
- elements.push(me.transformElement(els[i]));
- }
- return me;
- },
+ /** @private */
+ enableNamespaceParseCache: true,
- invoke : function(fn, args){
- var me = this,
- els = me.elements,
- len = els.length,
- e,
- i;
+ /** @private */
+ namespaceParseCache: {},
- for(i = 0; i < len; i++) {
- e = els[i];
- if(e){
- Ext.Element.prototype[fn].apply(me.getElement(e), args);
- }
- }
- return me;
- },
- /**
- * Returns a flyweight Element of the dom element object at the specified index
- * @param {Number} index
- * @return {Ext.Element}
- */
- item : function(index){
- var me = this,
- el = me.elements[index],
- out = null;
+ /** @private */
+ instantiators: [],
- if(el){
- out = me.getElement(el);
- }
- return out;
- },
- // fixes scope with flyweight
- addListener : function(eventName, handler, scope, opt){
- var els = this.elements,
- len = els.length,
- i, e;
+ /**
+ * Checks if a class has already been created.
+ *
+ * @param {String} className
+ * @return {Boolean} exist
+ */
+ isCreated: function(className) {
+ var i, ln, part, root, parts;
- for(i = 0; iCalls the passed function for each element in this composite.
- * @param {Function} fn The function to call. The function is passed the following parameters:
- *
el : Element
The current Element in the iteration.
- * This is the flyweight (shared) Ext.Element instance, so if you require a
- * a reference to the dom node, use el.dom.
- *
c : Composite
This Composite object.
- *
idx : Number
The zero-based index in the iteration.
- *
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed. (defaults to the Element)
- * @return {CompositeElement} this
- */
- each : function(fn, scope){
- var me = this,
- els = me.elements,
- len = els.length,
- i, e;
- for(i = 0; i
- *
el : Ext.Element
The current DOM element.
- *
index : Number
The current index within the collection.
- *
- * @return {CompositeElement} this
- */
- filter : function(selector){
- var els = [],
- me = this,
- fn = Ext.isFunction(selector) ? selector
- : function(el){
- return el.is(selector);
- };
+ this.existCache[className] = true;
- me.each(function(el, self, i) {
- if (fn(el, i) !== false) {
- els[els.length] = me.transformElement(el);
- }
- });
-
- me.elements = els;
- return me;
- },
+ return true;
+ },
- /**
- * Find the index of the passed element within the composite collection.
- * @param el {Mixed} The id of an element, or an Ext.Element, or an HtmlElement to find within the composite collection.
- * @return Number The index of the passed Ext.Element in the composite collection, or -1 if not found.
- */
- indexOf : function(el){
- return this.elements.indexOf(this.transformElement(el));
- },
+ /**
+ * Supports namespace rewriting
+ * @private
+ */
+ parseNamespace: function(namespace) {
- /**
- * Replaces the specified element with the passed element.
- * @param {Mixed} el The id of an element, the Element itself, the index of the element in this composite
- * to replace.
- * @param {Mixed} replacement The id of an element or the Element itself.
- * @param {Boolean} domReplace (Optional) True to remove and replace the element in the document too.
- * @return {CompositeElement} this
- */
- replaceElement : function(el, replacement, domReplace){
- var index = !isNaN(el) ? el : this.indexOf(el),
- d;
- if(index > -1){
- replacement = Ext.getDom(replacement);
- if(domReplace){
- d = this.elements[index];
- d.parentNode.insertBefore(replacement, d);
- Ext.removeNode(d);
+ var cache = this.namespaceParseCache;
+
+ if (this.enableNamespaceParseCache) {
+ if (cache.hasOwnProperty(namespace)) {
+ return cache[namespace];
+ }
}
- this.elements.splice(index, 1, replacement);
- }
- return this;
- },
- /**
- * Removes all elements.
- */
- clear : function(){
- this.elements = [];
- }
-};
+ var parts = [],
+ rewrites = this.namespaceRewrites,
+ rewrite, from, to, i, ln, root = Ext.global;
-Ext.CompositeElementLite.prototype.on = Ext.CompositeElementLite.prototype.addListener;
+ for (i = 0, ln = rewrites.length; i < ln; i++) {
+ rewrite = rewrites[i];
+ from = rewrite.from;
+ to = rewrite.to;
-/**
- * @private
- * Copies all of the functions from Ext.Element's prototype onto CompositeElementLite's prototype.
- * This is called twice - once immediately below, and once again after additional Ext.Element
- * are added in Ext JS
- */
-Ext.CompositeElementLite.importElementMethods = function() {
- var fnName,
- ElProto = Ext.Element.prototype,
- CelProto = Ext.CompositeElementLite.prototype;
+ if (namespace === from || namespace.substring(0, from.length) === from) {
+ namespace = namespace.substring(from.length);
- for (fnName in ElProto) {
- if (typeof ElProto[fnName] == 'function'){
- (function(fnName) {
- CelProto[fnName] = CelProto[fnName] || function() {
- return this.invoke(fnName, arguments);
- };
- }).call(CelProto, fnName);
+ if (typeof to !== 'string') {
+ root = to;
+ } else {
+ parts = parts.concat(to.split('.'));
+ }
- }
- }
-};
+ break;
+ }
+ }
-Ext.CompositeElementLite.importElementMethods();
+ parts.push(root);
-if(Ext.DomQuery){
- Ext.Element.selectorFunction = Ext.DomQuery.select;
-}
+ parts = parts.concat(namespace.split('.'));
-/**
- * Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
- * to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
- * {@link Ext.CompositeElementLite CompositeElementLite} object.
- * @param {String/Array} selector The CSS selector or an array of elements
- * @param {HTMLElement/String} root (optional) The root element of the query or id of the root
- * @return {CompositeElementLite/CompositeElement}
- * @member Ext.Element
- * @method select
- */
-Ext.Element.select = function(selector, root){
- var els;
- if(typeof selector == "string"){
- els = Ext.Element.selectorFunction(selector, root);
- }else if(selector.length !== undefined){
- els = selector;
- }else{
- throw "Invalid selector";
- }
- return new Ext.CompositeElementLite(els);
-};
-/**
- * Selects elements based on the passed CSS selector to enable {@link Ext.Element Element} methods
- * to be applied to many related elements in one statement through the returned {@link Ext.CompositeElement CompositeElement} or
- * {@link Ext.CompositeElementLite CompositeElementLite} object.
- * @param {String/Array} selector The CSS selector or an array of elements
- * @param {HTMLElement/String} root (optional) The root element of the query or id of the root
- * @return {CompositeElementLite/CompositeElement}
- * @member Ext
- * @method select
- */
-Ext.select = Ext.Element.select;
-(function(){
- var BEFOREREQUEST = "beforerequest",
- REQUESTCOMPLETE = "requestcomplete",
- REQUESTEXCEPTION = "requestexception",
- UNDEFINED = undefined,
- LOAD = 'load',
- POST = 'POST',
- GET = 'GET',
- WINDOW = window;
-
- /**
- * @class Ext.data.Connection
- * @extends Ext.util.Observable
- *
The class encapsulates a connection to the page's originating domain, allowing requests to be made
- * either to a configured URL, or to a URL specified at request time.
- *
Requests made by this class are asynchronous, and will return immediately. No data from
- * the server will be available to the statement immediately following the {@link #request} call.
- * To process returned data, use a
- * success callback
- * in the request options object,
- * or an {@link #requestcomplete event listener}.
- *
File Uploads
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.
- *
Also note that it's not possible to check the response code of the hidden iframe, so the success handler will ALWAYS fire.
- * @constructor
- * @param {Object} config a configuration object.
- */
- Ext.data.Connection = function(config){
- Ext.apply(this, config);
- this.addEvents(
- /**
- * @event beforerequest
- * Fires before a network request is made to retrieve a data object.
- * @param {Connection} conn This Connection object.
- * @param {Object} options The options config object passed to the {@link #request} method.
- */
- BEFOREREQUEST,
- /**
- * @event requestcomplete
- * Fires if the request was successfully completed.
- * @param {Connection} conn This Connection object.
- * @param {Object} response The XHR object containing the response data.
- * See The XMLHttpRequest Object
- * for details.
- * @param {Object} options The options config object passed to the {@link #request} method.
- */
- REQUESTCOMPLETE,
- /**
- * @event requestexception
- * Fires if an error HTTP status was returned from the server.
- * See HTTP Status Code Definitions
- * for details of HTTP status codes.
- * @param {Connection} conn This Connection object.
- * @param {Object} response The XHR object containing the response data.
- * See The XMLHttpRequest Object
- * for details.
- * @param {Object} options The options config object passed to the {@link #request} method.
- */
- REQUESTEXCEPTION
- );
- Ext.data.Connection.superclass.constructor.call(this);
- };
+ if (this.enableNamespaceParseCache) {
+ cache[namespace] = parts;
+ }
+
+ return parts;
+ },
+
+ /**
+ * Creates a namespace and assign the `value` to the created object
+ *
+ * Ext.ClassManager.setNamespace('MyCompany.pkg.Example', someObject);
+ *
+ * alert(MyCompany.pkg.Example === someObject); // alerts true
+ *
+ * @param {String} name
+ * @param {Mixed} value
+ */
+ setNamespace: function(name, value) {
+ var root = Ext.global,
+ parts = this.parseNamespace(name),
+ leaf = parts.pop(),
+ i, ln, part;
+
+ for (i = 0, ln = parts.length; i < ln; i++) {
+ part = parts[i];
+
+ if (typeof part !== 'string') {
+ root = part;
+ } else {
+ if (!root[part]) {
+ root[part] = {};
+ }
+
+ root = root[part];
+ }
+ }
+
+ root[leaf] = value;
+
+ return root[leaf];
+ },
+
+ /**
+ * The new Ext.ns, supports namespace rewriting
+ * @private
+ */
+ createNamespaces: function() {
+ var root = Ext.global,
+ parts, part, i, j, ln, subLn;
+
+ for (i = 0, ln = arguments.length; i < ln; i++) {
+ parts = this.parseNamespace(arguments[i]);
+
+ for (j = 0, subLn = parts.length; j < subLn; j++) {
+ part = parts[j];
+
+ if (typeof part !== 'string') {
+ root = part;
+ } else {
+ if (!root[part]) {
+ root[part] = {};
+ }
+
+ root = root[part];
+ }
+ }
+ }
+
+ return root;
+ },
+
+ /**
+ * Sets a name reference to a class.
+ *
+ * @param {String} name
+ * @param {Object} value
+ * @return {Ext.ClassManager} this
+ */
+ set: function(name, value) {
+ var targetName = this.getName(value);
+
+ this.classes[name] = this.setNamespace(name, value);
+
+ if (targetName && targetName !== name) {
+ this.maps.alternateToName[name] = targetName;
+ }
+
+ return this;
+ },
- Ext.extend(Ext.data.Connection, Ext.util.Observable, {
/**
- * @cfg {String} url (Optional)
The default URL to be used for requests to the server. Defaults to undefined.
- *
The url config may be a function which returns the URL to use for the Ajax request. The scope
- * (this reference) of the function is the scope option passed to the {@link #request} method.
+ * Retrieve a class by its name.
+ *
+ * @param {String} name
+ * @return {Class} class
*/
+ get: function(name) {
+ if (this.classes.hasOwnProperty(name)) {
+ return this.classes[name];
+ }
+
+ var root = Ext.global,
+ parts = this.parseNamespace(name),
+ part, i, ln;
+
+ for (i = 0, ln = parts.length; i < ln; i++) {
+ part = parts[i];
+
+ if (typeof part !== 'string') {
+ root = part;
+ } else {
+ if (!root || !root[part]) {
+ return null;
+ }
+
+ root = root[part];
+ }
+ }
+
+ return root;
+ },
+
/**
- * @cfg {Object} extraParams (Optional) An object containing properties which are used as
- * extra parameters to each request made by this object. (defaults to undefined)
+ * Register the alias for a class.
+ *
+ * @param {Class/String} cls a reference to a class or a className
+ * @param {String} alias Alias to use when referring to this class
*/
+ setAlias: function(cls, alias) {
+ var aliasToNameMap = this.maps.aliasToName,
+ nameToAliasesMap = this.maps.nameToAliases,
+ className;
+
+ if (typeof cls === 'string') {
+ className = cls;
+ } else {
+ className = this.getName(cls);
+ }
+
+ if (alias && aliasToNameMap[alias] !== className) {
+
+ aliasToNameMap[alias] = className;
+ }
+
+ if (!nameToAliasesMap[className]) {
+ nameToAliasesMap[className] = [];
+ }
+
+ if (alias) {
+ Ext.Array.include(nameToAliasesMap[className], alias);
+ }
+
+ return this;
+ },
+
/**
- * @cfg {Object} defaultHeaders (Optional) An object containing request headers which are added
- * to each request made by this object. (defaults to undefined)
+ * Get a reference to the class by its alias.
+ *
+ * @param {String} alias
+ * @return {Class} class
*/
+ getByAlias: function(alias) {
+ return this.get(this.getNameByAlias(alias));
+ },
+
/**
- * @cfg {String} method (Optional) The default HTTP method to be used for requests.
- * (defaults to undefined; if not set, but {@link #request} params are present, POST will be used;
- * otherwise, GET will be used.)
+ * Get the name of a class by its alias.
+ *
+ * @param {String} alias
+ * @return {String} className
*/
+ getNameByAlias: function(alias) {
+ return this.maps.aliasToName[alias] || '';
+ },
+
/**
- * @cfg {Number} timeout (Optional) The timeout in milliseconds to be used for requests. (defaults to 30000)
+ * Get the name of a class by its alternate name.
+ *
+ * @param {String} alternate
+ * @return {String} className
*/
- timeout : 30000,
+ getNameByAlternate: function(alternate) {
+ return this.maps.alternateToName[alternate] || '';
+ },
+
/**
- * @cfg {Boolean} autoAbort (Optional) Whether this request should abort any pending requests. (defaults to false)
- * @type Boolean
+ * Get the aliases of a class by the class name
+ *
+ * @param {String} name
+ * @return {Array} aliases
*/
- autoAbort:false,
+ getAliasesByName: function(name) {
+ return this.maps.nameToAliases[name] || [];
+ },
/**
- * @cfg {Boolean} disableCaching (Optional) True to add a unique cache-buster param to GET requests. (defaults to true)
- * @type Boolean
+ * Get the name of the class by its reference or its instance.
+ *
+ * Ext.ClassManager.getName(Ext.Action); // returns "Ext.Action"
+ *
+ * {@link Ext#getClassName Ext.getClassName} is alias for {@link Ext.ClassManager#getName Ext.ClassManager.getName}.
+ *
+ * @param {Class/Object} object
+ * @return {String} className
*/
- disableCaching: true,
+ getName: function(object) {
+ return object && object.$className || '';
+ },
/**
- * @cfg {String} disableCachingParam (Optional) Change the parameter which is sent went disabling caching
- * through a cache buster. Defaults to '_dc'
- * @type String
+ * Get the class of the provided object; returns null if it's not an instance
+ * of any class created with Ext.define.
+ *
+ * var component = new Ext.Component();
+ *
+ * Ext.ClassManager.getClass(component); // returns Ext.Component
+ *
+ * {@link Ext#getClass Ext.getClass} is alias for {@link Ext.ClassManager#getClass Ext.ClassManager.getClass}.
+ *
+ * @param {Object} object
+ * @return {Class} class
*/
- disableCachingParam: '_dc',
+ getClass: function(object) {
+ return object && object.self || null;
+ },
/**
- *
Sends an HTTP request to a remote server.
- *
Important: Ajax server requests are asynchronous, and this call will
- * return before the response has been received. Process any returned data
- * in a callback function.
To execute a callback function in the correct scope, use the scope option.
- * @param {Object} options An object which may contain the following properties:
- *
url : String/Function (Optional)
The URL to
- * which to send the request, or a function to call which returns a URL string. The scope of the
- * function is specified by the scope option. Defaults to the configured
- * {@link #url}.
- *
params : Object/String/Function (Optional)
- * An object containing properties which are used as parameters to the
- * request, a url encoded string or a function to call to get either. The scope of the function
- * is specified by the scope option.
- *
method : String (Optional)
The HTTP method to use
- * for the request. Defaults to the configured method, or if no method was configured,
- * "GET" if no parameters are being sent, and "POST" if parameters are being sent. Note that
- * the method name is case-sensitive and should be all caps.
- *
callback : Function (Optional)
The
- * function to be called upon receipt of the HTTP response. The callback is
- * called regardless of success or failure and is passed the following
- * parameters:
- *
options : Object
The parameter to the request call.
- *
success : Boolean
True if the request succeeded.
- *
response : Object
The XMLHttpRequest object containing the response data.
- * See http://www.w3.org/TR/XMLHttpRequest/ for details about
- * accessing elements of the response.
- *
- *
success : Function (Optional)
The function
- * to be called upon success of the request. The callback is passed the following
- * parameters:
- *
response : Object
The XMLHttpRequest object containing the response data.
- *
options : Object
The parameter to the request call.
- *
- *
failure : Function (Optional)
The function
- * to be called upon failure of the request. The callback is passed the
- * following parameters:
- *
response : Object
The XMLHttpRequest object containing the response data.
- *
options : Object
The parameter to the request call.
- *
- *
scope : Object (Optional)
The scope in
- * which to execute the callbacks: The "this" object for the callback function. If the url, or params options were
- * specified as functions from which to draw values, then this also serves as the scope for those function calls.
- * Defaults to the browser window.
- *
timeout : Number (Optional)
The timeout in milliseconds to be used for this request. Defaults to 30 seconds.
- *
form : Element/HTMLElement/String (Optional)
The <form>
- * Element or the id of the <form> to pull parameters from.
- *
isUpload : Boolean (Optional)
Only meaningful when used
- * with the form option.
- *
True if the form object is a file upload (will be set automatically if the form was
- * configured with enctype "multipart/form-data").
- *
File uploads are not performed using normal "Ajax" techniques, that is they are not
- * performed using XMLHttpRequests. Instead the form is submitted in the standard manner with the
- * DOM <form> element temporarily modified to have its
- * target set to refer
- * to a dynamically generated, hidden <iframe> which is inserted into the document
- * but removed after the return data has been gathered.
- *
The server response is parsed by the browser to create the document for the IFRAME. If the
- * server is using JSON to send the return object, then the
- * Content-Type header
- * must be set to "text/html" in order to tell the browser to insert the text unchanged into the document body.
- *
The response text is retrieved from the document, and a fake XMLHttpRequest object
- * is created containing a responseText property in order to conform to the
- * requirements of event handlers and callbacks.
- *
Be aware that file upload packets are sent with the content type multipart/form
- * and some server technologies (notably JEE) may require some custom processing in order to
- * retrieve parameter names and parameter values from the packet content.
- *
- *
headers : Object (Optional)
Request
- * headers to set for the request.
- *
xmlData : Object (Optional)
XML document
- * to use for the post. Note: This will be used instead of params for the post
- * data. Any params will be appended to the URL.
- *
jsonData : Object/String (Optional)
JSON
- * data to use as the post. Note: This will be used instead of params for the post
- * data. Any params will be appended to the URL.
- *
disableCaching : Boolean (Optional)
True
- * to add a unique cache-buster param to GET requests.
- *
- *
The options object may also contain any other property which might be needed to perform
- * postprocessing in a callback because it is passed to callback functions.
- * @return {Number} transactionId The id of the server transaction. This may be used
- * to cancel the request.
+ * Defines a class.
+ *
+ * Ext.ClassManager.create('My.awesome.Class', {
+ * someProperty: 'something',
+ * someMethod: function() { ... }
+ * ...
+ *
+ * }, function() {
+ * alert('Created!');
+ * alert(this === My.awesome.Class); // alerts true
+ *
+ * var myInstance = new this();
+ * });
+ *
+ * {@link Ext#define Ext.define} is alias for {@link Ext.ClassManager#create Ext.ClassManager.create}.
+ *
+ * @param {String} className The class name to create in string dot-namespaced format, for example:
+ * 'My.very.awesome.Class', 'FeedViewer.plugin.CoolPager'
+ * It is highly recommended to follow this simple convention:
+ *
+ * - The root and the class name are 'CamelCased'
+ * - Everything else is lower-cased
+ *
+ * @param {Object} data The key - value pairs of properties to apply to this class. Property names can be of any valid
+ * strings, except those in the reserved list below:
+ *
+ * - {@link Ext.Base#self self}
+ * - {@link Ext.Class#alias alias}
+ * - {@link Ext.Class#alternateClassName alternateClassName}
+ * - {@link Ext.Class#config config}
+ * - {@link Ext.Class#extend extend}
+ * - {@link Ext.Class#inheritableStatics inheritableStatics}
+ * - {@link Ext.Class#mixins mixins}
+ * - {@link Ext.Class#requires requires}
+ * - {@link Ext.Class#singleton singleton}
+ * - {@link Ext.Class#statics statics}
+ * - {@link Ext.Class#uses uses}
+ *
+ * @param {Function} createdFn Optional callback to execute after the class is created, the execution scope of which
+ * (`this`) will be the newly created class itself.
+ * @return {Ext.Base}
*/
- request : function(o){
- var me = this;
- if(me.fireEvent(BEFOREREQUEST, me, o)){
- if (o.el) {
- if(!Ext.isEmpty(o.indicatorText)){
- me.indicatorText = '
'+o.indicatorText+"
";
+ create: function(className, data, createdFn) {
+ var manager = this;
+
+
+ data.$className = className;
+
+ return new Class(data, function() {
+ var postprocessorStack = data.postprocessors || manager.defaultPostprocessors,
+ registeredPostprocessors = manager.postprocessors,
+ index = 0,
+ postprocessors = [],
+ postprocessor, postprocessors, process, i, ln;
+
+ delete data.postprocessors;
+
+ for (i = 0, ln = postprocessorStack.length; i < ln; i++) {
+ postprocessor = postprocessorStack[i];
+
+ if (typeof postprocessor === 'string') {
+ postprocessor = registeredPostprocessors[postprocessor];
+
+ if (!postprocessor.always) {
+ if (data[postprocessor.name] !== undefined) {
+ postprocessors.push(postprocessor.fn);
+ }
+ }
+ else {
+ postprocessors.push(postprocessor.fn);
+ }
}
- if(me.indicatorText) {
- Ext.getDom(o.el).innerHTML = me.indicatorText;
+ else {
+ postprocessors.push(postprocessor);
}
- o.success = (Ext.isFunction(o.success) ? o.success : function(){}).createInterceptor(function(response) {
- Ext.getDom(o.el).innerHTML = response.responseText;
- });
}
- var p = o.params,
- url = o.url || me.url,
- method,
- cb = {success: me.handleResponse,
- failure: me.handleFailure,
- scope: me,
- argument: {options: o},
- timeout : Ext.num(o.timeout, me.timeout)
- },
- form,
- serForm;
+ process = function(clsName, cls, clsData) {
+ postprocessor = postprocessors[index++];
+ if (!postprocessor) {
+ manager.set(className, cls);
- if (Ext.isFunction(p)) {
- p = p.call(o.scope||WINDOW, o);
- }
+ Ext.Loader.historyPush(className);
- p = Ext.urlEncode(me.extraParams, Ext.isObject(p) ? Ext.urlEncode(p) : p);
+ if (createdFn) {
+ createdFn.call(cls, cls);
+ }
- if (Ext.isFunction(url)) {
- url = url.call(o.scope || WINDOW, o);
- }
+ return;
+ }
- if((form = Ext.getDom(o.form))){
- url = url || form.action;
- if(o.isUpload || (/multipart\/form-data/i.test(form.getAttribute("enctype")))) {
- return me.doFormUpload.call(me, o, p, url);
- }
- serForm = Ext.lib.Ajax.serializeForm(form);
- p = p ? (p + '&' + serForm) : serForm;
- }
+ if (postprocessor.call(this, clsName, cls, clsData, process) !== false) {
+ process.apply(this, arguments);
+ }
+ };
- method = o.method || me.method || ((p || o.xmlData || o.jsonData) ? POST : GET);
+ process.call(manager, className, this, data);
+ });
+ },
- if(method === GET && (me.disableCaching && o.disableCaching !== false) || o.disableCaching === true){
- var dcp = o.disableCachingParam || me.disableCachingParam;
- url = Ext.urlAppend(url, dcp + '=' + (new Date().getTime()));
- }
+ /**
+ * Instantiate a class by its alias.
+ *
+ * If {@link Ext.Loader} is {@link Ext.Loader#setConfig enabled} and the class has not been defined yet, it will
+ * attempt to load the class via synchronous loading.
+ *
+ * var window = Ext.ClassManager.instantiateByAlias('widget.window', { width: 600, height: 800, ... });
+ *
+ * {@link Ext#createByAlias Ext.createByAlias} is alias for {@link Ext.ClassManager#instantiateByAlias Ext.ClassManager.instantiateByAlias}.
+ *
+ * @param {String} alias
+ * @param {Mixed} args,... Additional arguments after the alias will be passed to the
+ * class constructor.
+ * @return {Object} instance
+ */
+ instantiateByAlias: function() {
+ var alias = arguments[0],
+ args = slice.call(arguments),
+ className = this.getNameByAlias(alias);
+
+ if (!className) {
+ className = this.maps.aliasToName[alias];
+
+
+
+ Ext.syncRequire(className);
+ }
+
+ args[0] = className;
+
+ return this.instantiate.apply(this, args);
+ },
+
+ /**
+ * Instantiate a class by either full name, alias or alternate name.
+ *
+ * If {@link Ext.Loader} is {@link Ext.Loader#setConfig enabled} and the class has not been defined yet, it will
+ * attempt to load the class via synchronous loading.
+ *
+ * For example, all these three lines return the same result:
+ *
+ * // alias
+ * var window = Ext.ClassManager.instantiate('widget.window', { width: 600, height: 800, ... });
+ *
+ * // alternate name
+ * var window = Ext.ClassManager.instantiate('Ext.Window', { width: 600, height: 800, ... });
+ *
+ * // full class name
+ * var window = Ext.ClassManager.instantiate('Ext.window.Window', { width: 600, height: 800, ... });
+ *
+ * {@link Ext#create Ext.create} is alias for {@link Ext.ClassManager#instantiate Ext.ClassManager.instantiate}.
+ *
+ * @param {String} name
+ * @param {Mixed} args,... Additional arguments after the name will be passed to the class' constructor.
+ * @return {Object} instance
+ */
+ instantiate: function() {
+ var name = arguments[0],
+ args = slice.call(arguments, 1),
+ alias = name,
+ possibleName, cls;
- o.headers = Ext.apply(o.headers || {}, me.defaultHeaders || {});
+ if (typeof name !== 'function') {
- if(o.autoAbort === true || me.autoAbort) {
- me.abort();
+ cls = this.get(name);
+ }
+ else {
+ cls = name;
+ }
+
+ // No record of this class name, it's possibly an alias, so look it up
+ if (!cls) {
+ possibleName = this.getNameByAlias(name);
+
+ if (possibleName) {
+ name = possibleName;
+
+ cls = this.get(name);
}
+ }
+
+ // Still no record of this class name, it's possibly an alternate name, so look it up
+ if (!cls) {
+ possibleName = this.getNameByAlternate(name);
- if((method == GET || o.xmlData || o.jsonData) && p){
- url = Ext.urlAppend(url, p);
- p = '';
+ if (possibleName) {
+ name = possibleName;
+
+ cls = this.get(name);
}
- return (me.transId = Ext.lib.Ajax.request(method, url, cb, p, o));
- }else{
- return o.callback ? o.callback.apply(o.scope, [o,UNDEFINED,UNDEFINED]) : null;
}
+
+ // Still not existing at this point, try to load it via synchronous mode as the last resort
+ if (!cls) {
+
+ Ext.syncRequire(name);
+
+ cls = this.get(name);
+ }
+
+
+
+ return this.getInstantiator(args.length)(cls, args);
},
/**
- * Determine whether this object has a request outstanding.
- * @param {Number} transactionId (Optional) defaults to the last transaction
- * @return {Boolean} True if there is an outstanding request.
+ * @private
+ * @param name
+ * @param args
*/
- isLoading : function(transId){
- return transId ? Ext.lib.Ajax.isCallInProgress(transId) : !! this.transId;
+ dynInstantiate: function(name, args) {
+ args = Ext.Array.from(args, true);
+ args.unshift(name);
+
+ return this.instantiate.apply(this, args);
},
/**
- * Aborts any outstanding request.
- * @param {Number} transactionId (Optional) defaults to the last transaction
+ * @private
+ * @param length
*/
- abort : function(transId){
- if(transId || this.isLoading()){
- Ext.lib.Ajax.abort(transId || this.transId);
+ getInstantiator: function(length) {
+ if (!this.instantiators[length]) {
+ var i = length,
+ args = [];
+
+ for (i = 0; i < length; i++) {
+ args.push('a['+i+']');
+ }
+
+ this.instantiators[length] = new Function('c', 'a', 'return new c('+args.join(',')+')');
}
+
+ return this.instantiators[length];
},
- // private
- handleResponse : function(response){
- this.transId = false;
- var options = response.argument.options;
- response.argument = options ? options.argument : null;
- this.fireEvent(REQUESTCOMPLETE, this, response, options);
- if(options.success){
- options.success.call(options.scope, response, options);
- }
- if(options.callback){
- options.callback.call(options.scope, options, true, response);
- }
+ /**
+ * @private
+ */
+ postprocessors: {},
+
+ /**
+ * @private
+ */
+ defaultPostprocessors: [],
+
+ /**
+ * Register a post-processor function.
+ *
+ * @param {String} name
+ * @param {Function} postprocessor
+ */
+ registerPostprocessor: function(name, fn, always) {
+ this.postprocessors[name] = {
+ name: name,
+ always: always || false,
+ fn: fn
+ };
+
+ return this;
},
- // private
- handleFailure : function(response, e){
- this.transId = false;
- var options = response.argument.options;
- response.argument = options ? options.argument : null;
- this.fireEvent(REQUESTEXCEPTION, this, response, options, e);
- if(options.failure){
- options.failure.call(options.scope, response, options);
- }
- if(options.callback){
- options.callback.call(options.scope, options, false, response);
- }
+ /**
+ * Set the default post processors array stack which are applied to every class.
+ *
+ * @param {String/Array} The name of a registered post processor or an array of registered names.
+ * @return {Ext.ClassManager} this
+ */
+ setDefaultPostprocessors: function(postprocessors) {
+ this.defaultPostprocessors = Ext.Array.from(postprocessors);
+
+ return this;
},
- // private
- doFormUpload : function(o, ps, url){
- var id = Ext.id(),
- doc = document,
- frame = doc.createElement('iframe'),
- form = Ext.getDom(o.form),
- hiddens = [],
- hd,
- encoding = 'multipart/form-data',
- buf = {
- target: form.target,
- method: form.method,
- encoding: form.encoding,
- enctype: form.enctype,
- action: form.action
- };
+ /**
+ * Insert this post-processor at a specific position in the stack, optionally relative to
+ * any existing post-processor
+ *
+ * @param {String} name The post-processor name. Note that it needs to be registered with
+ * {@link Ext.ClassManager#registerPostprocessor} before this
+ * @param {String} offset The insertion position. Four possible values are:
+ * 'first', 'last', or: 'before', 'after' (relative to the name provided in the third argument)
+ * @param {String} relativeName
+ * @return {Ext.ClassManager} this
+ */
+ setDefaultPostprocessorPosition: function(name, offset, relativeName) {
+ var defaultPostprocessors = this.defaultPostprocessors,
+ index;
- /*
- * Originally this behaviour was modified for Opera 10 to apply the secure URL after
- * the frame had been added to the document. It seems this has since been corrected in
- * Opera so the behaviour has been reverted, the URL will be set before being added.
- */
- Ext.fly(frame).set({
- id: id,
- name: id,
- cls: 'x-hidden',
- src: Ext.SSL_SECURE_URL
- });
+ if (typeof offset === 'string') {
+ if (offset === 'first') {
+ defaultPostprocessors.unshift(name);
- doc.body.appendChild(frame);
+ return this;
+ }
+ else if (offset === 'last') {
+ defaultPostprocessors.push(name);
- // This is required so that IE doesn't pop the response up in a new window.
- if(Ext.isIE){
- document.frames[id].name = id;
+ return this;
+ }
+
+ offset = (offset === 'after') ? 1 : -1;
}
+ index = Ext.Array.indexOf(defaultPostprocessors, relativeName);
- Ext.fly(form).set({
- target: id,
- method: POST,
- enctype: encoding,
- encoding: encoding,
- action: url || buf.action
- });
+ if (index !== -1) {
+ Ext.Array.splice(defaultPostprocessors, Math.max(0, index + offset), 0, name);
+ }
- // add dynamic params
- Ext.iterate(Ext.urlDecode(ps, false), function(k, v){
- hd = doc.createElement('input');
- Ext.fly(hd).set({
- type: 'hidden',
- value: v,
- name: k
- });
- form.appendChild(hd);
- hiddens.push(hd);
- });
+ return this;
+ },
- function cb(){
- var me = this,
- // bogus response object
- r = {responseText : '',
- responseXML : null,
- argument : o.argument},
- doc,
- firstChild;
+ /**
+ * Converts a string expression to an array of matching class names. An expression can either refers to class aliases
+ * or class names. Expressions support wildcards:
+ *
+ * // returns ['Ext.window.Window']
+ * var window = Ext.ClassManager.getNamesByExpression('widget.window');
+ *
+ * // returns ['widget.panel', 'widget.window', ...]
+ * var allWidgets = Ext.ClassManager.getNamesByExpression('widget.*');
+ *
+ * // returns ['Ext.data.Store', 'Ext.data.ArrayProxy', ...]
+ * var allData = Ext.ClassManager.getNamesByExpression('Ext.data.*');
+ *
+ * @param {String} expression
+ * @return {Array} classNames
+ * @markdown
+ */
+ getNamesByExpression: function(expression) {
+ var nameToAliasesMap = this.maps.nameToAliases,
+ names = [],
+ name, alias, aliases, possibleName, regex, i, ln;
- try{
- doc = frame.contentWindow.document || frame.contentDocument || WINDOW.frames[id].document;
- if(doc){
- if(doc.body){
- if(/textarea/i.test((firstChild = doc.body.firstChild || {}).tagName)){ // json response wrapped in textarea
- r.responseText = firstChild.value;
- }else{
- r.responseText = doc.body.innerHTML;
+
+ if (expression.indexOf('*') !== -1) {
+ expression = expression.replace(/\*/g, '(.*?)');
+ regex = new RegExp('^' + expression + '$');
+
+ for (name in nameToAliasesMap) {
+ if (nameToAliasesMap.hasOwnProperty(name)) {
+ aliases = nameToAliasesMap[name];
+
+ if (name.search(regex) !== -1) {
+ names.push(name);
+ }
+ else {
+ for (i = 0, ln = aliases.length; i < ln; i++) {
+ alias = aliases[i];
+
+ if (alias.search(regex) !== -1) {
+ names.push(name);
+ break;
+ }
}
}
- //in IE the document may still have a body even if returns XML.
- r.responseXML = doc.XMLDocument || doc;
}
}
- catch(e) {}
- Ext.EventManager.removeListener(frame, LOAD, cb, me);
+ } else {
+ possibleName = this.getNameByAlias(expression);
- me.fireEvent(REQUESTCOMPLETE, me, r, o);
+ if (possibleName) {
+ names.push(possibleName);
+ } else {
+ possibleName = this.getNameByAlternate(expression);
- function runCallback(fn, scope, args){
- if(Ext.isFunction(fn)){
- fn.apply(scope, args);
+ if (possibleName) {
+ names.push(possibleName);
+ } else {
+ names.push(expression);
}
}
+ }
- runCallback(o.success, o.scope, [r, o]);
- runCallback(o.callback, o.scope, [o, true, r]);
+ return names;
+ }
+ };
- if(!me.debugUploads){
- setTimeout(function(){Ext.removeNode(frame);}, 100);
- }
- }
+ /**
+ * @cfg {[String]} alias
+ * @member Ext.Class
+ * List of short aliases for class names. Most useful for defining xtypes for widgets:
+ *
+ * Ext.define('MyApp.CoolPanel', {
+ * extend: 'Ext.panel.Panel',
+ * alias: ['widget.coolpanel'],
+ * title: 'Yeah!'
+ * });
+ *
+ * // Using Ext.create
+ * Ext.widget('widget.coolpanel');
+ * // Using the shorthand for widgets and in xtypes
+ * Ext.widget('panel', {
+ * items: [
+ * {xtype: 'coolpanel', html: 'Foo'},
+ * {xtype: 'coolpanel', html: 'Bar'}
+ * ]
+ * });
+ */
+ Manager.registerPostprocessor('alias', function(name, cls, data) {
+ var aliases = data.alias,
+ widgetPrefix = 'widget.',
+ i, ln, alias;
+
+ if (!(aliases instanceof Array)) {
+ aliases = [aliases];
+ }
- Ext.EventManager.on(frame, LOAD, cb, this);
- form.submit();
+ for (i = 0, ln = aliases.length; i < ln; i++) {
+ alias = aliases[i];
- Ext.fly(form).set(buf);
- Ext.each(hiddens, function(h) {
- Ext.removeNode(h);
- });
+
+ this.setAlias(cls, alias);
+ }
+
+ // This is ugly, will change to make use of parseNamespace for alias later on
+ for (i = 0, ln = aliases.length; i < ln; i++) {
+ alias = aliases[i];
+
+ if (alias.substring(0, widgetPrefix.length) === widgetPrefix) {
+ // Only the first alias with 'widget.' prefix will be used for xtype
+ cls.xtype = cls.$xtype = alias.substring(widgetPrefix.length);
+ break;
+ }
}
});
-})();
-/**
- * @class Ext.Ajax
- * @extends Ext.data.Connection
- *
The global Ajax request class that provides a simple way to make Ajax requests
- * with maximum flexibility.
- *
Since Ext.Ajax is a singleton, you can set common properties/events for it once
- * and override them at the request function level only if necessary.
- *
Common Properties you may want to set are:
- *
{@link #method}
- *
{@link #extraParams}
- *
{@link #url}
- *
- *
-// Default headers to pass in every request
-Ext.Ajax.defaultHeaders = {
- 'Powered-By': 'Ext'
-};
- *
-// Example: show a spinner during all Ajax requests
-Ext.Ajax.on('beforerequest', this.showSpinner, this);
-Ext.Ajax.on('requestcomplete', this.hideSpinner, this);
-Ext.Ajax.on('requestexception', this.hideSpinner, this);
- *
- *
- * @singleton
- */
-Ext.Ajax = new Ext.data.Connection({
- /**
- * @cfg {String} url @hide
- */
/**
- * @cfg {Object} extraParams @hide
- */
- /**
- * @cfg {Object} defaultHeaders @hide
- */
- /**
- * @cfg {String} method (Optional) @hide
- */
- /**
- * @cfg {Number} timeout (Optional) @hide
- */
- /**
- * @cfg {Boolean} autoAbort (Optional) @hide
+ * @cfg {Boolean} singleton
+ * @member Ext.Class
+ * When set to true, the class will be instanciated as singleton. For example:
+ *
+ * Ext.define('Logger', {
+ * singleton: true,
+ * log: function(msg) {
+ * console.log(msg);
+ * }
+ * });
+ *
+ * Logger.log('Hello');
*/
+ Manager.registerPostprocessor('singleton', function(name, cls, data, fn) {
+ fn.call(this, name, new cls(), data);
+ return false;
+ });
/**
- * @cfg {Boolean} disableCaching (Optional) @hide
+ * @cfg {String/[String]} alternateClassName
+ * @member Ext.Class
+ * Defines alternate names for this class. For example:
+ *
+ * Ext.define('Developer', {
+ * alternateClassName: ['Coder', 'Hacker'],
+ * code: function(msg) {
+ * alert('Typing... ' + msg);
+ * }
+ * });
+ *
+ * var joe = Ext.create('Developer');
+ * joe.code('stackoverflow');
+ *
+ * var rms = Ext.create('Hacker');
+ * rms.code('hack hack');
*/
+ Manager.registerPostprocessor('alternateClassName', function(name, cls, data) {
+ var alternates = data.alternateClassName,
+ i, ln, alternate;
- /**
- * @property disableCaching
- * True to add a unique cache-buster param to GET requests. (defaults to true)
- * @type Boolean
- */
- /**
- * @property url
- * The default URL to be used for requests to the server. (defaults to undefined)
- * If the server receives all requests through one URL, setting this once is easier than
- * entering it on every request.
- * @type String
- */
- /**
- * @property extraParams
- * An object containing properties which are used as extra parameters to each request made
- * by this object (defaults to undefined). Session information and other data that you need
- * to pass with each request are commonly put here.
- * @type Object
- */
- /**
- * @property defaultHeaders
- * An object containing request headers which are added to each request made by this object
- * (defaults to undefined).
- * @type Object
- */
- /**
- * @property method
- * The default HTTP method to be used for requests. Note that this is case-sensitive and
- * should be all caps (defaults to undefined; if not set but params are present will use
- * "POST", otherwise will use "GET".)
- * @type String
- */
- /**
- * @property timeout
- * The timeout in milliseconds to be used for requests. (defaults to 30000)
- * @type Number
- */
+ if (!(alternates instanceof Array)) {
+ alternates = [alternates];
+ }
- /**
- * @property autoAbort
- * Whether a new request should abort any pending requests. (defaults to false)
- * @type Boolean
- */
- autoAbort : false,
+ for (i = 0, ln = alternates.length; i < ln; i++) {
+ alternate = alternates[i];
- /**
- * Serialize the passed form into a url encoded string
- * @param {String/HTMLElement} form
- * @return {String}
- */
- serializeForm : function(form){
- return Ext.lib.Ajax.serializeForm(form);
- }
-});
-/**
- * @class Ext.util.JSON
- * Modified version of Douglas Crockford"s json.js that doesn"t
- * mess with the Object prototype
- * http://www.json.org/js.html
- * @singleton
- */
-Ext.util.JSON = new (function(){
- var useHasOwn = !!{}.hasOwnProperty,
- isNative = function() {
- var useNative = null;
- return function() {
- if (useNative === null) {
- useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
- }
-
- return useNative;
- };
- }(),
- pad = function(n) {
- return n < 10 ? "0" + n : n;
- },
- doDecode = function(json){
- return eval("(" + json + ")");
- },
- doEncode = function(o){
- if(!Ext.isDefined(o) || o === null){
- return "null";
- }else if(Ext.isArray(o)){
- return encodeArray(o);
- }else if(Ext.isDate(o)){
- return Ext.util.JSON.encodeDate(o);
- }else if(Ext.isString(o)){
- return encodeString(o);
- }else if(typeof o == "number"){
- //don't use isNumber here, since finite checks happen inside isNumber
- return isFinite(o) ? String(o) : "null";
- }else if(Ext.isBoolean(o)){
- return String(o);
- }else {
- var a = ["{"], b, i, v;
- for (i in o) {
- // don't encode DOM objects
- if(!o.getElementsByTagName){
- if(!useHasOwn || o.hasOwnProperty(i)) {
- v = o[i];
- switch (typeof v) {
- case "undefined":
- case "function":
- case "unknown":
- break;
- default:
- if(b){
- a.push(',');
- }
- a.push(doEncode(i), ":",
- v === null ? "null" : doEncode(v));
- b = true;
- }
- }
- }
+ this.set(alternate, cls);
+ }
+ });
+
+ Manager.setDefaultPostprocessors(['alias', 'singleton', 'alternateClassName']);
+
+ Ext.apply(Ext, {
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.ClassManager#instantiate
+ */
+ create: alias(Manager, 'instantiate'),
+
+ /**
+ * @private
+ * API to be stablized
+ *
+ * @param {Mixed} item
+ * @param {String} namespace
+ */
+ factory: function(item, namespace) {
+ if (item instanceof Array) {
+ var i, ln;
+
+ for (i = 0, ln = item.length; i < ln; i++) {
+ item[i] = Ext.factory(item[i], namespace);
}
- a.push("}");
- return a.join("");
- }
- },
- m = {
- "\b": '\\b',
- "\t": '\\t',
- "\n": '\\n',
- "\f": '\\f',
- "\r": '\\r',
- '"' : '\\"',
- "\\": '\\\\'
- },
- encodeString = function(s){
- if (/["\\\x00-\x1f]/.test(s)) {
- return '"' + s.replace(/([\x00-\x1f\\"])/g, function(a, b) {
- var c = m[b];
- if(c){
- return c;
- }
- c = b.charCodeAt();
- return "\\u00" +
- Math.floor(c / 16).toString(16) +
- (c % 16).toString(16);
- }) + '"';
+
+ return item;
}
- return '"' + s + '"';
- },
- encodeArray = function(o){
- var a = ["["], b, i, l = o.length, v;
- for (i = 0; i < l; i += 1) {
- v = o[i];
- switch (typeof v) {
- case "undefined":
- case "function":
- case "unknown":
- break;
- default:
- if (b) {
- a.push(',');
- }
- a.push(v === null ? "null" : Ext.util.JSON.encode(v));
- b = true;
- }
+
+ var isString = (typeof item === 'string');
+
+ if (isString || (item instanceof Object && item.constructor === Object)) {
+ var name, config = {};
+
+ if (isString) {
+ name = item;
+ }
+ else {
+ name = item.className;
+ config = item;
+ delete config.className;
}
- a.push("]");
- return a.join("");
- };
- /**
- *
Encodes a Date. This returns the actual string which is inserted into the JSON string as the literal expression.
- * The returned value includes enclosing double quotation marks.
- *
The default return format is "yyyy-mm-ddThh:mm:ss".
- * @param {Date} d The Date to encode
- * @return {String} The string literal to use in a JSON string.
- */
- this.encodeDate = function(o){
- return '"' + o.getFullYear() + "-" +
- pad(o.getMonth() + 1) + "-" +
- pad(o.getDate()) + "T" +
- pad(o.getHours()) + ":" +
- pad(o.getMinutes()) + ":" +
- pad(o.getSeconds()) + '"';
- };
+ if (namespace !== undefined && name.indexOf(namespace) === -1) {
+ name = namespace + '.' + Ext.String.capitalize(name);
+ }
- /**
- * Encodes an Object, Array or other value
- * @param {Mixed} o The variable to encode
- * @return {String} The JSON string
- */
- this.encode = function() {
- var ec;
- return function(o) {
- if (!ec) {
- // setup encoding function on first access
- ec = isNative() ? JSON.stringify : doEncode;
+ return Ext.create(name, config);
}
- return ec(o);
- };
- }();
+ if (typeof item === 'function') {
+ return Ext.create(item);
+ }
- /**
- * Decodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError unless the safe option is set.
- * @param {String} json The JSON string
- * @return {Object} The resulting object
- */
- this.decode = function() {
- var dc;
- return function(json) {
- if (!dc) {
- // setup decoding function on first access
- dc = isNative() ? JSON.parse : doDecode;
- }
- return dc(json);
- };
- }();
+ return item;
+ },
-})();
-/**
- * Shorthand for {@link Ext.util.JSON#encode}
- * @param {Mixed} o The variable to encode
- * @return {String} The JSON string
- * @member Ext
- * @method encode
- */
-Ext.encode = Ext.util.JSON.encode;
-/**
- * Shorthand for {@link Ext.util.JSON#decode}
- * @param {String} json The JSON string
- * @param {Boolean} safe (optional) Whether to return null or throw an exception if the JSON is invalid.
- * @return {Object} The resulting object
- * @member Ext
- * @method decode
- */
-Ext.decode = Ext.util.JSON.decode;
-/**
- * @class Ext.EventManager
- * Registers event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
- * several useful events directly.
- * See {@link Ext.EventObject} for more details on normalized event objects.
- * @singleton
- */
-Ext.EventManager = function(){
- var docReadyEvent,
- docReadyProcId,
- docReadyState = false,
- DETECT_NATIVE = Ext.isGecko || Ext.isWebKit || Ext.isSafari,
- E = Ext.lib.Event,
- D = Ext.lib.Dom,
- DOC = document,
- WINDOW = window,
- DOMCONTENTLOADED = "DOMContentLoaded",
- COMPLETE = 'complete',
- propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
- /*
- * This cache is used to hold special js objects, the document and window, that don't have an id. We need to keep
- * a reference to them so we can look them up at a later point.
+ /**
+ * Convenient shorthand to create a widget by its xtype, also see {@link Ext.ClassManager#instantiateByAlias}
+ *
+ * var button = Ext.widget('button'); // Equivalent to Ext.create('widget.button')
+ * var panel = Ext.widget('panel'); // Equivalent to Ext.create('widget.panel')
+ *
+ * @method
+ * @member Ext
+ * @param {String} name xtype of the widget to create.
+ * @return {Object} widget instance
*/
- specialElCache = [];
+ widget: function(name) {
+ var args = slice.call(arguments);
+ args[0] = 'widget.' + name;
- function getId(el){
- var id = false,
- i = 0,
- len = specialElCache.length,
- skip = false,
- o;
-
- if (el) {
- if (el.getElementById || el.navigator) {
- // look up the id
- for(; i < len; ++i){
- o = specialElCache[i];
- if(o.el === el){
- id = o.id;
- break;
- }
- }
- if(!id){
- // for browsers that support it, ensure that give the el the same id
- id = Ext.id(el);
- specialElCache.push({
- id: id,
- el: el
- });
- skip = true;
- }
- }else{
- id = Ext.id(el);
- }
- if(!Ext.elCache[id]){
- Ext.Element.addToCache(new Ext.Element(el), id);
- if(skip){
- Ext.elCache[id].skipGC = true;
- }
- }
- }
- return id;
- }
+ return Manager.instantiateByAlias.apply(Manager, args);
+ },
- /// There is some jquery work around stuff here that isn't needed in Ext Core.
- function addListener(el, ename, fn, task, wrap, scope){
- el = Ext.getDom(el);
- var id = getId(el),
- es = Ext.elCache[id].events,
- wfn;
-
- wfn = E.on(el, ename, wrap);
- es[ename] = es[ename] || [];
-
- /* 0 = Original Function,
- 1 = Event Manager Wrapped Function,
- 2 = Scope,
- 3 = Adapter Wrapped Function,
- 4 = Buffered Task
- */
- es[ename].push([fn, wrap, scope, wfn, task]);
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.ClassManager#instantiateByAlias
+ */
+ createByAlias: alias(Manager, 'instantiateByAlias'),
- // this is a workaround for jQuery and should somehow be removed from Ext Core in the future
- // without breaking ExtJS.
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.ClassManager#create
+ */
+ define: alias(Manager, 'create'),
- // workaround for jQuery
- if(el.addEventListener && ename == "mousewheel"){
- var args = ["DOMMouseScroll", wrap, false];
- el.addEventListener.apply(el, args);
- Ext.EventManager.addListener(WINDOW, 'unload', function(){
- el.removeEventListener.apply(el, args);
- });
- }
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.ClassManager#getName
+ */
+ getClassName: alias(Manager, 'getName'),
- // fix stopped mousedowns on the document
- if(el == DOC && ename == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.addListener(wrap);
- }
- }
+ /**
+ *
+ * @param {Mixed} object
+ */
+ getDisplayName: function(object) {
+ if (object.displayName) {
+ return object.displayName;
+ }
- function doScrollChk(){
- /* Notes:
- 'doScroll' will NOT work in a IFRAME/FRAMESET.
- The method succeeds but, a DOM query done immediately after -- FAILS.
- */
- if(window != top){
- return false;
- }
+ if (object.$name && object.$class) {
+ return Ext.getClassName(object.$class) + '#' + object.$name;
+ }
- try{
- DOC.documentElement.doScroll('left');
- }catch(e){
- return false;
- }
+ if (object.$className) {
+ return object.$className;
+ }
+
+ return 'Anonymous';
+ },
+
+ /**
+ * @method
+ * @member Ext
+ * @alias Ext.ClassManager#getClass
+ */
+ getClass: alias(Manager, 'getClass'),
+
+ /**
+ * Creates namespaces to be used for scoping variables and classes so that they are not global.
+ * Specifying the last node of a namespace implicitly creates all other nodes. Usage:
+ *
+ * Ext.namespace('Company', 'Company.data');
+ *
+ * // equivalent and preferable to the above syntax
+ * Ext.namespace('Company.data');
+ *
+ * Company.Widget = function() { ... };
+ *
+ * Company.data.CustomStore = function(config) { ... };
+ *
+ * @method
+ * @member Ext
+ * @param {String} namespace1
+ * @param {String} namespace2
+ * @param {String} etc
+ * @return {Object} The namespace object. (If multiple arguments are passed, this will be the last namespace created)
+ */
+ namespace: alias(Manager, 'createNamespaces')
+ });
- fireDocReady();
- return true;
- }
/**
- * @return {Boolean} True if the document is in a 'complete' state (or was determined to
- * be true by other means). If false, the state is evaluated again until canceled.
+ * Old name for {@link Ext#widget}.
+ * @deprecated 4.0.0 Use {@link Ext#widget} instead.
+ * @method
+ * @member Ext
+ * @alias Ext#widget
*/
- function checkReadyState(e){
+ Ext.createWidget = Ext.widget;
- if(Ext.isIE && doScrollChk()){
- return true;
- }
- if(DOC.readyState == COMPLETE){
- fireDocReady();
- return true;
- }
- docReadyState || (docReadyProcId = setTimeout(arguments.callee, 2));
- return false;
- }
+ /**
+ * Convenient alias for {@link Ext#namespace Ext.namespace}
+ * @method
+ * @member Ext
+ * @alias Ext#namespace
+ */
+ Ext.ns = Ext.namespace;
- var styles;
- function checkStyleSheets(e){
- styles || (styles = Ext.query('style, link[rel=stylesheet]'));
- if(styles.length == DOC.styleSheets.length){
- fireDocReady();
- return true;
+ Class.registerPreprocessor('className', function(cls, data) {
+ if (data.$className) {
+ cls.$className = data.$className;
}
- docReadyState || (docReadyProcId = setTimeout(arguments.callee, 2));
- return false;
- }
+ }, true);
- function OperaDOMContentLoaded(e){
- DOC.removeEventListener(DOMCONTENTLOADED, arguments.callee, false);
- checkStyleSheets();
- }
+ Class.setDefaultPreprocessorPosition('className', 'first');
- function fireDocReady(e){
- if(!docReadyState){
- docReadyState = true; //only attempt listener removal once
+})(Ext.Class, Ext.Function.alias);
- if(docReadyProcId){
- clearTimeout(docReadyProcId);
- }
- if(DETECT_NATIVE) {
- DOC.removeEventListener(DOMCONTENTLOADED, fireDocReady, false);
- }
- if(Ext.isIE && checkReadyState.bindIE){ //was this was actually set ??
- DOC.detachEvent('onreadystatechange', checkReadyState);
- }
- E.un(WINDOW, "load", arguments.callee);
- }
- if(docReadyEvent && !Ext.isReady){
- Ext.isReady = true;
- docReadyEvent.fire();
- docReadyEvent.listeners = [];
- }
+/**
+ * @class Ext.Loader
+ * @singleton
+ * @author Jacky Nguyen
+ * @docauthor Jacky Nguyen
+ *
+ * Ext.Loader is the heart of the new dynamic dependency loading capability in Ext JS 4+. It is most commonly used
+ * via the {@link Ext#require} shorthand. Ext.Loader supports both asynchronous and synchronous loading
+ * approaches, and leverage their advantages for the best development flow. We'll discuss about the pros and cons
+ * of each approach:
+ *
+ * # Asynchronous Loading
+ *
+ * - *Advantages:*
+ * + Cross-domain
+ * + No web server needed: you can run the application via the file system protocol
+ * (i.e: `file://path/to/your/index.html`)
+ * + Best possible debugging experience: error messages come with the exact file name and line number
+ *
+ * - *Disadvantages:*
+ * + Dependencies need to be specified before-hand
+ *
+ * ### Method 1: Explicitly include what you need:
+ *
+ * // Syntax
+ * Ext.require({String/Array} expressions);
+ *
+ * // Example: Single alias
+ * Ext.require('widget.window');
+ *
+ * // Example: Single class name
+ * Ext.require('Ext.window.Window');
+ *
+ * // Example: Multiple aliases / class names mix
+ * Ext.require(['widget.window', 'layout.border', 'Ext.data.Connection']);
+ *
+ * // Wildcards
+ * Ext.require(['widget.*', 'layout.*', 'Ext.data.*']);
+ *
+ * ### Method 2: Explicitly exclude what you don't need:
+ *
+ * // Syntax: Note that it must be in this chaining format.
+ * Ext.exclude({String/Array} expressions)
+ * .require({String/Array} expressions);
+ *
+ * // Include everything except Ext.data.*
+ * Ext.exclude('Ext.data.*').require('*');ÂÂ
+ *
+ * // Include all widgets except widget.checkbox*,
+ * // which will match widget.checkbox, widget.checkboxfield, widget.checkboxgroup, etc.
+ * Ext.exclude('widget.checkbox*').require('widget.*');
+ *
+ * # Synchronous Loading on Demand
+ *
+ * - *Advantages:*
+ * + There's no need to specify dependencies before-hand, which is always the convenience of including
+ * ext-all.js before
+ *
+ * - *Disadvantages:*
+ * + Not as good debugging experience since file name won't be shown (except in Firebug at the moment)
+ * + Must be from the same domain due to XHR restriction
+ * + Need a web server, same reason as above
+ *
+ * There's one simple rule to follow: Instantiate everything with Ext.create instead of the `new` keyword
+ *
+ * Ext.create('widget.window', { ... }); // Instead of new Ext.window.Window({...});
+ *
+ * Ext.create('Ext.window.Window', {}); // Same as above, using full class name instead of alias
+ *
+ * Ext.widget('window', {}); // Same as above, all you need is the traditional `xtype`
+ *
+ * Behind the scene, {@link Ext.ClassManager} will automatically check whether the given class name / alias has already
+ * existed on the page. If it's not, Ext.Loader will immediately switch itself to synchronous mode and automatic load
+ * the given class and all its dependencies.
+ *
+ * # Hybrid Loading - The Best of Both Worlds
+ *
+ * It has all the advantages combined from asynchronous and synchronous loading. The development flow is simple:
+ *
+ * ### Step 1: Start writing your application using synchronous approach.
+ *
+ * Ext.Loader will automatically fetch all dependencies on demand as they're needed during run-time. For example:
+ *
+ * Ext.onReady(function(){
+ * var window = Ext.createWidget('window', {
+ * width: 500,
+ * height: 300,
+ * layout: {
+ * type: 'border',
+ * padding: 5
+ * },
+ * title: 'Hello Dialog',
+ * items: [{
+ * title: 'Navigation',
+ * collapsible: true,
+ * region: 'west',
+ * width: 200,
+ * html: 'Hello',
+ * split: true
+ * }, {
+ * title: 'TabPanel',
+ * region: 'center'
+ * }]
+ * });
+ *
+ * window.show();
+ * })
+ *
+ * ### Step 2: Along the way, when you need better debugging ability, watch the console for warnings like these:
+ *
+ * [Ext.Loader] Synchronously loading 'Ext.window.Window'; consider adding Ext.require('Ext.window.Window') before your application's code ClassManager.js:432
+ * [Ext.Loader] Synchronously loading 'Ext.layout.container.Border'; consider adding Ext.require('Ext.layout.container.Border') before your application's code
+ *
+ * Simply copy and paste the suggested code above `Ext.onReady`, e.g.:
+ *
+ * Ext.require('Ext.window.Window');
+ * Ext.require('Ext.layout.container.Border');
+ *
+ * Ext.onReady(...);
+ *
+ * Everything should now load via asynchronous mode.
+ *
+ * # Deployment
+ *
+ * It's important to note that dynamic loading should only be used during development on your local machines.
+ * During production, all dependencies should be combined into one single JavaScript file. Ext.Loader makes
+ * the whole process of transitioning from / to between development / maintenance and production as easy as
+ * possible. Internally {@link Ext.Loader#history Ext.Loader.history} maintains the list of all dependencies
+ * your application needs in the exact loading sequence. It's as simple as concatenating all files in this
+ * array into one, then include it on top of your application.
+ *
+ * This process will be automated with Sencha Command, to be released and documented towards Ext JS 4 Final.
+ */
+(function(Manager, Class, flexSetter, alias) {
- }
+ var
+ dependencyProperties = ['extend', 'mixins', 'requires'],
+ Loader;
- function initDocReady(){
- docReadyEvent || (docReadyEvent = new Ext.util.Event());
- if (DETECT_NATIVE) {
- DOC.addEventListener(DOMCONTENTLOADED, fireDocReady, false);
- }
- /*
- * Handle additional (exceptional) detection strategies here
+ Loader = Ext.Loader = {
+ /**
+ * @private
*/
- if (Ext.isIE){
- //Use readystatechange as a backup AND primary detection mechanism for a FRAME/IFRAME
- //See if page is already loaded
- if(!checkReadyState()){
- checkReadyState.bindIE = true;
- DOC.attachEvent('onreadystatechange', checkReadyState);
- }
-
- }else if(Ext.isOpera ){
- /* Notes:
- Opera needs special treatment needed here because CSS rules are NOT QUITE
- available after DOMContentLoaded is raised.
- */
-
- //See if page is already loaded and all styleSheets are in place
- (DOC.readyState == COMPLETE && checkStyleSheets()) ||
- DOC.addEventListener(DOMCONTENTLOADED, OperaDOMContentLoaded, false);
-
- }else if (Ext.isWebKit){
- //Fallback for older Webkits without DOMCONTENTLOADED support
- checkReadyState();
- }
- // no matter what, make sure it fires on load
- E.on(WINDOW, "load", fireDocReady);
- }
+ documentHead: typeof document !== 'undefined' && (document.head || document.getElementsByTagName('head')[0]),
- function createTargeted(h, o){
- return function(){
- var args = Ext.toArray(arguments);
- if(o.target == Ext.EventObject.setEvent(args[0]).target){
- h.apply(this, args);
- }
- };
- }
+ /**
+ * Flag indicating whether there are still files being loaded
+ * @private
+ */
+ isLoading: false,
- function createBuffered(h, o, task){
- return function(e){
- // create new event object impl so new events don't wipe out properties
- task.delay(o.buffer, h, null, [new Ext.EventObjectImpl(e)]);
- };
- }
+ /**
+ * Maintain the queue for all dependencies. Each item in the array is an object of the format:
+ * {
+ * requires: [...], // The required classes for this queue item
+ * callback: function() { ... } // The function to execute when all classes specified in requires exist
+ * }
+ * @private
+ */
+ queue: [],
- function createSingle(h, el, ename, fn, scope){
- return function(e){
- Ext.EventManager.removeListener(el, ename, fn, scope);
- h(e);
- };
- }
+ /**
+ * Maintain the list of files that have already been handled so that they never get double-loaded
+ * @private
+ */
+ isFileLoaded: {},
- function createDelayed(h, o, fn){
- return function(e){
- var task = new Ext.util.DelayedTask(h);
- if(!fn.tasks) {
- fn.tasks = [];
- }
- fn.tasks.push(task);
- task.delay(o.delay || 10, h, null, [new Ext.EventObjectImpl(e)]);
- };
- }
+ /**
+ * Maintain the list of listeners to execute when all required scripts are fully loaded
+ * @private
+ */
+ readyListeners: [],
- function listen(element, ename, opt, fn, scope){
- var o = (!opt || typeof opt == "boolean") ? {} : opt,
- el = Ext.getDom(element), task;
+ /**
+ * Contains optional dependencies to be loaded last
+ * @private
+ */
+ optionalRequires: [],
- fn = fn || o.fn;
- scope = scope || o.scope;
+ /**
+ * Map of fully qualified class names to an array of dependent classes.
+ * @private
+ */
+ requiresMap: {},
- if(!el){
- throw "Error listening for \"" + ename + '\". Element "' + element + '" doesn\'t exist.';
- }
- function h(e){
- // prevent errors while unload occurring
- if(!Ext){// !window[xname]){ ==> can't we do this?
- return;
- }
- e = Ext.EventObject.setEvent(e);
- var t;
- if (o.delegate) {
- if(!(t = e.getTarget(o.delegate, el))){
- return;
- }
- } else {
- t = e.target;
- }
- if (o.stopEvent) {
- e.stopEvent();
- }
- if (o.preventDefault) {
- e.preventDefault();
- }
- if (o.stopPropagation) {
- e.stopPropagation();
- }
- if (o.normalized === false) {
- e = e.browserEvent;
- }
+ /**
+ * @private
+ */
+ numPendingFiles: 0,
- fn.call(scope || el, e, t, o);
- }
- if(o.target){
- h = createTargeted(h, o);
- }
- if(o.delay){
- h = createDelayed(h, o, fn);
- }
- if(o.single){
- h = createSingle(h, el, ename, fn, scope);
- }
- if(o.buffer){
- task = new Ext.util.DelayedTask(h);
- h = createBuffered(h, o, task);
- }
+ /**
+ * @private
+ */
+ numLoadedFiles: 0,
- addListener(el, ename, fn, task, h, scope);
- return h;
- }
+ /** @private */
+ hasFileLoadError: false,
- var pub = {
- /**
- * Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
- * use {@link Ext.Element#addListener} directly on an Element in favor of calling this version.
- * @param {String/HTMLElement} el The html element or id to assign the event handler to.
- * @param {String} eventName The name of the event to listen for.
- * @param {Function} handler The handler function the event invokes. This function is passed
- * the following parameters:
- *
evt : EventObject
The {@link Ext.EventObject EventObject} describing the event.
- *
t : Element
The {@link Ext.Element Element} which was the target of the event.
- * Note that this may be filtered by using the delegate option.
- *
o : Object
The options object from the addListener call.
- *
- * @param {Object} scope (optional) The scope (this reference) in which the handler function is executed. Defaults to the Element.
- * @param {Object} options (optional) An object containing handler configuration properties.
- * This may contain any of the following properties:
- *
scope : Object
The scope (this reference) in which the handler function is executed. Defaults to the Element.
- *
delegate : String
A simple selector to filter the target or look for a descendant of the target
- *
stopEvent : Boolean
True to stop the event. That is stop propagation, and prevent the default action.
- *
preventDefault : Boolean
True to prevent the default action
- *
stopPropagation : Boolean
True to prevent event propagation
- *
normalized : Boolean
False to pass a browser event to the handler function instead of an Ext.EventObject
- *
delay : Number
The number of milliseconds to delay the invocation of the handler after te event fires.
- *
single : Boolean
True to add a handler to handle just the next firing of the event, and then remove itself.
- *
buffer : Number
Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
- * by the specified number of milliseconds. If the event fires again within that time, the original
- * handler is not invoked, but the new handler is scheduled in its place.
- *
target : Element
Only call the handler if the event was fired on the target Element, not if the event was bubbled up from a child node.
- *
- *
See {@link Ext.Element#addListener} for examples of how to use these options.
+ /**
+ * @private
*/
- addListener : function(element, eventName, fn, scope, options){
- if(typeof eventName == 'object'){
- var o = eventName, e, val;
- for(e in o){
- val = o[e];
- if(!propRe.test(e)){
- if(Ext.isFunction(val)){
- // shared options
- listen(element, e, o, val, o.scope);
- }else{
- // individual options
- listen(element, e, val);
- }
- }
- }
- } else {
- listen(element, eventName, options, fn, scope);
- }
- },
+ classNameToFilePathMap: {},
/**
- * Removes an event handler from an element. The shorthand version {@link #un} is equivalent. Typically
- * you will use {@link Ext.Element#removeListener} directly on an Element in favor of calling this version.
- * @param {String/HTMLElement} el The id or html element from which to remove the listener.
- * @param {String} eventName The name of the event.
- * @param {Function} fn The handler function to remove. This must be a reference to the function passed into the {@link #addListener} call.
- * @param {Object} scope If a scope (this reference) was specified when the listener was added,
- * then this must refer to the same object.
+ * @property {[String]} history
+ * An array of class names to keep track of the dependency loading order.
+ * This is not guaranteed to be the same everytime due to the asynchronous nature of the Loader.
*/
- removeListener : function(el, eventName, fn, scope){
- el = Ext.getDom(el);
- var id = getId(el),
- f = el && (Ext.elCache[id].events)[eventName] || [],
- wrap, i, l, k, len, fnc;
-
- for (i = 0, len = f.length; i < len; i++) {
+ history: [],
- /* 0 = Original Function,
- 1 = Event Manager Wrapped Function,
- 2 = Scope,
- 3 = Adapter Wrapped Function,
- 4 = Buffered Task
- */
- if (Ext.isArray(fnc = f[i]) && fnc[0] == fn && (!scope || fnc[2] == scope)) {
- if(fnc[4]) {
- fnc[4].cancel();
- }
- k = fn.tasks && fn.tasks.length;
- if(k) {
- while(k--) {
- fn.tasks[k].cancel();
- }
- delete fn.tasks;
- }
- wrap = fnc[1];
- E.un(el, eventName, E.extAdapter ? fnc[3] : wrap);
+ /**
+ * Configuration
+ * @private
+ */
+ config: {
+ /**
+ * @cfg {Boolean} enabled
+ * Whether or not to enable the dynamic dependency loading feature Defaults to false
+ */
+ enabled: false,
- // jQuery workaround that should be removed from Ext Core
- if(wrap && el.addEventListener && eventName == "mousewheel"){
- el.removeEventListener("DOMMouseScroll", wrap, false);
- }
+ /**
+ * @cfg {Boolean} disableCaching
+ * Appends current timestamp to script files to prevent caching Defaults to true
+ */
+ disableCaching: true,
- // fix stopped mousedowns on the document
- if(wrap && el == DOC && eventName == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.removeListener(wrap);
- }
+ /**
+ * @cfg {String} disableCachingParam
+ * The get parameter name for the cache buster's timestamp. Defaults to '_dc'
+ */
+ disableCachingParam: '_dc',
- f.splice(i, 1);
- if (f.length === 0) {
- delete Ext.elCache[id].events[eventName];
- }
- for (k in Ext.elCache[id].events) {
- return false;
- }
- Ext.elCache[id].events = {};
- return false;
- }
+ /**
+ * @cfg {Object} paths
+ * The mapping from namespaces to file paths
+ *
+ * {
+ * 'Ext': '.', // This is set by default, Ext.layout.container.Container will be
+ * // loaded from ./layout/Container.js
+ *
+ * 'My': './src/my_own_folder' // My.layout.Container will be loaded from
+ * // ./src/my_own_folder/layout/Container.js
+ * }
+ *
+ * Note that all relative paths are relative to the current HTML document.
+ * If not being specified, for example, `Other.awesome.Class`
+ * will simply be loaded from `./Other/awesome/Class.js`
+ */
+ paths: {
+ 'Ext': '.'
}
},
/**
- * Removes all event handers from an element. Typically you will use {@link Ext.Element#removeAllListeners}
- * directly on an Element in favor of calling this version.
- * @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
+ * Set the configuration for the loader. This should be called right after ext-core.js
+ * (or ext-core-debug.js) is included in the page, e.g.:
+ *
+ *
+ *
+ *
+ * Refer to config options of {@link Ext.Loader} for the list of possible properties.
+ *
+ * @param {String/Object} name Name of the value to override, or a config object to override multiple values.
+ * @param {Object} value (optional) The new value to set, needed if first parameter is String.
+ * @return {Ext.Loader} this
*/
- removeAll : function(el){
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- f, i, len, ename, fn, k, wrap;
-
- for(ename in es){
- if(es.hasOwnProperty(ename)){
- f = es[ename];
- /* 0 = Original Function,
- 1 = Event Manager Wrapped Function,
- 2 = Scope,
- 3 = Adapter Wrapped Function,
- 4 = Buffered Task
- */
- for (i = 0, len = f.length; i < len; i++) {
- fn = f[i];
- if(fn[4]) {
- fn[4].cancel();
- }
- if(fn[0].tasks && (k = fn[0].tasks.length)) {
- while(k--) {
- fn[0].tasks[k].cancel();
- }
- delete fn.tasks;
- }
- wrap = fn[1];
- E.un(el, ename, E.extAdapter ? fn[3] : wrap);
-
- // jQuery workaround that should be removed from Ext Core
- if(el.addEventListener && wrap && ename == "mousewheel"){
- el.removeEventListener("DOMMouseScroll", wrap, false);
- }
-
- // fix stopped mousedowns on the document
- if(wrap && el == DOC && ename == "mousedown"){
- Ext.EventManager.stoppedMouseDownEvent.removeListener(wrap);
- }
- }
- }
+ setConfig: function(name, value) {
+ if (Ext.isObject(name) && arguments.length === 1) {
+ Ext.Object.merge(this.config, name);
}
- if (Ext.elCache[id]) {
- Ext.elCache[id].events = {};
+ else {
+ this.config[name] = (Ext.isObject(value)) ? Ext.Object.merge(this.config[name], value) : value;
}
+
+ return this;
},
- getListeners : function(el, eventName) {
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- results = [];
- if (es && es[eventName]) {
- return es[eventName];
- } else {
- return null;
+ /**
+ * Get the config value corresponding to the specified name.
+ * If no name is given, will return the config object.
+ * @param {String} name The config property name
+ * @return {Object/Mixed}
+ */
+ getConfig: function(name) {
+ if (name) {
+ return this.config[name];
}
+
+ return this.config;
},
- purgeElement : function(el, recurse, eventName) {
- el = Ext.getDom(el);
- var id = getId(el),
- ec = Ext.elCache[id] || {},
- es = ec.events || {},
- i, f, len;
- if (eventName) {
- if (es && es.hasOwnProperty(eventName)) {
- f = es[eventName];
- for (i = 0, len = f.length; i < len; i++) {
- Ext.EventManager.removeListener(el, eventName, f[i][0]);
- }
- }
- } else {
- Ext.EventManager.removeAll(el);
- }
- if (recurse && el && el.childNodes) {
- for (i = 0, len = el.childNodes.length; i < len; i++) {
- Ext.EventManager.purgeElement(el.childNodes[i], recurse, eventName);
+ /**
+ * Sets the path of a namespace. For Example:
+ *
+ * Ext.Loader.setPath('Ext', '.');
+ *
+ * @param {String/Object} name See {@link Ext.Function#flexSetter flexSetter}
+ * @param {String} path See {@link Ext.Function#flexSetter flexSetter}
+ * @return {Ext.Loader} this
+ * @method
+ */
+ setPath: flexSetter(function(name, path) {
+ this.config.paths[name] = path;
+
+ return this;
+ }),
+
+ /**
+ * Translates a className to a file path by adding the the proper prefix and converting the .'s to /'s.
+ * For example:
+ *
+ * Ext.Loader.setPath('My', '/path/to/My');
+ *
+ * alert(Ext.Loader.getPath('My.awesome.Class')); // alerts '/path/to/My/awesome/Class.js'
+ *
+ * Note that the deeper namespace levels, if explicitly set, are always resolved first. For example:
+ *
+ * Ext.Loader.setPath({
+ * 'My': '/path/to/lib',
+ * 'My.awesome': '/other/path/for/awesome/stuff',
+ * 'My.awesome.more': '/more/awesome/path'
+ * });
+ *
+ * alert(Ext.Loader.getPath('My.awesome.Class')); // alerts '/other/path/for/awesome/stuff/Class.js'
+ *
+ * alert(Ext.Loader.getPath('My.awesome.more.Class')); // alerts '/more/awesome/path/Class.js'
+ *
+ * alert(Ext.Loader.getPath('My.cool.Class')); // alerts '/path/to/lib/cool/Class.js'
+ *
+ * alert(Ext.Loader.getPath('Unknown.strange.Stuff')); // alerts 'Unknown/strange/Stuff.js'
+ *
+ * @param {String} className
+ * @return {String} path
+ */
+ getPath: function(className) {
+ var path = '',
+ paths = this.config.paths,
+ prefix = this.getPrefix(className);
+
+ if (prefix.length > 0) {
+ if (prefix === className) {
+ return paths[prefix];
}
- }
- },
- _unload : function() {
- var el;
- for (el in Ext.elCache) {
- Ext.EventManager.removeAll(el);
+ path = paths[prefix];
+ className = className.substring(prefix.length + 1);
}
- delete Ext.elCache;
- delete Ext.Element._flyweights;
- // Abort any outstanding Ajax requests
- var c,
- conn,
- tid,
- ajax = Ext.lib.Ajax;
- (typeof ajax.conn == 'object') ? conn = ajax.conn : conn = {};
- for (tid in conn) {
- c = conn[tid];
- if (c) {
- ajax.abort({conn: c, tId: tid});
- }
+ if (path.length > 0) {
+ path += '/';
}
+
+ return path.replace(/\/\.\//g, '/') + className.replace(/\./g, "/") + '.js';
},
+
/**
- * Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
- * accessed shorthanded as Ext.onReady().
- * @param {Function} fn The method the event invokes.
- * @param {Object} scope (optional) The scope (this reference) in which the handler function executes. Defaults to the browser window.
- * @param {boolean} options (optional) Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
- * {single: true} be used so that the handler is removed on first invocation.
+ * @private
+ * @param {String} className
*/
- onDocumentReady : function(fn, scope, options){
- if (Ext.isReady) { // if it already fired or document.body is present
- docReadyEvent || (docReadyEvent = new Ext.util.Event());
- docReadyEvent.addListener(fn, scope, options);
- docReadyEvent.fire();
- docReadyEvent.listeners = [];
- } else {
- if (!docReadyEvent) {
- initDocReady();
+ getPrefix: function(className) {
+ var paths = this.config.paths,
+ prefix, deepestPrefix = '';
+
+ if (paths.hasOwnProperty(className)) {
+ return className;
+ }
+
+ for (prefix in paths) {
+ if (paths.hasOwnProperty(prefix) && prefix + '.' === className.substring(0, prefix.length + 1)) {
+ if (prefix.length > deepestPrefix.length) {
+ deepestPrefix = prefix;
+ }
}
- options = options || {};
- options.delay = options.delay || 1;
- docReadyEvent.addListener(fn, scope, options);
}
+
+ return deepestPrefix;
},
/**
- * Forces a document ready state transition for the framework. Used when Ext is loaded
- * into a DOM structure AFTER initial page load (Google API or other dynamic load scenario.
- * Any pending 'onDocumentReady' handlers will be fired (if not already handled).
+ * Refresh all items in the queue. If all dependencies for an item exist during looping,
+ * it will execute the callback and call refreshQueue again. Triggers onReady when the queue is
+ * empty
+ * @private
*/
- fireDocReady : fireDocReady
- };
- /**
- * Appends an event handler to an element. Shorthand for {@link #addListener}.
- * @param {String/HTMLElement} el The html element or id to assign the event handler to
- * @param {String} eventName The name of the event to listen for.
- * @param {Function} handler The handler function the event invokes.
- * @param {Object} scope (optional) (this reference) in which the handler function executes. Defaults to the Element.
- * @param {Object} options (optional) An object containing standard {@link #addListener} options
- * @member Ext.EventManager
- * @method on
- */
- pub.on = pub.addListener;
- /**
- * Removes an event handler from an element. Shorthand for {@link #removeListener}.
- * @param {String/HTMLElement} el The id or html element from which to remove the listener.
- * @param {String} eventName The name of the event.
- * @param {Function} fn The handler function to remove. This must be a reference to the function passed into the {@link #on} call.
- * @param {Object} scope If a scope (this reference) was specified when the listener was added,
- * then this must refer to the same object.
- * @member Ext.EventManager
- * @method un
- */
- pub.un = pub.removeListener;
+ refreshQueue: function() {
+ var ln = this.queue.length,
+ i, item, j, requires;
- pub.stoppedMouseDownEvent = new Ext.util.Event();
- return pub;
-}();
-/**
- * Adds a listener to be notified when the document is ready (before onload and before images are loaded). Shorthand of {@link Ext.EventManager#onDocumentReady}.
- * @param {Function} fn The method the event invokes.
- * @param {Object} scope (optional) The scope (this reference) in which the handler function executes. Defaults to the browser window.
- * @param {boolean} options (optional) Options object as passed to {@link Ext.Element#addListener}. It is recommended that the options
- * {single: true} be used so that the handler is removed on first invocation.
- * @member Ext
- * @method onReady
- */
-Ext.onReady = Ext.EventManager.onDocumentReady;
+ if (ln === 0) {
+ this.triggerReady();
+ return;
+ }
+ for (i = 0; i < ln; i++) {
+ item = this.queue[i];
-//Initialize doc classes
-(function(){
- var initExtCss = function() {
- // find the body element
- var bd = document.body || document.getElementsByTagName('body')[0];
- if (!bd) {
- return false;
- }
-
- var cls = [' ',
- Ext.isIE ? "ext-ie " + (Ext.isIE6 ? 'ext-ie6' : (Ext.isIE7 ? 'ext-ie7' : 'ext-ie8'))
- : Ext.isGecko ? "ext-gecko " + (Ext.isGecko2 ? 'ext-gecko2' : 'ext-gecko3')
- : Ext.isOpera ? "ext-opera"
- : Ext.isWebKit ? "ext-webkit" : ""];
+ if (item) {
+ requires = item.requires;
- if (Ext.isSafari) {
- cls.push("ext-safari " + (Ext.isSafari2 ? 'ext-safari2' : (Ext.isSafari3 ? 'ext-safari3' : 'ext-safari4')));
- } else if(Ext.isChrome) {
- cls.push("ext-chrome");
- }
+ // Don't bother checking when the number of files loaded
+ // is still less than the array length
+ if (requires.length > this.numLoadedFiles) {
+ continue;
+ }
- if (Ext.isMac) {
- cls.push("ext-mac");
- }
- if (Ext.isLinux) {
- cls.push("ext-linux");
- }
+ j = 0;
+
+ do {
+ if (Manager.isCreated(requires[j])) {
+ // Take out from the queue
+ Ext.Array.erase(requires, j, 1);
+ }
+ else {
+ j++;
+ }
+ } while (j < requires.length);
- // add to the parent to allow for selectors like ".ext-strict .ext-ie"
- if (Ext.isStrict || Ext.isBorderBox) {
- var p = bd.parentNode;
- if (p) {
- Ext.fly(p, '_internal').addClass(((Ext.isStrict && Ext.isIE ) || (!Ext.enableForcedBoxModel && !Ext.isIE)) ? ' ext-strict' : ' ext-border-box');
+ if (item.requires.length === 0) {
+ Ext.Array.erase(this.queue, i, 1);
+ item.callback.call(item.scope);
+ this.refreshQueue();
+ break;
+ }
+ }
}
- }
- // Forced border box model class applied to all elements. Bypassing javascript based box model adjustments
- // in favor of css. This is for non-IE browsers.
- if (Ext.enableForcedBoxModel && !Ext.isIE) {
- Ext.isForcedBorderBox = true;
- cls.push("ext-forced-border-box");
- }
-
- Ext.fly(bd, '_internal').addClass(cls);
- return true;
- };
-
- if (!initExtCss()) {
- Ext.onReady(initExtCss);
- }
-})();
-/**
- * Code used to detect certain browser feature/quirks/bugs at startup.
- */
-(function(){
- var supports = Ext.apply(Ext.supports, {
+ return this;
+ },
+
/**
- * In Webkit, there is an issue with getting the margin right property, see
- * https://bugs.webkit.org/show_bug.cgi?id=13343
+ * Inject a script element to document's head, call onLoad and onError accordingly
+ * @private
*/
- correctRightMargin: true,
-
+ injectScriptElement: function(url, onLoad, onError, scope) {
+ var script = document.createElement('script'),
+ me = this,
+ onLoadFn = function() {
+ me.cleanupScriptElement(script);
+ onLoad.call(scope);
+ },
+ onErrorFn = function() {
+ me.cleanupScriptElement(script);
+ onError.call(scope);
+ };
+
+ script.type = 'text/javascript';
+ script.src = url;
+ script.onload = onLoadFn;
+ script.onerror = onErrorFn;
+ script.onreadystatechange = function() {
+ if (this.readyState === 'loaded' || this.readyState === 'complete') {
+ onLoadFn();
+ }
+ };
+
+ this.documentHead.appendChild(script);
+
+ return script;
+ },
+
/**
- * Webkit browsers return rgba(0, 0, 0) when a transparent color is used
+ * @private
*/
- correctTransparentColor: true,
-
+ cleanupScriptElement: function(script) {
+ script.onload = null;
+ script.onreadystatechange = null;
+ script.onerror = null;
+
+ return this;
+ },
+
/**
- * IE uses styleFloat, not cssFloat for the float property.
+ * Load a script file, supports both asynchronous and synchronous approaches
+ *
+ * @param {String} url
+ * @param {Function} onLoad
+ * @param {Scope} scope
+ * @param {Boolean} synchronous
+ * @private
*/
- cssFloat: true
- });
-
- var supportTests = function(){
- var div = document.createElement('div'),
- doc = document,
- view,
- last;
-
- div.innerHTML = '
';
- doc.body.appendChild(div);
- last = div.lastChild;
-
- if((view = doc.defaultView)){
- if(view.getComputedStyle(div.firstChild.firstChild, null).marginRight != '0px'){
- supports.correctRightMargin = false;
+ loadScriptFile: function(url, onLoad, onError, scope, synchronous) {
+ var me = this,
+ noCacheUrl = url + (this.getConfig('disableCaching') ? ('?' + this.getConfig('disableCachingParam') + '=' + Ext.Date.now()) : ''),
+ fileName = url.split('/').pop(),
+ isCrossOriginRestricted = false,
+ xhr, status, onScriptError;
+
+ scope = scope || this;
+
+ this.isLoading = true;
+
+ if (!synchronous) {
+ onScriptError = function() {
+ onError.call(scope, "Failed loading '" + url + "', please verify that the file exists", synchronous);
+ };
+
+ if (!Ext.isReady && Ext.onDocumentReady) {
+ Ext.onDocumentReady(function() {
+ me.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
+ });
}
- if(view.getComputedStyle(last, null).backgroundColor != 'transparent'){
- supports.correctTransparentColor = false;
+ else {
+ this.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
}
}
- supports.cssFloat = !!last.style.cssFloat;
- doc.body.removeChild(div);
- };
-
- if (Ext.isReady) {
- supportTests();
- } else {
- Ext.onReady(supportTests);
- }
-})();
+ else {
+ if (typeof XMLHttpRequest !== 'undefined') {
+ xhr = new XMLHttpRequest();
+ } else {
+ xhr = new ActiveXObject('Microsoft.XMLHTTP');
+ }
+ try {
+ xhr.open('GET', noCacheUrl, false);
+ xhr.send(null);
+ } catch (e) {
+ isCrossOriginRestricted = true;
+ }
-/**
- * @class Ext.EventObject
- * Just as {@link Ext.Element} wraps around a native DOM node, Ext.EventObject
- * wraps the browser's native event-object normalizing cross-browser differences,
- * such as which mouse button is clicked, keys pressed, mechanisms to stop
- * event-propagation along with a method to prevent default actions from taking place.
- *
For example:
- *
-function handleClick(e, t){ // e is not a standard event object, it is a Ext.EventObject
- e.preventDefault();
- var target = e.getTarget(); // same as t (the target HTMLElement)
- ...
-}
-var myDiv = {@link Ext#get Ext.get}("myDiv"); // get reference to an {@link Ext.Element}
-myDiv.on( // 'on' is shorthand for addListener
- "click", // perform an action on click of myDiv
- handleClick // reference to the action handler
-);
-// other methods to do the same:
-Ext.EventManager.on("myDiv", 'click', handleClick);
-Ext.EventManager.addListener("myDiv", 'click', handleClick);
-
- * @singleton
- */
-Ext.EventObject = function(){
- var E = Ext.lib.Event,
- clickRe = /(dbl)?click/,
- // safari keypress events for special keys return bad keycodes
- safariKeys = {
- 3 : 13, // enter
- 63234 : 37, // left
- 63235 : 39, // right
- 63232 : 38, // up
- 63233 : 40, // down
- 63276 : 33, // page up
- 63277 : 34, // page down
- 63272 : 46, // delete
- 63273 : 36, // home
- 63275 : 35 // end
- },
- // normalize button clicks
- btnMap = Ext.isIE ? {1:0,4:1,2:2} : {0:0,1:1,2:2};
+ status = (xhr.status === 1223) ? 204 : xhr.status;
- Ext.EventObjectImpl = function(e){
- if(e){
- this.setEvent(e.browserEvent || e);
- }
- };
+ if (!isCrossOriginRestricted) {
+ isCrossOriginRestricted = (status === 0);
+ }
- Ext.EventObjectImpl.prototype = {
- /** @private */
- setEvent : function(e){
- var me = this;
- if(e == me || (e && e.browserEvent)){ // already wrapped
- return e;
- }
- me.browserEvent = e;
- if(e){
- // normalize buttons
- me.button = e.button ? btnMap[e.button] : (e.which ? e.which - 1 : -1);
- if(clickRe.test(e.type) && me.button == -1){
- me.button = 0;
+ if (isCrossOriginRestricted
+ ) {
+ onError.call(this, "Failed loading synchronously via XHR: '" + url + "'; It's likely that the file is either " +
+ "being loaded from a different domain or from the local file system whereby cross origin " +
+ "requests are not allowed due to security reasons. Use asynchronous loading with " +
+ "Ext.require instead.", synchronous);
}
- me.type = e.type;
- me.shiftKey = e.shiftKey;
- // mac metaKey behaves like ctrlKey
- me.ctrlKey = e.ctrlKey || e.metaKey || false;
- me.altKey = e.altKey;
- // in getKey these will be normalized for the mac
- me.keyCode = e.keyCode;
- me.charCode = e.charCode;
- // cache the target for the delayed and or buffered events
- me.target = E.getTarget(e);
- // same for XY
- me.xy = E.getXY(e);
- }else{
- me.button = -1;
- me.shiftKey = false;
- me.ctrlKey = false;
- me.altKey = false;
- me.keyCode = 0;
- me.charCode = 0;
- me.target = null;
- me.xy = [0, 0];
+ else if (status >= 200 && status < 300
+ ) {
+ // Firebug friendly, file names are still shown even though they're eval'ed code
+ new Function(xhr.responseText + "\n//@ sourceURL=" + fileName)();
+
+ onLoad.call(scope);
+ }
+ else {
+ onError.call(this, "Failed loading synchronously via XHR: '" + url + "'; please " +
+ "verify that the file exists. " +
+ "XHR status code: " + status, synchronous);
+ }
+
+ // Prevent potential IE memory leak
+ xhr = null;
}
- return me;
},
/**
- * Stop the event (preventDefault and stopPropagation)
+ * Explicitly exclude files from being loaded. Useful when used in conjunction with a broad include expression.
+ * Can be chained with more `require` and `exclude` methods, e.g.:
+ *
+ * Ext.exclude('Ext.data.*').require('*');
+ *
+ * Ext.exclude('widget.button*').require('widget.*');
+ *
+ * {@link Ext#exclude Ext.exclude} is alias for {@link Ext.Loader#exclude Ext.Loader.exclude} for convenience.
+ *
+ * @param {String/[String]} excludes
+ * @return {Object} object contains `require` method for chaining
*/
- stopEvent : function(){
+ exclude: function(excludes) {
var me = this;
- if(me.browserEvent){
- if(me.browserEvent.type == 'mousedown'){
- Ext.EventManager.stoppedMouseDownEvent.fire(me);
+
+ return {
+ require: function(expressions, fn, scope) {
+ return me.require(expressions, fn, scope, excludes);
+ },
+
+ syncRequire: function(expressions, fn, scope) {
+ return me.syncRequire(expressions, fn, scope, excludes);
}
- E.stopEvent(me.browserEvent);
- }
+ };
},
/**
- * Prevents the browsers default handling of the event.
+ * Synchronously loads all classes by the given names and all their direct dependencies;
+ * optionally executes the given callback function when finishes, within the optional scope.
+ *
+ * {@link Ext#syncRequire Ext.syncRequire} is alias for {@link Ext.Loader#syncRequire Ext.Loader.syncRequire} for convenience.
+ *
+ * @param {String/[String]} expressions Can either be a string or an array of string
+ * @param {Function} fn (Optional) The callback function
+ * @param {Object} scope (Optional) The execution scope (`this`) of the callback function
+ * @param {String/[String]} excludes (Optional) Classes to be excluded, useful when being used with expressions
*/
- preventDefault : function(){
- if(this.browserEvent){
- E.preventDefault(this.browserEvent);
- }
+ syncRequire: function() {
+ this.syncModeEnabled = true;
+ this.require.apply(this, arguments);
+ this.refreshQueue();
+ this.syncModeEnabled = false;
},
/**
- * Cancels bubbling of the event.
+ * Loads all classes by the given names and all their direct dependencies;
+ * optionally executes the given callback function when finishes, within the optional scope.
+ *
+ * {@link Ext#require Ext.require} is alias for {@link Ext.Loader#require Ext.Loader.require} for convenience.
+ *
+ * @param {String/[String]} expressions Can either be a string or an array of string
+ * @param {Function} fn (Optional) The callback function
+ * @param {Object} scope (Optional) The execution scope (`this`) of the callback function
+ * @param {String/[String]} excludes (Optional) Classes to be excluded, useful when being used with expressions
*/
- stopPropagation : function(){
- var me = this;
- if(me.browserEvent){
- if(me.browserEvent.type == 'mousedown'){
- Ext.EventManager.stoppedMouseDownEvent.fire(me);
+ require: function(expressions, fn, scope, excludes) {
+ var filePath, expression, exclude, className, excluded = {},
+ excludedClassNames = [],
+ possibleClassNames = [],
+ possibleClassName, classNames = [],
+ i, j, ln, subLn;
+
+ expressions = Ext.Array.from(expressions);
+ excludes = Ext.Array.from(excludes);
+
+ fn = fn || Ext.emptyFn;
+
+ scope = scope || Ext.global;
+
+ for (i = 0, ln = excludes.length; i < ln; i++) {
+ exclude = excludes[i];
+
+ if (typeof exclude === 'string' && exclude.length > 0) {
+ excludedClassNames = Manager.getNamesByExpression(exclude);
+
+ for (j = 0, subLn = excludedClassNames.length; j < subLn; j++) {
+ excluded[excludedClassNames[j]] = true;
+ }
}
- E.stopPropagation(me.browserEvent);
}
- },
- /**
- * Gets the character code for the event.
- * @return {Number}
- */
- getCharCode : function(){
- return this.charCode || this.keyCode;
- },
+ for (i = 0, ln = expressions.length; i < ln; i++) {
+ expression = expressions[i];
- /**
- * Returns a normalized keyCode for the event.
- * @return {Number} The key code
- */
- getKey : function(){
- return this.normalizeKey(this.keyCode || this.charCode);
- },
+ if (typeof expression === 'string' && expression.length > 0) {
+ possibleClassNames = Manager.getNamesByExpression(expression);
- // private
- normalizeKey: function(k){
- return Ext.isSafari ? (safariKeys[k] || k) : k;
- },
+ for (j = 0, subLn = possibleClassNames.length; j < subLn; j++) {
+ possibleClassName = possibleClassNames[j];
- /**
- * Gets the x coordinate of the event.
- * @return {Number}
- */
- getPageX : function(){
- return this.xy[0];
+ if (!excluded.hasOwnProperty(possibleClassName) && !Manager.isCreated(possibleClassName)) {
+ Ext.Array.include(classNames, possibleClassName);
+ }
+ }
+ }
+ }
+
+ // If the dynamic dependency feature is not being used, throw an error
+ // if the dependencies are not defined
+ if (!this.config.enabled) {
+ if (classNames.length > 0) {
+ Ext.Error.raise({
+ sourceClass: "Ext.Loader",
+ sourceMethod: "require",
+ msg: "Ext.Loader is not enabled, so dependencies cannot be resolved dynamically. " +
+ "Missing required class" + ((classNames.length > 1) ? "es" : "") + ": " + classNames.join(', ')
+ });
+ }
+ }
+
+ if (classNames.length === 0) {
+ fn.call(scope);
+ return this;
+ }
+
+ this.queue.push({
+ requires: classNames,
+ callback: fn,
+ scope: scope
+ });
+
+ classNames = classNames.slice();
+
+ for (i = 0, ln = classNames.length; i < ln; i++) {
+ className = classNames[i];
+
+ if (!this.isFileLoaded.hasOwnProperty(className)) {
+ this.isFileLoaded[className] = false;
+
+ filePath = this.getPath(className);
+
+ this.classNameToFilePathMap[className] = filePath;
+
+ this.numPendingFiles++;
+
+ this.loadScriptFile(
+ filePath,
+ Ext.Function.pass(this.onFileLoaded, [className, filePath], this),
+ Ext.Function.pass(this.onFileLoadError, [className, filePath]),
+ this,
+ this.syncModeEnabled
+ );
+ }
+ }
+
+ return this;
},
/**
- * Gets the y coordinate of the event.
- * @return {Number}
+ * @private
+ * @param {String} className
+ * @param {String} filePath
*/
- getPageY : function(){
- return this.xy[1];
+ onFileLoaded: function(className, filePath) {
+ this.numLoadedFiles++;
+
+ this.isFileLoaded[className] = true;
+
+ this.numPendingFiles--;
+
+ if (this.numPendingFiles === 0) {
+ this.refreshQueue();
+ }
+
+
},
/**
- * Gets the page coordinates of the event.
- * @return {Array} The xy values like [x, y]
+ * @private
*/
- getXY : function(){
- return this.xy;
+ onFileLoadError: function(className, filePath, errorMessage, isSynchronous) {
+ this.numPendingFiles--;
+ this.hasFileLoadError = true;
+
},
/**
- * Gets the target for the event.
- * @param {String} selector (optional) A simple selector to filter the target or look for an ancestor of the target
- * @param {Number/Mixed} maxDepth (optional) The max depth to
- search as a number or element (defaults to 10 || document.body)
- * @param {Boolean} returnEl (optional) True to return a Ext.Element object instead of DOM node
- * @return {HTMLelement}
+ * @private
*/
- getTarget : function(selector, maxDepth, returnEl){
- return selector ? Ext.fly(this.target).findParent(selector, maxDepth, returnEl) : (returnEl ? Ext.get(this.target) : this.target);
- },
+ addOptionalRequires: function(requires) {
+ var optionalRequires = this.optionalRequires,
+ i, ln, require;
- /**
- * Gets the related target.
- * @return {HTMLElement}
- */
- getRelatedTarget : function(){
- return this.browserEvent ? E.getRelatedTarget(this.browserEvent) : null;
+ requires = Ext.Array.from(requires);
+
+ for (i = 0, ln = requires.length; i < ln; i++) {
+ require = requires[i];
+
+ Ext.Array.include(optionalRequires, require);
+ }
+
+ return this;
},
/**
- * Normalizes mouse wheel delta across browsers
- * @return {Number} The delta
+ * @private
*/
- getWheelDelta : function(){
- var e = this.browserEvent;
- var delta = 0;
- if(e.wheelDelta){ /* IE/Opera. */
- delta = e.wheelDelta/120;
- }else if(e.detail){ /* Mozilla case. */
- delta = -e.detail/3;
- }
- return delta;
+ triggerReady: function(force) {
+ var readyListeners = this.readyListeners,
+ optionalRequires, listener;
+
+ if (this.isLoading || force) {
+ this.isLoading = false;
+
+ if (this.optionalRequires.length) {
+ // Clone then empty the array to eliminate potential recursive loop issue
+ optionalRequires = Ext.Array.clone(this.optionalRequires);
+
+ // Empty the original array
+ this.optionalRequires.length = 0;
+
+ this.require(optionalRequires, Ext.Function.pass(this.triggerReady, [true], this), this);
+ return this;
+ }
+
+ while (readyListeners.length) {
+ listener = readyListeners.shift();
+ listener.fn.call(listener.scope);
+
+ if (this.isLoading) {
+ return this;
+ }
+ }
+ }
+
+ return this;
},
/**
- * Returns true if the target of this event is a child of el. Unless the allowEl parameter is set, it will return false if if the target is el.
- * Example usage:
- // Handle click on any child of an element
- Ext.getBody().on('click', function(e){
- if(e.within('some-el')){
- alert('Clicked on a child of some-el!');
+ * Adds new listener to be executed when all required scripts are fully loaded.
+ *
+ * @param {Function} fn The function callback to be executed
+ * @param {Object} scope The execution scope (`this`) of the callback function
+ * @param {Boolean} withDomReady Whether or not to wait for document dom ready as well
+ */
+ onReady: function(fn, scope, withDomReady, options) {
+ var oldFn;
+
+ if (withDomReady !== false && Ext.onDocumentReady) {
+ oldFn = fn;
+
+ fn = function() {
+ Ext.onDocumentReady(oldFn, scope, options);
+ };
}
- });
- // Handle click directly on an element, ignoring clicks on child nodes
- Ext.getBody().on('click', function(e,t){
- if((t.id == 'some-el') && !e.within(t, true)){
- alert('Clicked directly on some-el!');
+ if (!this.isLoading) {
+ fn.call(scope);
}
- });
-
- * @param {Mixed} el The id, DOM element or Ext.Element to check
- * @param {Boolean} related (optional) true to test if the related target is within el instead of the target
- * @param {Boolean} allowEl {optional} true to also check if the passed element is the target or related target
- * @return {Boolean}
- */
- within : function(el, related, allowEl){
- if(el){
- var t = this[related ? "getRelatedTarget" : "getTarget"]();
- return t && ((allowEl ? (t == Ext.getDom(el)) : false) || Ext.fly(el).contains(t));
+ else {
+ this.readyListeners.push({
+ fn: fn,
+ scope: scope
+ });
}
- return false;
- }
- };
+ },
- return new Ext.EventObjectImpl();
-}();
-/**
- * @class Ext.Loader
- * @singleton
- * Simple class to help load JavaScript files on demand
- */
-Ext.Loader = Ext.apply({}, {
- /**
- * Loads a given set of .js files. Calls the callback function when all files have been loaded
- * Set preserveOrder to true to ensure non-parallel loading of files if load order is important
- * @param {Array} fileList Array of all files to load
- * @param {Function} callback Callback to call after all files have been loaded
- * @param {Object} scope The scope to call the callback in
- * @param {Boolean} preserveOrder True to make files load in serial, one after the other (defaults to false)
- */
- load: function(fileList, callback, scope, preserveOrder) {
- var scope = scope || this,
- head = document.getElementsByTagName("head")[0],
- fragment = document.createDocumentFragment(),
- numFiles = fileList.length,
- loadedFiles = 0,
- me = this;
-
- /**
- * Loads a particular file from the fileList by index. This is used when preserving order
- */
- var loadFileIndex = function(index) {
- head.appendChild(
- me.buildScriptTag(fileList[index], onFileLoaded)
- );
- };
-
/**
- * Callback function which is called after each file has been loaded. This calls the callback
- * passed to load once the final file in the fileList has been loaded
+ * @private
+ * @param {String} className
*/
- var onFileLoaded = function() {
- loadedFiles ++;
-
- //if this was the last file, call the callback, otherwise load the next file
- if (numFiles == loadedFiles && typeof callback == 'function') {
- callback.call(scope);
- } else {
- if (preserveOrder === true) {
- loadFileIndex(loadedFiles);
- }
+ historyPush: function(className) {
+ if (className && this.isFileLoaded.hasOwnProperty(className)) {
+ Ext.Array.include(this.history, className);
}
- };
-
- if (preserveOrder === true) {
- loadFileIndex.call(this, 0);
- } else {
- //load each file (most browsers will do this in parallel)
- Ext.each(fileList, function(file, index) {
- fragment.appendChild(
- this.buildScriptTag(file, onFileLoaded)
- );
- }, this);
-
- head.appendChild(fragment);
+
+ return this;
}
- },
-
+ };
+
/**
- * @private
- * Creates and returns a script tag, but does not place it into the document. If a callback function
- * is passed, this is called when the script has been loaded
- * @param {String} filename The name of the file to create a script tag for
- * @param {Function} callback Optional callback, which is called when the script has been loaded
- * @return {Element} The new script ta
+ * @member Ext
+ * @method require
+ * @alias Ext.Loader#require
*/
- buildScriptTag: function(filename, callback) {
- var script = document.createElement('script');
- script.type = "text/javascript";
- script.src = filename;
-
- //IE has a different way of handling <script> loads, so we need to check for it here
- if (script.readyState) {
- script.onreadystatechange = function() {
- if (script.readyState == "loaded" || script.readyState == "complete") {
- script.onreadystatechange = null;
- callback();
- }
- };
- } else {
- script.onload = callback;
- }
-
- return script;
- }
-});
-/**
- * @class Ext
- */
+ Ext.require = alias(Loader, 'require');
-Ext.ns("Ext.grid", "Ext.list", "Ext.dd", "Ext.tree", "Ext.form", "Ext.menu",
- "Ext.state", "Ext.layout", "Ext.app", "Ext.ux", "Ext.chart", "Ext.direct");
/**
- * Namespace alloted for extensions to the framework.
- * @property ux
- * @type Object
+ * @member Ext
+ * @method syncRequire
+ * @alias Ext.Loader#syncRequire
+ */
+ Ext.syncRequire = alias(Loader, 'syncRequire');
+
+ /**
+ * @member Ext
+ * @method exclude
+ * @alias Ext.Loader#exclude
*/
+ Ext.exclude = alias(Loader, 'exclude');
-Ext.apply(Ext, function(){
- var E = Ext,
- idSeed = 0,
- scrollWidth = null;
+ /**
+ * @member Ext
+ * @method onReady
+ * @alias Ext.Loader#onReady
+ */
+ Ext.onReady = function(fn, scope, options) {
+ Loader.onReady(fn, scope, true, options);
+ };
- return {
- /**
- * A reusable empty function
- * @property
- * @type Function
+ /**
+ * @cfg {[String]} requires
+ * @member Ext.Class
+ * List of classes that have to be loaded before instanciating this class.
+ * For example:
+ *
+ * Ext.define('Mother', {
+ * requires: ['Child'],
+ * giveBirth: function() {
+ * // we can be sure that child class is available.
+ * return new Child();
+ * }
+ * });
+ */
+ Class.registerPreprocessor('loader', function(cls, data, continueFn) {
+ var me = this,
+ dependencies = [],
+ className = Manager.getName(cls),
+ i, j, ln, subLn, value, propertyName, propertyValue;
+
+ /*
+ Basically loop through the dependencyProperties, look for string class names and push
+ them into a stack, regardless of whether the property's value is a string, array or object. For example:
+ {
+ extend: 'Ext.MyClass',
+ requires: ['Ext.some.OtherClass'],
+ mixins: {
+ observable: 'Ext.util.Observable';
+ }
+ }
+ which will later be transformed into:
+ {
+ extend: Ext.MyClass,
+ requires: [Ext.some.OtherClass],
+ mixins: {
+ observable: Ext.util.Observable;
+ }
+ }
*/
- emptyFn : function(){},
- /**
- * URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images.
- * In older versions of IE, this defaults to "http://extjs.com/s.gif" and you should change this to a URL on your server.
- * For other browsers it uses an inline data URL.
- * @type String
- */
- BLANK_IMAGE_URL : Ext.isIE6 || Ext.isIE7 || Ext.isAir ?
- 'http:/' + '/www.extjs.com/s.gif' :
- 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
+ for (i = 0, ln = dependencyProperties.length; i < ln; i++) {
+ propertyName = dependencyProperties[i];
- extendX : function(supr, fn){
- return Ext.extend(supr, fn(supr.prototype));
- },
+ if (data.hasOwnProperty(propertyName)) {
+ propertyValue = data[propertyName];
- /**
- * Returns the current HTML document object as an {@link Ext.Element}.
- * @return Ext.Element The document
- */
- getDoc : function(){
- return Ext.get(document);
- },
+ if (typeof propertyValue === 'string') {
+ dependencies.push(propertyValue);
+ }
+ else if (propertyValue instanceof Array) {
+ for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
+ value = propertyValue[j];
- /**
- * Utility method for validating that a value is numeric, returning the specified default value if it is not.
- * @param {Mixed} value Should be a number, but any type will be handled appropriately
- * @param {Number} defaultValue The value to return if the original value is non-numeric
- * @return {Number} Value, if numeric, else defaultValue
- */
- num : function(v, defaultValue){
- v = Number(Ext.isEmpty(v) || Ext.isArray(v) || typeof v == 'boolean' || (typeof v == 'string' && v.trim().length == 0) ? NaN : v);
- return isNaN(v) ? defaultValue : v;
- },
+ if (typeof value === 'string') {
+ dependencies.push(value);
+ }
+ }
+ }
+ else {
+ for (j in propertyValue) {
+ if (propertyValue.hasOwnProperty(j)) {
+ value = propertyValue[j];
- /**
- *
Utility method for returning a default value if the passed value is empty.
- *
The value is deemed to be empty if it is
- *
null
- *
undefined
- *
an empty array
- *
a zero length string (Unless the allowBlank parameter is true)
- *
- * @param {Mixed} value The value to test
- * @param {Mixed} defaultValue The value to return if the original value is empty
- * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
- * @return {Mixed} value, if non-empty, else defaultValue
- */
- value : function(v, defaultValue, allowBlank){
- return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
- },
+ if (typeof value === 'string') {
+ dependencies.push(value);
+ }
+ }
+ }
+ }
+ }
+ }
- /**
- * Escapes the passed string for use in a regular expression
- * @param {String} str
- * @return {String}
- */
- escapeRe : function(s) {
- return s.replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
- },
+ if (dependencies.length === 0) {
+// Loader.historyPush(className);
+ return;
+ }
- sequence : function(o, name, fn, scope){
- o[name] = o[name].createSequence(fn, scope);
- },
- /**
- * Applies event listeners to elements by selectors when the document is ready.
- * The event name is specified with an @ suffix.
- *
-Ext.addBehaviors({
- // add a listener for click on all anchors in element with id foo
- '#foo a@click' : function(e, t){
- // do something
- },
+ Loader.require(dependencies, function() {
+ for (i = 0, ln = dependencyProperties.length; i < ln; i++) {
+ propertyName = dependencyProperties[i];
- // add the same listener to multiple selectors (separated by comma BEFORE the @)
- '#foo a, #bar span.some-class@mouseover' : function(){
- // do something
- }
-});
- *
- * @param {Object} obj The list of behaviors to apply
- */
- addBehaviors : function(o){
- if(!Ext.isReady){
- Ext.onReady(function(){
- Ext.addBehaviors(o);
- });
- } else {
- var cache = {}, // simple cache for applying multiple behaviors to same selector does query multiple times
- parts,
- b,
- s;
- for (b in o) {
- if ((parts = b.split('@'))[1]) { // for Object prototype breakers
- s = parts[0];
- if(!cache[s]){
- cache[s] = Ext.select(s);
+ if (data.hasOwnProperty(propertyName)) {
+ propertyValue = data[propertyName];
+
+ if (typeof propertyValue === 'string') {
+ data[propertyName] = Manager.get(propertyValue);
+ }
+ else if (propertyValue instanceof Array) {
+ for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
+ value = propertyValue[j];
+
+ if (typeof value === 'string') {
+ data[propertyName][j] = Manager.get(value);
+ }
+ }
+ }
+ else {
+ for (var k in propertyValue) {
+ if (propertyValue.hasOwnProperty(k)) {
+ value = propertyValue[k];
+
+ if (typeof value === 'string') {
+ data[propertyName][k] = Manager.get(value);
+ }
+ }
}
- cache[s].on(parts[1], o[b]);
}
}
- cache = null;
}
- },
- /**
- * Utility method for getting the width of the browser scrollbar. This can differ depending on
- * operating system settings, such as the theme or font size.
- * @param {Boolean} force (optional) true to force a recalculation of the value.
- * @return {Number} The width of the scrollbar.
- */
- getScrollBarWidth: function(force){
- if(!Ext.isReady){
- return 0;
- }
+ continueFn.call(me, cls, data);
+ });
- if(force === true || scrollWidth === null){
- // Append our div, do our calculation and then remove it
- var div = Ext.getBody().createChild('
'),
- child = div.child('div', true);
- var w1 = child.offsetWidth;
- div.setStyle('overflow', (Ext.isWebKit || Ext.isGecko) ? 'auto' : 'scroll');
- var w2 = child.offsetWidth;
- div.remove();
- // Need to add 2 to ensure we leave enough space
- scrollWidth = w1 - w2 + 2;
- }
- return scrollWidth;
- },
+ return false;
+ }, true);
+ Class.setDefaultPreprocessorPosition('loader', 'after', 'className');
- // deprecated
- combine : function(){
- var as = arguments, l = as.length, r = [];
- for(var i = 0; i < l; i++){
- var a = as[i];
- if(Ext.isArray(a)){
- r = r.concat(a);
- }else if(a.length !== undefined && !a.substr){
- r = r.concat(Array.prototype.slice.call(a, 0));
- }else{
- r.push(a);
- }
- }
- return r;
- },
+ /**
+ * @cfg {[String]} uses
+ * @member Ext.Class
+ * List of classes to load together with this class. These aren't neccessarily loaded before
+ * this class is instanciated. For example:
+ *
+ * Ext.define('Mother', {
+ * uses: ['Child'],
+ * giveBirth: function() {
+ * // This code might, or might not work:
+ * // return new Child();
+ *
+ * // Instead use Ext.create() to load the class at the spot if not loaded already:
+ * return Ext.create('Child');
+ * }
+ * });
+ */
+ Manager.registerPostprocessor('uses', function(name, cls, data) {
+ var uses = Ext.Array.from(data.uses),
+ items = [],
+ i, ln, item;
- /**
- * Copies a set of named properties fom the source object to the destination object.
- *
- * @param {Object} dest The destination object.
- * @param {Object} source The source object.
- * @param {Array/String} names Either an Array of property names, or a comma-delimited list
- * of property names to copy.
- * @return {Object} The modified object.
- */
- copyTo : function(dest, source, names){
- if(typeof names == 'string'){
- names = names.split(/[,;\s]/);
+ for (i = 0, ln = uses.length; i < ln; i++) {
+ item = uses[i];
+
+ if (typeof item === 'string') {
+ items.push(item);
}
- Ext.each(names, function(name){
- if(source.hasOwnProperty(name)){
- dest[name] = source[name];
- }
- }, this);
- return dest;
- },
+ }
- /**
- * Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
- * DOM (if applicable) and calling their destroy functions (if available). This method is primarily
- * intended for arguments of type {@link Ext.Element} and {@link Ext.Component}, but any subclass of
- * {@link Ext.util.Observable} can be passed in. Any number of elements and/or components can be
- * passed into this function in a single call as separate arguments.
- * @param {Mixed} arg1 An {@link Ext.Element}, {@link Ext.Component}, or an Array of either of these to destroy
- * @param {Mixed} arg2 (optional)
- * @param {Mixed} etc... (optional)
- */
- destroy : function(){
- Ext.each(arguments, function(arg){
- if(arg){
- if(Ext.isArray(arg)){
- this.destroy.apply(this, arg);
- }else if(typeof arg.destroy == 'function'){
- arg.destroy();
- }else if(arg.dom){
- arg.remove();
- }
- }
- }, this);
- },
+ Loader.addOptionalRequires(items);
+ });
- /**
- * Attempts to destroy and then remove a set of named properties of the passed object.
- * @param {Object} o The object (most likely a Component) who's properties you wish to destroy.
- * @param {Mixed} arg1 The name of the property to destroy and remove from the object.
- * @param {Mixed} etc... More property names to destroy and remove.
- */
- destroyMembers : function(o, arg1, arg2, etc){
- for(var i = 1, a = arguments, len = a.length; i < len; i++) {
- Ext.destroy(o[a[i]]);
- delete o[a[i]];
- }
- },
+ Manager.setDefaultPostprocessorPosition('uses', 'last');
- /**
- * Creates a copy of the passed Array with falsy values removed.
- * @param {Array/NodeList} arr The Array from which to remove falsy values.
- * @return {Array} The new, compressed Array.
- */
- clean : function(arr){
- var ret = [];
- Ext.each(arr, function(v){
- if(!!v){
- ret.push(v);
- }
- });
- return ret;
- },
+})(Ext.ClassManager, Ext.Class, Ext.Function.flexSetter, Ext.Function.alias);
- /**
- * Creates a copy of the passed Array, filtered to contain only unique values.
- * @param {Array} arr The Array to filter
- * @return {Array} The new Array containing unique values.
- */
- unique : function(arr){
- var ret = [],
- collect = {};
+/**
+ * @class Ext.Error
+ * @private
+ * @extends Error
- Ext.each(arr, function(v) {
- if(!collect[v]){
- ret.push(v);
- }
- collect[v] = true;
- });
- return ret;
- },
+A wrapper class for the native JavaScript Error object that adds a few useful capabilities for handling
+errors in an Ext application. When you use Ext.Error to {@link #raise} an error from within any class that
+uses the Ext 4 class system, the Error class can automatically add the source class and method from which
+the error was raised. It also includes logic to automatically log the eroor to the console, if available,
+with additional metadata about the error. In all cases, the error will always be thrown at the end so that
+execution will halt.
- /**
- * Recursively flattens into 1-d Array. Injects Arrays inline.
- * @param {Array} arr The array to flatten
- * @return {Array} The new, flattened array.
- */
- flatten : function(arr){
- var worker = [];
- function rFlatten(a) {
- Ext.each(a, function(v) {
- if(Ext.isArray(v)){
- rFlatten(v);
- }else{
- worker.push(v);
- }
+Ext.Error also offers a global error {@link #handle handling} method that can be overridden in order to
+handle application-wide errors in a single spot. You can optionally {@link #ignore} errors altogether,
+although in a real application it's usually a better idea to override the handling function and perform
+logging or some other method of reporting the errors in a way that is meaningful to the application.
+
+At its simplest you can simply raise an error as a simple string from within any code:
+
+#Example usage:#
+
+ Ext.Error.raise('Something bad happened!');
+
+If raised from plain JavaScript code, the error will be logged to the console (if available) and the message
+displayed. In most cases however you'll be raising errors from within a class, and it may often be useful to add
+additional metadata about the error being raised. The {@link #raise} method can also take a config object.
+In this form the `msg` attribute becomes the error description, and any other data added to the config gets
+added to the error object and, if the console is available, logged to the console for inspection.
+
+#Example usage:#
+
+ Ext.define('Ext.Foo', {
+ doSomething: function(option){
+ if (someCondition === false) {
+ Ext.Error.raise({
+ msg: 'You cannot do that!',
+ option: option, // whatever was passed into the method
+ 'error code': 100 // other arbitrary info
});
- return worker;
}
- return rFlatten(arr);
- },
+ }
+ });
- /**
- * Returns the minimum value in the Array.
- * @param {Array|NodeList} arr The Array from which to select the minimum value.
- * @param {Function} comp (optional) a function to perform the comparision which determines minimization.
- * If omitted the "<" operator will be used. Note: gt = 1; eq = 0; lt = -1
- * @return {Object} The minimum value in the Array.
- */
- min : function(arr, comp){
- var ret = arr[0];
- comp = comp || function(a,b){ return a < b ? -1 : 1; };
- Ext.each(arr, function(v) {
- ret = comp(ret, v) == -1 ? ret : v;
- });
- return ret;
- },
+If a console is available (that supports the `console.dir` function) you'll see console output like:
- /**
- * Returns the maximum value in the Array
- * @param {Array|NodeList} arr The Array from which to select the maximum value.
- * @param {Function} comp (optional) a function to perform the comparision which determines maximization.
- * If omitted the ">" operator will be used. Note: gt = 1; eq = 0; lt = -1
- * @return {Object} The maximum value in the Array.
- */
- max : function(arr, comp){
- var ret = arr[0];
- comp = comp || function(a,b){ return a > b ? 1 : -1; };
- Ext.each(arr, function(v) {
- ret = comp(ret, v) == 1 ? ret : v;
- });
- return ret;
- },
+ An error was raised with the following data:
+ option: Object { foo: "bar"}
+ foo: "bar"
+ error code: 100
+ msg: "You cannot do that!"
+ sourceClass: "Ext.Foo"
+ sourceMethod: "doSomething"
- /**
- * Calculates the mean of the Array
- * @param {Array} arr The Array to calculate the mean value of.
- * @return {Number} The mean.
- */
- mean : function(arr){
- return arr.length > 0 ? Ext.sum(arr) / arr.length : undefined;
- },
+ uncaught exception: You cannot do that!
- /**
- * Calculates the sum of the Array
- * @param {Array} arr The Array to calculate the sum value of.
- * @return {Number} The sum.
- */
- sum : function(arr){
- var ret = 0;
- Ext.each(arr, function(v) {
- ret += v;
- });
- return ret;
- },
+As you can see, the error will report exactly where it was raised and will include as much information as the
+raising code can usefully provide.
- /**
- * Partitions the set into two sets: a true set and a false set.
- * Example:
- * Example2:
- *
-// Example 1:
-Ext.partition([true, false, true, true, false]); // [[true, true, true], [false, false]]
+If you want to handle all application errors globally you can simply override the static {@link #handle} method
+and provide whatever handling logic you need. If the method returns true then the error is considered handled
+and will not be thrown to the browser. If anything but true is returned then the error will be thrown normally.
-// Example 2:
-Ext.partition(
- Ext.query("p"),
- function(val){
- return val.className == "class1"
+#Example usage:#
+
+ Ext.Error.handle = function(err) {
+ if (err.someProperty == 'NotReallyAnError') {
+ // maybe log something to the application here if applicable
+ return true;
+ }
+ // any non-true return value (including none) will cause the error to be thrown
}
-);
-// true are those paragraph elements with a className of "class1",
-// false set are those that do not have that className.
- *
- * @param {Array|NodeList} arr The array to partition
- * @param {Function} truth (optional) a function to determine truth. If this is omitted the element
- * itself must be able to be evaluated for its truthfulness.
- * @return {Array} [true,false]
- */
- partition : function(arr, truth){
- var ret = [[],[]];
- Ext.each(arr, function(v, i, a) {
- ret[ (truth && truth(v, i, a)) || (!truth && v) ? 0 : 1].push(v);
- });
- return ret;
- },
+ * Create a new Error object
+ * @param {Object} config The config object
+ * @markdown
+ * @author Brian Moeskau
+ * @docauthor Brian Moeskau
+ */
+Ext.Error = Ext.extend(Error, {
+ statics: {
/**
- * Invokes a method on each item in an Array.
- *
- * @param {Array|NodeList} arr The Array of items to invoke the method on.
- * @param {String} methodName The method name to invoke.
- * @param {...*} args Arguments to send into the method invocation.
- * @return {Array} The results of invoking the method on each item in the array.
+ * @property ignore
+Static flag that can be used to globally disable error reporting to the browser if set to true
+(defaults to false). Note that if you ignore Ext errors it's likely that some other code may fail
+and throw a native JavaScript error thereafter, so use with caution. In most cases it will probably
+be preferable to supply a custom error {@link #handle handling} function instead.
+
+#Example usage:#
+
+ Ext.Error.ignore = true;
+
+ * @markdown
+ * @static
*/
- invoke : function(arr, methodName){
- var ret = [],
- args = Array.prototype.slice.call(arguments, 2);
- Ext.each(arr, function(v,i) {
- if (v && typeof v[methodName] == 'function') {
- ret.push(v[methodName].apply(v, args));
- } else {
- ret.push(undefined);
- }
- });
- return ret;
- },
+ ignore: false,
/**
- * Plucks the value of a property from each item in the Array
- *
- * @param {Array|NodeList} arr The Array of items to pluck the value from.
- * @param {String} prop The property name to pluck from each element.
- * @return {Array} The value from each item in the Array.
+ * @property notify
+Static flag that can be used to globally control error notification to the user. Unlike
+Ex.Error.ignore, this does not effect exceptions. They are still thrown. This value can be
+set to false to disable the alert notification (default is true for IE6 and IE7).
+
+Only the first error will generate an alert. Internally this flag is set to false when the
+first error occurs prior to displaying the alert.
+
+This flag is not used in a release build.
+
+#Example usage:#
+
+ Ext.Error.notify = false;
+
+ * @markdown
+ * @static
*/
- pluck : function(arr, prop){
- var ret = [];
- Ext.each(arr, function(v) {
- ret.push( v[prop] );
- });
- return ret;
- },
+ //notify: Ext.isIE6 || Ext.isIE7,
/**
- *
- * @param {Arrays|NodeLists} arr This argument may be repeated. Array(s) to contribute values.
- * @param {Function} zipper (optional) The last item in the argument list. This will drive how the items are zipped together.
- * @return {Array} The zipped set.
- */
- zip : function(){
- var parts = Ext.partition(arguments, function( val ){ return typeof val != 'function'; }),
- arrs = parts[0],
- fn = parts[1][0],
- len = Ext.max(Ext.pluck(arrs, "length")),
- ret = [];
+Raise an error that can include additional data and supports automatic console logging if available.
+You can pass a string error message or an object with the `msg` attribute which will be used as the
+error message. The object can contain any other name-value attributes (or objects) to be logged
+along with the error.
- for (var i = 0; i < len; i++) {
- ret[i] = [];
- if(fn){
- ret[i] = fn.apply(fn, Ext.pluck(arrs, i));
- }else{
- for (var j = 0, aLen = arrs.length; j < aLen; j++){
- ret[i].push( arrs[j][i] );
- }
- }
- }
- return ret;
- },
+Note that after displaying the error message a JavaScript error will ultimately be thrown so that
+execution will halt.
- /**
- * This is shorthand reference to {@link Ext.ComponentMgr#get}.
- * Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}
- * @param {String} id The component {@link Ext.Component#id id}
- * @return Ext.Component The Component, undefined if not found, or null if a
- * Class was found.
- */
- getCmp : function(id){
- return Ext.ComponentMgr.get(id);
- },
+#Example usage:#
- /**
- * By default, Ext intelligently decides whether floating elements should be shimmed. If you are using flash,
- * you may want to set this to true.
- * @type Boolean
- */
- useShims: E.isIE6 || (E.isMac && E.isGecko2),
-
- // inpired by a similar function in mootools library
- /**
- * Returns the type of object that is passed in. If the object passed in is null or undefined it
- * return false otherwise it returns one of the following values:
- *
string: If the object passed is a string
- *
number: If the object passed is a number
- *
boolean: If the object passed is a boolean value
- *
date: If the object passed is a Date object
- *
function: If the object passed is a function reference
- *
object: If the object passed is an object
- *
array: If the object passed is an array
- *
regexp: If the object passed is a regular expression
- *
element: If the object passed is a DOM Element
- *
nodelist: If the object passed is a DOM NodeList
- *
textnode: If the object passed is a DOM text node and contains something other than whitespace
- *
whitespace: If the object passed is a DOM text node and contains only whitespace
- *
- * @param {Mixed} object
- * @return {String}
- */
- type : function(o){
- if(o === undefined || o === null){
- return false;
- }
- if(o.htmlElement){
- return 'element';
+ Ext.Error.raise('A simple string error message');
+
+ // or...
+
+ Ext.define('Ext.Foo', {
+ doSomething: function(option){
+ if (someCondition === false) {
+ Ext.Error.raise({
+ msg: 'You cannot do that!',
+ option: option, // whatever was passed into the method
+ 'error code': 100 // other arbitrary info
+ });
}
- var t = typeof o;
- if(t == 'object' && o.nodeName) {
- switch(o.nodeType) {
- case 1: return 'element';
- case 3: return (/\S/).test(o.nodeValue) ? 'textnode' : 'whitespace';
- }
+ }
+ });
+ * @param {String/Object} err The error message string, or an object containing the
+ * attribute "msg" that will be used as the error message. Any other data included in
+ * the object will also be logged to the browser console, if available.
+ * @static
+ * @markdown
+ */
+ raise: function(err){
+ err = err || {};
+ if (Ext.isString(err)) {
+ err = { msg: err };
}
- if(t == 'object' || t == 'function') {
- switch(o.constructor) {
- case Array: return 'array';
- case RegExp: return 'regexp';
- case Date: return 'date';
+
+ var method = this.raise.caller;
+
+ if (method) {
+ if (method.$name) {
+ err.sourceMethod = method.$name;
}
- if(typeof o.length == 'number' && typeof o.item == 'function') {
- return 'nodelist';
+ if (method.$owner) {
+ err.sourceClass = method.$owner.$className;
}
}
- return t;
- },
- intercept : function(o, name, fn, scope){
- o[name] = o[name].createInterceptor(fn, scope);
- },
+ if (Ext.Error.handle(err) !== true) {
+ var msg = Ext.Error.prototype.toString.call(err);
- // internal
- callback : function(cb, scope, args, delay){
- if(typeof cb == 'function'){
- if(delay){
- cb.defer(delay, scope, args || []);
- }else{
- cb.apply(scope, args || []);
- }
- }
- }
- };
-}());
+ Ext.log({
+ msg: msg,
+ level: 'error',
+ dump: err,
+ stack: true
+ });
-/**
- * @class Function
- * These functions are available on every Function object (any JavaScript function).
- */
-Ext.apply(Function.prototype, {
- /**
- * Create a combined function call sequence of the original function + the passed function.
- * The resulting function returns the results of the original function.
- * The passed fcn is called with the parameters of the original function. Example usage:
- *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
+ throw new Ext.Error(err);
+ }
+ },
-sayHi('Fred'); // alerts "Hi, Fred"
+ /**
+Globally handle any Ext errors that may be raised, optionally providing custom logic to
+handle different errors individually. Return true from the function to bypass throwing the
+error to the browser, otherwise the error will be thrown and execution will halt.
-var sayGoodbye = sayHi.createSequence(function(name){
- alert('Bye, ' + name);
-});
+#Example usage:#
-sayGoodbye('Fred'); // both alerts show
-
- * @param {Function} fcn The function to sequence
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- */
- createSequence : function(fcn, scope){
- var method = this;
- return (typeof fcn != 'function') ?
- this :
- function(){
- var retval = method.apply(this || window, arguments);
- fcn.apply(scope || this || window, arguments);
- return retval;
- };
+ Ext.Error.handle = function(err) {
+ if (err.someProperty == 'NotReallyAnError') {
+ // maybe log something to the application here if applicable
+ return true;
+ }
+ // any non-true return value (including none) will cause the error to be thrown
}
-});
+ * @param {Ext.Error} err The Ext.Error object being raised. It will contain any attributes
+ * that were originally raised with it, plus properties about the method and class from which
+ * the error originated (if raised from a class that uses the Ext 4 class system).
+ * @static
+ * @markdown
+ */
+ handle: function(){
+ return Ext.Error.ignore;
+ }
+ },
-/**
- * @class String
- * These functions are available as static methods on the JavaScript String object.
- */
-Ext.applyIf(String, {
+ // This is the standard property that is the name of the constructor.
+ name: 'Ext.Error',
/**
- * Escapes the passed string for ' and \
- * @param {String} string The string to escape
- * @return {String} The escaped string
- * @static
+ * @param {String/Object} config The error message string, or an object containing the
+ * attribute "msg" that will be used as the error message. Any other data included in
+ * the object will be applied to the error instance and logged to the browser console, if available.
*/
- escape : function(string) {
- return string.replace(/('|\\)/g, "\\$1");
+ constructor: function(config){
+ if (Ext.isString(config)) {
+ config = { msg: config };
+ }
+
+ var me = this;
+
+ Ext.apply(me, config);
+
+ me.message = me.message || me.msg; // 'message' is standard ('msg' is non-standard)
+ // note: the above does not work in old WebKit (me.message is readonly) (Safari 4)
},
/**
- * Pads the left side of a string with a specified character. This is especially useful
- * for normalizing number and date strings. Example usage:
- *
-var s = String.leftPad('123', 5, '0');
-// s now contains the string: '00123'
- *
- * @param {String} string The original string
- * @param {Number} size The total length of the output string
- * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ")
- * @return {String} The padded string
- * @static
+Provides a custom string representation of the error object. This is an override of the base JavaScript
+`Object.toString` method, which is useful so that when logged to the browser console, an error object will
+be displayed with a useful message instead of `[object Object]`, the default `toString` result.
+
+The default implementation will include the error message along with the raising class and method, if available,
+but this can be overridden with a custom implementation either at the prototype level (for all errors) or on
+a particular error instance, if you want to provide a custom description that will show up in the console.
+ * @markdown
+ * @return {String} The error message. If raised from within the Ext 4 class system, the error message
+ * will also include the raising class and method names, if available.
*/
- leftPad : function (val, size, ch) {
- var result = String(val);
- if(!ch) {
- ch = " ";
- }
- while (result.length < size) {
- result = ch + result;
- }
- return result;
+ toString: function(){
+ var me = this,
+ className = me.className ? me.className : '',
+ methodName = me.methodName ? '.' + me.methodName + '(): ' : '',
+ msg = me.msg || '(No description provided)';
+
+ return className + methodName + msg;
}
});
-/**
- * Utility function that allows you to easily switch a string between two alternating values. The passed value
- * is compared to the current string, and if they are equal, the other value that was passed in is returned. If
- * they are already different, the first value passed in is returned. Note that this method returns the new value
- * but does not change the current string.
- *
- * @param {String} value The value to compare to the current string
- * @param {String} other The new value to use if the string already equals the first value passed in
- * @return {String} The new value
+/*
+ * This mechanism is used to notify the user of the first error encountered on the page. This
+ * was previously internal to Ext.Error.raise and is a desirable feature since errors often
+ * slip silently under the radar. It cannot live in Ext.Error.raise since there are times
+ * where exceptions are handled in a try/catch.
*/
-String.prototype.toggle = function(value, other){
- return this == value ? other : value;
-};
-/**
- * Trims whitespace from either end of a string, leaving spaces within the string intact. Example:
- *
-var s = ' foo bar ';
-alert('-' + s + '-'); //alerts "- foo bar -"
-alert('-' + s.trim() + '-'); //alerts "-foo bar-"
-
- * @return {String} The trimmed string
- */
-String.prototype.trim = function(){
- var re = /^\s+|\s+$/g;
- return function(){ return this.replace(re, ""); };
-}();
-
-// here to prevent dependency on Date.js
-/**
- Returns the number of milliseconds between this date and date
- @param {Date} date (optional) Defaults to now
- @return {Number} The diff in milliseconds
- @member Date getElapsed
- */
-Date.prototype.getElapsed = function(date) {
- return Math.abs((date || new Date()).getTime()-this.getTime());
-};
-/**
- * @class Number
- */
-Ext.applyIf(Number.prototype, {
- /**
- * Checks whether or not the current number is within a desired range. If the number is already within the
- * range it is returned, otherwise the min or max value is returned depending on which side of the range is
- * exceeded. Note that this method returns the constrained value but does not change the current number.
- * @param {Number} min The minimum number in the range
- * @param {Number} max The maximum number in the range
- * @return {Number} The constrained value if outside the range, otherwise the current value
- */
- constrain : function(min, max){
- return Math.min(Math.max(this, min), max);
- }
-});
-Ext.lib.Dom.getRegion = function(el) {
- return Ext.lib.Region.getRegion(el);
-}; Ext.lib.Region = function(t, r, b, l) {
- var me = this;
- me.top = t;
- me[1] = t;
- me.right = r;
- me.bottom = b;
- me.left = l;
- me[0] = l;
- };
+/*
- Ext.lib.Region.prototype = {
- contains : function(region) {
- var me = this;
- return ( region.left >= me.left &&
- region.right <= me.right &&
- region.top >= me.top &&
- region.bottom <= me.bottom );
+This file is part of Ext JS 4
- },
+Copyright (c) 2011 Sencha Inc
- getArea : function() {
- var me = this;
- return ( (me.bottom - me.top) * (me.right - me.left) );
- },
+Contact: http://www.sencha.com/contact
- intersect : function(region) {
- var me = this,
- t = Math.max(me.top, region.top),
- r = Math.min(me.right, region.right),
- b = Math.min(me.bottom, region.bottom),
- l = Math.max(me.left, region.left);
+GNU General Public License Usage
+This file may be used under the terms of the GNU General Public License version 3.0 as published by the Free Software Foundation and appearing in the file LICENSE included in the packaging of this file. Please review the following information to ensure the GNU General Public License version 3.0 requirements will be met: http://www.gnu.org/copyleft/gpl.html.
- if (b >= t && r >= l) {
- return new Ext.lib.Region(t, r, b, l);
- }
- },
-
- union : function(region) {
- var me = this,
- t = Math.min(me.top, region.top),
- r = Math.max(me.right, region.right),
- b = Math.max(me.bottom, region.bottom),
- l = Math.min(me.left, region.left);
+If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact.
- return new Ext.lib.Region(t, r, b, l);
- },
+*/
+/**
+ * @class Ext.JSON
+ * Modified version of Douglas Crockford"s json.js that doesn"t
+ * mess with the Object prototype
+ * http://www.json.org/js.html
+ * @singleton
+ */
+Ext.JSON = new(function() {
+ var useHasOwn = !! {}.hasOwnProperty,
+ isNative = function() {
+ var useNative = null;
- constrainTo : function(r) {
- var me = this;
- me.top = me.top.constrain(r.top, r.bottom);
- me.bottom = me.bottom.constrain(r.top, r.bottom);
- me.left = me.left.constrain(r.left, r.right);
- me.right = me.right.constrain(r.left, r.right);
- return me;
- },
+ return function() {
+ if (useNative === null) {
+ useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
+ }
- adjust : function(t, l, b, r) {
- var me = this;
- me.top += t;
- me.left += l;
- me.right += r;
- me.bottom += b;
- return me;
+ return useNative;
+ };
+ }(),
+ pad = function(n) {
+ return n < 10 ? "0" + n : n;
+ },
+ doDecode = function(json) {
+ return eval("(" + json + ')');
+ },
+ doEncode = function(o) {
+ if (!Ext.isDefined(o) || o === null) {
+ return "null";
+ } else if (Ext.isArray(o)) {
+ return encodeArray(o);
+ } else if (Ext.isDate(o)) {
+ return Ext.JSON.encodeDate(o);
+ } else if (Ext.isString(o)) {
+ return encodeString(o);
+ } else if (typeof o == "number") {
+ //don't use isNumber here, since finite checks happen inside isNumber
+ return isFinite(o) ? String(o) : "null";
+ } else if (Ext.isBoolean(o)) {
+ return String(o);
+ } else if (Ext.isObject(o)) {
+ return encodeObject(o);
+ } else if (typeof o === "function") {
+ return "null";
+ }
+ return 'undefined';
+ },
+ m = {
+ "\b": '\\b',
+ "\t": '\\t',
+ "\n": '\\n',
+ "\f": '\\f',
+ "\r": '\\r',
+ '"': '\\"',
+ "\\": '\\\\',
+ '\x0b': '\\u000b' //ie doesn't handle \v
+ },
+ charToReplace = /[\\\"\x00-\x1f\x7f-\uffff]/g,
+ encodeString = function(s) {
+ return '"' + s.replace(charToReplace, function(a) {
+ var c = m[a];
+ return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"';
+ },
+ encodeArray = function(o) {
+ var a = ["[", ""],
+ // Note empty string in case there are no serializable members.
+ len = o.length,
+ i;
+ for (i = 0; i < len; i += 1) {
+ a.push(doEncode(o[i]), ',');
}
- };
-
- Ext.lib.Region.getRegion = function(el) {
- var p = Ext.lib.Dom.getXY(el),
- t = p[1],
- r = p[0] + el.offsetWidth,
- b = p[1] + el.offsetHeight,
- l = p[0];
-
- return new Ext.lib.Region(t, r, b, l);
- }; Ext.lib.Point = function(x, y) {
- if (Ext.isArray(x)) {
- y = x[1];
- x = x[0];
+ // Overwrite trailing comma (or empty string)
+ a[a.length - 1] = ']';
+ return a.join("");
+ },
+ encodeObject = function(o) {
+ var a = ["{", ""],
+ // Note empty string in case there are no serializable members.
+ i;
+ for (i in o) {
+ if (!useHasOwn || o.hasOwnProperty(i)) {
+ a.push(doEncode(i), ":", doEncode(o[i]), ',');
+ }
}
- var me = this;
- me.x = me.right = me.left = me[0] = x;
- me.y = me.top = me.bottom = me[1] = y;
+ // Overwrite trailing comma (or empty string)
+ a[a.length - 1] = '}';
+ return a.join("");
};
- Ext.lib.Point.prototype = new Ext.lib.Region();
-/**
- * @class Ext.DomHelper
- */
-Ext.apply(Ext.DomHelper,
-function(){
- var pub,
- afterbegin = 'afterbegin',
- afterend = 'afterend',
- beforebegin = 'beforebegin',
- beforeend = 'beforeend',
- confRe = /tag|children|cn|html$/i;
+ /**
+ *
Encodes a Date. This returns the actual string which is inserted into the JSON string as the literal expression.
+ * The returned value includes enclosing double quotation marks.
+ *
The default return format is "yyyy-mm-ddThh:mm:ss".
+ * @param {Date} d The Date to encode
+ * @return {String} The string literal to use in a JSON string.
+ */
+ this.encodeDate = function(o) {
+ return '"' + o.getFullYear() + "-"
+ + pad(o.getMonth() + 1) + "-"
+ + pad(o.getDate()) + "T"
+ + pad(o.getHours()) + ":"
+ + pad(o.getMinutes()) + ":"
+ + pad(o.getSeconds()) + '"';
+ };
- // private
- function doInsert(el, o, returnElement, pos, sibling, append){
- el = Ext.getDom(el);
- var newNode;
- if (pub.useDom) {
- newNode = createDom(o, null);
- if (append) {
- el.appendChild(newNode);
- } else {
- (sibling == 'firstChild' ? el : el.parentNode).insertBefore(newNode, el[sibling] || el);
+ /**
+ * Encodes an Object, Array or other value
+ * @param {Mixed} o The variable to encode
+ * @return {String} The JSON string
+ */
+ this.encode = function() {
+ var ec;
+ return function(o) {
+ if (!ec) {
+ // setup encoding function on first access
+ ec = isNative() ? JSON.stringify : doEncode;
}
- } else {
- newNode = Ext.DomHelper.insertHtml(pos, el, Ext.DomHelper.createHtml(o));
- }
- return returnElement ? Ext.get(newNode, true) : newNode;
- }
+ return ec(o);
+ };
+ }();
- // build as dom
- /** @ignore */
- function createDom(o, parentNode){
- var el,
- doc = document,
- useSet,
- attr,
- val,
- cn;
- if (Ext.isArray(o)) { // Allow Arrays of siblings to be inserted
- el = doc.createDocumentFragment(); // in one shot using a DocumentFragment
- for (var i = 0, l = o.length; i < l; i++) {
- createDom(o[i], el);
+ /**
+ * Decodes (parses) a JSON string to an object. If the JSON is invalid, this function throws a SyntaxError unless the safe option is set.
+ * @param {String} json The JSON string
+ * @param {Boolean} safe (optional) Whether to return null or throw an exception if the JSON is invalid.
+ * @return {Object} The resulting object
+ */
+ this.decode = function() {
+ var dc;
+ return function(json, safe) {
+ if (!dc) {
+ // setup decoding function on first access
+ dc = isNative() ? JSON.parse : doDecode;
}
- } else if (typeof o == 'string') { // Allow a string as a child spec.
- el = doc.createTextNode(o);
- } else {
- el = doc.createElement( o.tag || 'div' );
- useSet = !!el.setAttribute; // In IE some elements don't have setAttribute
- for (var attr in o) {
- if(!confRe.test(attr)){
- val = o[attr];
- if(attr == 'cls'){
- el.className = val;
- }else{
- if(useSet){
- el.setAttribute(attr, val);
- }else{
- el[attr] = val;
- }
- }
+ try {
+ return dc(json);
+ } catch (e) {
+ if (safe === true) {
+ return null;
}
+ Ext.Error.raise({
+ sourceClass: "Ext.JSON",
+ sourceMethod: "decode",
+ msg: "You're trying to decode an invalid JSON String: " + json
+ });
}
- Ext.DomHelper.applyStyles(el, o.style);
+ };
+ }();
- if ((cn = o.children || o.cn)) {
- createDom(cn, el);
- } else if (o.html) {
- el.innerHTML = o.html;
- }
- }
- if(parentNode){
- parentNode.appendChild(el);
- }
- return el;
- }
+})();
+/**
+ * Shorthand for {@link Ext.JSON#encode}
+ * @param {Mixed} o The variable to encode
+ * @return {String} The JSON string
+ * @member Ext
+ * @method encode
+ */
+Ext.encode = Ext.JSON.encode;
+/**
+ * Shorthand for {@link Ext.JSON#decode}
+ * @param {String} json The JSON string
+ * @param {Boolean} safe (optional) Whether to return null or throw an exception if the JSON is invalid.
+ * @return {Object} The resulting object
+ * @member Ext
+ * @method decode
+ */
+Ext.decode = Ext.JSON.decode;
- pub = {
- /**
- * Creates a new Ext.Template from the DOM object spec.
- * @param {Object} o The DOM object spec (and children)
- * @return {Ext.Template} The new template
- */
- createTemplate : function(o){
- var html = Ext.DomHelper.createHtml(o);
- return new Ext.Template(html);
- },
- /** True to force the use of DOM instead of html fragments @type Boolean */
- useDom : false,
+/**
+ * @class Ext
- /**
- * Creates new DOM element(s) and inserts them before el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
- * @hide (repeat)
- */
- insertBefore : function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforebegin);
- },
+ The Ext namespace (global object) encapsulates all classes, singletons, and utility methods provided by Sencha's libraries.
+ Most user interface Components are at a lower level of nesting in the namespace, but many common utility functions are provided
+ as direct properties of the Ext namespace.
- /**
- * Creates new DOM element(s) and inserts them after el.
- * @param {Mixed} el The context element
- * @param {Object} o The DOM object spec (and children)
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
- * @hide (repeat)
- */
- insertAfter : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterend, 'nextSibling');
- },
+ Also many frequently used methods from other classes are provided as shortcuts within the Ext namespace.
+ For example {@link Ext#getCmp Ext.getCmp} aliases {@link Ext.ComponentManager#get Ext.ComponentManager.get}.
- /**
- * Creates new DOM element(s) and inserts them as the first child of el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
- * @hide (repeat)
- */
- insertFirst : function(el, o, returnElement){
- return doInsert(el, o, returnElement, afterbegin, 'firstChild');
- },
+ Many applications are initiated with {@link Ext#onReady Ext.onReady} which is called once the DOM is ready.
+ This ensures all scripts have been loaded, preventing dependency issues. For example
- /**
- * Creates new DOM element(s) and appends them to el.
- * @param {Mixed} el The context element
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @param {Boolean} returnElement (optional) true to return a Ext.Element
- * @return {HTMLElement/Ext.Element} The new node
- * @hide (repeat)
- */
- append: function(el, o, returnElement){
- return doInsert(el, o, returnElement, beforeend, '', true);
- },
+ Ext.onReady(function(){
+ new Ext.Component({
+ renderTo: document.body,
+ html: 'DOM ready!'
+ });
+ });
- /**
- * Creates new DOM element(s) without inserting them to the document.
- * @param {Object/String} o The DOM object spec (and children) or raw HTML blob
- * @return {HTMLElement} The new uninserted node
- */
- createDom: createDom
- };
- return pub;
-}());
-/**
- * @class Ext.Template
+For more information about how to use the Ext classes, see
+
+- The Learning Center
+- The FAQ
+- The forums
+
+ * @singleton
+ * @markdown
*/
-Ext.apply(Ext.Template.prototype, {
+Ext.apply(Ext, {
+ userAgent: navigator.userAgent.toLowerCase(),
+ cache: {},
+ idSeed: 1000,
+ BLANK_IMAGE_URL : 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
+ isStrict: document.compatMode == "CSS1Compat",
+ windowId: 'ext-window',
+ documentId: 'ext-document',
+
/**
- * @cfg {Boolean} disableFormats Specify true to disable format
- * functions in the template. If the template does not contain
- * {@link Ext.util.Format format functions}, setting disableFormats
- * to true will reduce {@link #apply} time. Defaults to false.
- *
-var t = new Ext.Template(
- '<div name="{id}">',
- '<span class="{cls}">{name} {value}</span>',
- '</div>',
- {
- compiled: true, // {@link #compile} immediately
- disableFormats: true // reduce {@link #apply} time since no formatting
- }
-);
- *
- * For a list of available format functions, see {@link Ext.util.Format}.
+ * True when the document is fully initialized and ready for action
+ * @type Boolean
*/
- disableFormats : false,
+ isReady: false,
+
/**
- * See {@link #disableFormats}.
+ * True to automatically uncache orphaned Ext.core.Elements periodically (defaults to true)
* @type Boolean
- * @property disableFormats
*/
+ enableGarbageCollector: true,
/**
- * The regular expression used to match template variables
- * @type RegExp
- * @property
- * @hide repeat doc
+ * True to automatically purge event listeners during garbageCollection (defaults to true).
+ * @type Boolean
*/
- re : /\{([\w-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g,
- argsRe : /^\s*['"](.*)["']\s*$/,
- compileARe : /\\/g,
- compileBRe : /(\r\n|\n)/g,
- compileCRe : /'/g,
+ enableListenerCollection: true,
/**
- * 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
- * @hide repeat doc
+ * Generates unique ids. If the element already has an id, it is unchanged
+ * @param {Mixed} el (optional) The element to generate an id for
+ * @param {String} prefix (optional) Id prefix (defaults "ext-gen")
+ * @return {String} The generated Id.
*/
- applyTemplate : function(values){
+ id: function(el, prefix) {
var me = this,
- useF = me.disableFormats !== true,
- fm = Ext.util.Format,
- tpl = me;
-
- if(me.compiled){
- return me.compiled(values);
+ sandboxPrefix = '';
+ el = Ext.getDom(el, true) || {};
+ if (el === document) {
+ el.id = me.documentId;
}
- function fn(m, name, format, args){
- if (format && useF) {
- if (format.substr(0, 5) == "this.") {
- return tpl.call(format.substr(5), values[name], values);
- } else {
- if (args) {
- // quoted values are required for strings in compiled templates,
- // but for non compiled we need to strip them
- // quoted reversed for jsmin
- var re = me.argsRe;
- args = args.split(',');
- for(var i = 0, len = args.length; i < len; i++){
- args[i] = args[i].replace(re, "$1");
- }
- args = [values[name]].concat(args);
- } else {
- args = [values[name]];
- }
- return fm[format].apply(fm, args);
+ else if (el === window) {
+ el.id = me.windowId;
+ }
+ if (!el.id) {
+ if (me.isSandboxed) {
+ if (!me.uniqueGlobalNamespace) {
+ me.getUniqueGlobalNamespace();
}
- } else {
- return values[name] !== undefined ? values[name] : "";
+ sandboxPrefix = me.uniqueGlobalNamespace + '-';
}
+ el.id = sandboxPrefix + (prefix || "ext-gen") + (++Ext.idSeed);
}
- return me.html.replace(me.re, fn);
+ return el.id;
},
/**
- * Compiles the template into an internal function, eliminating the RegEx overhead.
- * @return {Ext.Template} this
- * @hide repeat doc
+ * Returns the current document body as an {@link Ext.core.Element}.
+ * @return Ext.core.Element The document body
*/
- compile : function(){
- var me = this,
- fm = Ext.util.Format,
- useF = me.disableFormats !== true,
- sep = Ext.isGecko ? "+" : ",",
- body;
-
- function fn(m, name, format, args){
- if(format && useF){
- args = args ? ',' + args : "";
- if(format.substr(0, 5) != "this."){
- format = "fm." + format + '(';
- }else{
- format = 'this.call("'+ format.substr(5) + '", ';
- args = ", values";
- }
- }else{
- args= ''; format = "(values['" + name + "'] == undefined ? '' : ";
- }
- return "'"+ sep + format + "values['" + name + "']" + args + ")"+sep+"'";
- }
-
- // branched to use + in gecko and [].join() in others
- if(Ext.isGecko){
- body = "this.compiled = function(values){ return '" +
- me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn) +
- "';};";
- }else{
- body = ["this.compiled = function(values){ return ['"];
- body.push(me.html.replace(me.compileARe, '\\\\').replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn));
- body.push("'].join('');};");
- body = body.join('');
- }
- eval(body);
- return me;
+ getBody: function() {
+ return Ext.get(document.body || false);
},
- // private function used to call members
- call : function(fnName, value, allValues){
- return this[fnName](value, allValues);
- }
-});
-Ext.Template.prototype.apply = Ext.Template.prototype.applyTemplate;
-/**
- * @class Ext.util.Functions
- * @singleton
- */
-Ext.util.Functions = {
/**
- * Creates an interceptor function. The passed function is called before the original one. If it returns false,
- * the original one is not called. The resulting function returns the results of the original function.
- * The passed function is called with the parameters of the original function. Example usage:
- *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
+ * Returns the current document head as an {@link Ext.core.Element}.
+ * @return Ext.core.Element The document head
+ * @method
+ */
+ getHead: function() {
+ var head;
-sayHi('Fred'); // alerts "Hi, Fred"
+ return function() {
+ if (head == undefined) {
+ head = Ext.get(document.getElementsByTagName("head")[0]);
+ }
-// create a new function that validates input without
-// directly modifying the original function:
-var sayHiToFriend = Ext.createInterceptor(sayHi, function(name){
- return name == 'Brian';
-});
+ return head;
+ };
+ }(),
-sayHiToFriend('Fred'); // no alert
-sayHiToFriend('Brian'); // alerts "Hi, Brian"
-
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to call before the original
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
+ /**
+ * Returns the current HTML document object as an {@link Ext.core.Element}.
+ * @return Ext.core.Element The document
*/
- createInterceptor: function(origFn, newFn, scope) {
- var method = origFn;
- if (!Ext.isFunction(newFn)) {
- return origFn;
- }
- else {
- return function() {
- var me = this,
- args = arguments;
- newFn.target = me;
- newFn.method = origFn;
- return (newFn.apply(scope || me || window, args) !== false) ?
- origFn.apply(me || window, args) :
- null;
- };
- }
+ getDoc: function() {
+ return Ext.get(document);
},
/**
- * Creates a delegate (callback) that sets the scope to obj.
- * Call directly on any function. Example: Ext.createDelegate(this.myFunction, this, [arg1, arg2])
- * Will create a function that is automatically scoped to obj so that the this variable inside the
- * callback points to obj. Example usage:
- *
-var sayHi = function(name){
- // Note this use of "this.text" here. This function expects to
- // execute within a scope that contains a text property. In this
- // example, the "this" variable is pointing to the btn object that
- // was passed in createDelegate below.
- alert('Hi, ' + name + '. You clicked the "' + this.text + '" button.');
-}
-
-var btn = new Ext.Button({
- text: 'Say Hi',
- renderTo: Ext.getBody()
-});
+ * This is shorthand reference to {@link Ext.ComponentManager#get}.
+ * Looks up an existing {@link Ext.Component Component} by {@link Ext.Component#id id}
+ * @param {String} id The component {@link Ext.Component#id id}
+ * @return Ext.Component The Component, undefined if not found, or null if a
+ * Class was found.
+ */
+ getCmp: function(id) {
+ return Ext.ComponentManager.get(id);
+ },
-// This callback will execute in the scope of the
-// button instance. Clicking the button alerts
-// "Hi, Fred. You clicked the "Say Hi" button."
-btn.on('click', Ext.createDelegate(sayHi, btn, ['Fred']));
-
- * @param {Function} fn The function to delegate.
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Function} The new function
+ /**
+ * Returns the current orientation of the mobile device
+ * @return {String} Either 'portrait' or 'landscape'
*/
- createDelegate: function(fn, obj, args, appendArgs) {
- if (!Ext.isFunction(fn)) {
- return fn;
- }
- return function() {
- var callArgs = args || arguments;
- if (appendArgs === true) {
- callArgs = Array.prototype.slice.call(arguments, 0);
- callArgs = callArgs.concat(args);
- }
- else if (Ext.isNumber(appendArgs)) {
- callArgs = Array.prototype.slice.call(arguments, 0);
- // copy arguments first
- var applyArgs = [appendArgs, 0].concat(args);
- // create method call params
- Array.prototype.splice.apply(callArgs, applyArgs);
- // splice them in
- }
- return fn.apply(obj || window, callArgs);
- };
+ getOrientation: function() {
+ return window.innerHeight > window.innerWidth ? 'portrait' : 'landscape';
},
/**
- * Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage:
- *
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-
-// executes immediately:
-sayHi('Fred');
-
-// executes after 2 seconds:
-Ext.defer(sayHi, 2000, this, ['Fred']);
-
-// this syntax is sometimes useful for deferring
-// execution of an anonymous function:
-Ext.defer(function(){
- alert('Anonymous');
-}, 100);
-
- * @param {Function} fn The function to defer.
- * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Number} The timeout id that can be used with clearTimeout
+ * Attempts to destroy any objects passed to it by removing all event listeners, removing them from the
+ * DOM (if applicable) and calling their destroy functions (if available). This method is primarily
+ * intended for arguments of type {@link Ext.core.Element} and {@link Ext.Component}, but any subclass of
+ * {@link Ext.util.Observable} can be passed in. Any number of elements and/or components can be
+ * passed into this function in a single call as separate arguments.
+ * @param {Mixed} arg1 An {@link Ext.core.Element}, {@link Ext.Component}, or an Array of either of these to destroy
+ * @param {Mixed} arg2 (optional)
+ * @param {Mixed} etc... (optional)
*/
- defer: function(fn, millis, obj, args, appendArgs) {
- fn = Ext.util.Functions.createDelegate(fn, obj, args, appendArgs);
- if (millis > 0) {
- return setTimeout(fn, millis);
+ destroy: function() {
+ var ln = arguments.length,
+ i, arg;
+
+ for (i = 0; i < ln; i++) {
+ arg = arguments[i];
+ if (arg) {
+ if (Ext.isArray(arg)) {
+ this.destroy.apply(this, arg);
+ }
+ else if (Ext.isFunction(arg.destroy)) {
+ arg.destroy();
+ }
+ else if (arg.dom) {
+ arg.remove();
+ }
+ }
}
- fn();
- return 0;
},
-
/**
- * Create a combined function call sequence of the original function + the passed function.
- * The resulting function returns the results of the original function.
- * The passed fcn is called with the parameters of the original function. Example usage:
+ * Execute a callback function in a particular scope. If no function is passed the call is ignored.
*
+ * For example, these lines are equivalent:
+ *
+ * Ext.callback(myFunc, this, [arg1, arg2]);
+ * Ext.isFunction(myFunc) && myFunc.apply(this, [arg1, arg2]);
+ *
+ * @param {Function} callback The callback to execute
+ * @param {Object} scope (optional) The scope to execute in
+ * @param {Array} args (optional) The arguments to pass to the function
+ * @param {Number} delay (optional) Pass a number to delay the call by a number of milliseconds.
+ */
+ callback: function(callback, scope, args, delay){
+ if(Ext.isFunction(callback)){
+ args = args || [];
+ scope = scope || window;
+ if (delay) {
+ Ext.defer(callback, delay, scope, args);
+ } else {
+ callback.apply(scope, args);
+ }
+ }
+ },
-var sayHi = function(name){
- alert('Hi, ' + name);
-}
-
-sayHi('Fred'); // alerts "Hi, Fred"
-
-var sayGoodbye = Ext.createSequence(sayHi, function(name){
- alert('Bye, ' + name);
-});
+ /**
+ * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
+ * @param {String} value The string to encode
+ * @return {String} The encoded text
+ */
+ htmlEncode : function(value) {
+ return Ext.String.htmlEncode(value);
+ },
-sayGoodbye('Fred'); // both alerts show
+ /**
+ * Convert certain characters (&, <, >, and ') from their HTML character equivalents.
+ * @param {String} value The string to decode
+ * @return {String} The decoded text
+ */
+ htmlDecode : function(value) {
+ return Ext.String.htmlDecode(value);
+ },
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to sequence
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
+ /**
+ * Appends content to the query string of a URL, handling logic for whether to place
+ * a question mark or ampersand.
+ * @param {String} url The URL to append to.
+ * @param {String} s The content to append to the URL.
+ * @return (String) The resulting URL
*/
- createSequence: function(origFn, newFn, scope) {
- if (!Ext.isFunction(newFn)) {
- return origFn;
- }
- else {
- return function() {
- var retval = origFn.apply(this || window, arguments);
- newFn.apply(scope || this || window, arguments);
- return retval;
- };
+ urlAppend : function(url, s) {
+ if (!Ext.isEmpty(s)) {
+ return url + (url.indexOf('?') === -1 ? '?' : '&') + s;
}
+ return url;
}
-};
-
-/**
- * Shorthand for {@link Ext.util.Functions#defer}
- * @param {Function} fn The function to defer.
- * @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately)
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Number} The timeout id that can be used with clearTimeout
- * @member Ext
- * @method defer
- */
-
-Ext.defer = Ext.util.Functions.defer;
-
-/**
- * Shorthand for {@link Ext.util.Functions#createInterceptor}
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to call before the original
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
+});
-Ext.createInterceptor = Ext.util.Functions.createInterceptor;
-/**
- * Shorthand for {@link Ext.util.Functions#createSequence}
- * @param {Function} origFn The original function.
- * @param {Function} newFn The function to sequence
- * @param {Object} scope (optional) The scope (this reference) in which the passed function is executed.
- * If omitted, defaults to the scope in which the original function is called or the browser window.
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
+Ext.ns = Ext.namespace;
-Ext.createSequence = Ext.util.Functions.createSequence;
+// for old browsers
+window.undefined = window.undefined;
/**
- * Shorthand for {@link Ext.util.Functions#createDelegate}
- * @param {Function} fn The function to delegate.
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed.
- * If omitted, defaults to the browser window.
- * @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller)
- * @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding,
- * if a number the args are inserted at the specified position
- * @return {Function} The new function
- * @member Ext
- * @method defer
- */
-Ext.createDelegate = Ext.util.Functions.createDelegate;
-/**
- * @class Ext.util.Observable
+ * @class Ext
+ * Ext core utilities and functions.
+ * @singleton
*/
-Ext.apply(Ext.util.Observable.prototype, function(){
- // this is considered experimental (along with beforeMethod, afterMethod, removeMethodListener?)
- // allows for easier interceptor and sequences, including cancelling and overwriting the return value of the call
- // private
- function getMethodEvent(method){
- var e = (this.methodEvents = this.methodEvents ||
- {})[method], returnValue, v, cancel, obj = this;
-
- if (!e) {
- this.methodEvents[method] = e = {};
- e.originalFn = this[method];
- e.methodName = method;
- e.before = [];
- e.after = [];
-
- var makeCall = function(fn, scope, args){
- if((v = fn.apply(scope || obj, args)) !== undefined){
- if (typeof v == 'object') {
- if(v.returnValue !== undefined){
- returnValue = v.returnValue;
- }else{
- returnValue = v;
- }
- cancel = !!v.cancel;
- }
- else
- if (v === false) {
- cancel = true;
- }
- else {
- returnValue = v;
- }
- }
- };
+(function(){
+ var check = function(regex){
+ return regex.test(Ext.userAgent);
+ },
+ docMode = document.documentMode,
+ isOpera = check(/opera/),
+ isOpera10_5 = isOpera && check(/version\/10\.5/),
+ isChrome = check(/\bchrome\b/),
+ isWebKit = check(/webkit/),
+ isSafari = !isChrome && check(/safari/),
+ isSafari2 = isSafari && check(/applewebkit\/4/), // unique to Safari 2
+ isSafari3 = isSafari && check(/version\/3/),
+ isSafari4 = isSafari && check(/version\/4/),
+ isIE = !isOpera && check(/msie/),
+ isIE7 = isIE && (check(/msie 7/) || docMode == 7),
+ isIE8 = isIE && (check(/msie 8/) && docMode != 7 && docMode != 9 || docMode == 8),
+ isIE9 = isIE && (check(/msie 9/) && docMode != 7 && docMode != 8 || docMode == 9),
+ isIE6 = isIE && check(/msie 6/),
+ isGecko = !isWebKit && check(/gecko/),
+ isGecko3 = isGecko && check(/rv:1\.9/),
+ isGecko4 = isGecko && check(/rv:2\.0/),
+ isFF3_0 = isGecko3 && check(/rv:1\.9\.0/),
+ isFF3_5 = isGecko3 && check(/rv:1\.9\.1/),
+ isFF3_6 = isGecko3 && check(/rv:1\.9\.2/),
+ isWindows = check(/windows|win32/),
+ isMac = check(/macintosh|mac os x/),
+ isLinux = check(/linux/),
+ scrollbarSize = null,
+ webKitVersion = isWebKit && (/webkit\/(\d+\.\d+)/.exec(Ext.userAgent));
+
+ // remove css image flicker
+ try {
+ document.execCommand("BackgroundImageCache", false, true);
+ } catch(e) {}
- this[method] = function(){
- var args = Array.prototype.slice.call(arguments, 0),
- b;
- returnValue = v = undefined;
- cancel = false;
-
- for(var i = 0, len = e.before.length; i < len; i++){
- b = e.before[i];
- makeCall(b.fn, b.scope, args);
- if (cancel) {
- return returnValue;
- }
- }
+ Ext.setVersion('extjs', '4.0.2');
+ Ext.apply(Ext, {
+ /**
+ * URL to a blank file used by Ext when in secure mode for iframe src and onReady src to prevent
+ * the IE insecure content warning ('about:blank', except for IE in secure mode, which is 'javascript:""').
+ * @type String
+ */
+ SSL_SECURE_URL : Ext.isSecure && isIE ? 'javascript:""' : 'about:blank',
- if((v = e.originalFn.apply(obj, args)) !== undefined){
- returnValue = v;
- }
+ /**
+ * True if the {@link Ext.fx.Anim} Class is available
+ * @type Boolean
+ * @property enableFx
+ */
- for(var i = 0, len = e.after.length; i < len; i++){
- b = e.after[i];
- makeCall(b.fn, b.scope, args);
- if (cancel) {
- return returnValue;
- }
- }
- return returnValue;
- };
- }
- return e;
- }
+ /**
+ * True to scope the reset CSS to be just applied to Ext components. Note that this wraps root containers
+ * with an additional element. Also remember that when you turn on this option, you have to use ext-all-scoped {
+ * unless you use the bootstrap.js to load your javascript, in which case it will be handled for you.
+ * @type Boolean
+ */
+ scopeResetCSS : Ext.buildSettings.scopeResetCSS,
- return {
- // these are considered experimental
- // allows for easier interceptor and sequences, including cancelling and overwriting the return value of the call
- // adds an 'interceptor' called before the original method
- beforeMethod : function(method, fn, scope){
- getMethodEvent.call(this, method).before.push({
- fn: fn,
- scope: scope
- });
- },
+ /**
+ * EXPERIMENTAL - True to cascade listener removal to child elements when an element is removed.
+ * Currently not optimized for performance.
+ * @type Boolean
+ */
+ enableNestedListenerRemoval : false,
- // adds a 'sequence' called after the original method
- afterMethod : function(method, fn, scope){
- getMethodEvent.call(this, method).after.push({
- fn: fn,
- scope: scope
- });
- },
+ /**
+ * Indicates whether to use native browser parsing for JSON methods.
+ * This option is ignored if the browser does not support native JSON methods.
+ * Note: Native JSON methods will not work with objects that have functions.
+ * Also, property names must be quoted, otherwise the data will not parse. (Defaults to false)
+ * @type Boolean
+ */
+ USE_NATIVE_JSON : false,
- removeMethodListener: function(method, fn, scope){
- var e = this.getMethodEvent(method);
- for(var i = 0, len = e.before.length; i < len; i++){
- if(e.before[i].fn == fn && e.before[i].scope == scope){
- e.before.splice(i, 1);
- return;
- }
+ /**
+ * Return the dom node for the passed String (id), dom node, or Ext.core.Element.
+ * Optional 'strict' flag is needed for IE since it can return 'name' and
+ * 'id' elements by using getElementById.
+ * Here are some examples:
+ *
+// gets dom node based on id
+var elDom = Ext.getDom('elId');
+// gets dom node based on the dom node
+var elDom1 = Ext.getDom(elDom);
+
+// If we don't know if we are working with an
+// Ext.core.Element or a dom node use Ext.getDom
+function(el){
+ var dom = Ext.getDom(el);
+ // do something with the dom node
+}
+ *
+ * Note: the dom node to be found actually needs to exist (be rendered, etc)
+ * when this method is called to be successful.
+ * @param {Mixed} el
+ * @return HTMLElement
+ */
+ getDom : function(el, strict) {
+ if (!el || !document) {
+ return null;
}
- for(var i = 0, len = e.after.length; i < len; i++){
- if(e.after[i].fn == fn && e.after[i].scope == scope){
- e.after.splice(i, 1);
- return;
+ if (el.dom) {
+ return el.dom;
+ } else {
+ if (typeof el == 'string') {
+ var e = document.getElementById(el);
+ // IE returns elements with the 'name' and 'id' attribute.
+ // we do a strict check to return the element with only the id attribute
+ if (e && isIE && strict) {
+ if (el == e.getAttribute('id')) {
+ return e;
+ } else {
+ return null;
+ }
+ }
+ return e;
+ } else {
+ return el;
}
}
},
/**
- * Relays selected events from the specified Observable as if the events were fired by this.
- * @param {Object} o The Observable whose events this object is to relay.
- * @param {Array} events Array of event names to relay.
+ * Removes a DOM node from the document.
+ *
Removes this element from the document, removes all DOM event listeners, and deletes the cache reference.
+ * All DOM event listeners are removed from this element. If {@link Ext#enableNestedListenerRemoval Ext.enableNestedListenerRemoval} is
+ * true, then DOM event listeners are also removed from all child nodes. The body node
+ * will be ignored if passed in.
Enables events fired by this Observable to bubble up an owner hierarchy by calling
- * this.getBubbleTarget() if present. There is no implementation in the Observable base class.
- *
This is commonly used by Ext.Components to bubble events to owner Containers. See {@link Ext.Component.getBubbleTarget}. The default
- * implementation in Ext.Component returns the Component's immediate owner. But if a known target is required, this can be overridden to
- * access the required target more quickly.
- *
Example:
-Ext.override(Ext.form.Field, {
- // Add functionality to Field's initComponent to enable the change event to bubble
- initComponent : Ext.form.Field.prototype.initComponent.createSequence(function() {
- this.enableBubble('change');
- }),
+ * True if the detected browser is Opera.
+ * @type Boolean
+ */
+ isOpera : isOpera,
- // We know that we want Field's events to bubble directly to the FormPanel.
- getBubbleTarget : function() {
- if (!this.formPanel) {
- this.formPanel = this.findParentByType('form');
- }
- return this.formPanel;
- }
-});
+ /**
+ * True if the detected browser is Opera 10.5x.
+ * @type Boolean
+ */
+ isOpera10_5 : isOpera10_5,
-var myForm = new Ext.formPanel({
- title: 'User Details',
- items: [{
- ...
- }],
- listeners: {
- change: function() {
- // Title goes red if form has been modified.
- myForm.header.setStyle('color', 'red');
- }
- }
-});
-
- * @param {String/Array} events The event name to bubble, or an Array of event names.
+ /**
+ * True if the detected browser uses WebKit.
+ * @type Boolean
*/
- enableBubble : function(events){
- var me = this;
- if(!Ext.isEmpty(events)){
- events = Ext.isArray(events) ? events : Array.prototype.slice.call(arguments, 0);
- for(var i = 0, len = events.length; i < len; i++){
- var ename = events[i];
- ename = ename.toLowerCase();
- var ce = me.events[ename] || true;
- if (typeof ce == 'boolean') {
- ce = new Ext.util.Event(me, ename);
- me.events[ename] = ce;
- }
- ce.bubble = true;
- }
- }
- }
- };
-}());
+ isWebKit : isWebKit,
+ /**
+ * True if the detected browser is Chrome.
+ * @type Boolean
+ */
+ isChrome : isChrome,
-/**
- * Starts capture on the specified Observable. All events will be passed
- * to the supplied function with the event name + standard signature of the event
- * before the event is fired. If the supplied function returns false,
- * the event will not fire.
- * @param {Observable} o The Observable to capture events from.
- * @param {Function} fn The function to call when an event is fired.
- * @param {Object} scope (optional) The scope (this reference) in which the function is executed. Defaults to the Observable firing the event.
- * @static
- */
-Ext.util.Observable.capture = function(o, fn, scope){
- o.fireEvent = o.fireEvent.createInterceptor(fn, scope);
-};
+ /**
+ * True if the detected browser is Safari.
+ * @type Boolean
+ */
+ isSafari : isSafari,
+ /**
+ * True if the detected browser is Safari 3.x.
+ * @type Boolean
+ */
+ isSafari3 : isSafari3,
-/**
- * Sets observability on the passed class constructor.
- *
This makes any event fired on any instance of the passed class also fire a single event through
- * the class allowing for central handling of events on many instances at once.
- *
Usage:
-Ext.util.Observable.observeClass(Ext.data.Connection);
-Ext.data.Connection.on('beforerequest', function(con, options) {
- console.log('Ajax request made to ' + options.url);
-});
- * @param {Function} c The class constructor to make observable.
- * @param {Object} listeners An object containing a series of listeners to add. See {@link #addListener}.
- * @static
- */
-Ext.util.Observable.observeClass = function(c, listeners){
- if(c){
- if(!c.fireEvent){
- Ext.apply(c, new Ext.util.Observable());
- Ext.util.Observable.capture(c.prototype, c.fireEvent, c);
- }
- if(typeof listeners == 'object'){
- c.on(listeners);
- }
- return c;
- }
-};
-/**
-* @class Ext.EventManager
-*/
-Ext.apply(Ext.EventManager, function(){
- var resizeEvent,
- resizeTask,
- textEvent,
- textSize,
- D = Ext.lib.Dom,
- propRe = /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
- curWidth = 0,
- curHeight = 0,
- // note 1: IE fires ONLY the keydown event on specialkey autorepeat
- // note 2: Safari < 3.1, Gecko (Mac/Linux) & Opera fire only the keypress event on specialkey autorepeat
- // (research done by @Jan Wolter at http://unixpapa.com/js/key.html)
- useKeydown = Ext.isWebKit ?
- Ext.num(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1]) >= 525 :
- !((Ext.isGecko && !Ext.isWindows) || Ext.isOpera);
-
- return {
- // private
- doResizeEvent: function(){
- var h = D.getViewHeight(),
- w = D.getViewWidth();
-
- //whacky problem in IE where the resize event will fire even though the w/h are the same.
- if(curHeight != h || curWidth != w){
- resizeEvent.fire(curWidth = w, curHeight = h);
- }
- },
+ /**
+ * True if the detected browser is Safari 4.x.
+ * @type Boolean
+ */
+ isSafari4 : isSafari4,
- /**
- * Adds a listener to be notified when the browser window is resized and provides resize event buffering (100 milliseconds),
- * passes new viewport width and height to handlers.
- * @param {Function} fn The handler function the window resize event invokes.
- * @param {Object} scope The scope (this reference) in which the handler function executes. Defaults to the browser window.
- * @param {boolean} options Options object as passed to {@link Ext.Element#addListener}
- */
- onWindowResize : function(fn, scope, options){
- if(!resizeEvent){
- resizeEvent = new Ext.util.Event();
- resizeTask = new Ext.util.DelayedTask(this.doResizeEvent);
- Ext.EventManager.on(window, "resize", this.fireWindowResize, this);
- }
- resizeEvent.addListener(fn, scope, options);
- },
+ /**
+ * True if the detected browser is Safari 2.x.
+ * @type Boolean
+ */
+ isSafari2 : isSafari2,
- // exposed only to allow manual firing
- fireWindowResize : function(){
- if(resizeEvent){
- resizeTask.delay(100);
- }
- },
+ /**
+ * True if the detected browser is Internet Explorer.
+ * @type Boolean
+ */
+ isIE : isIE,
- /**
- * Adds a listener to be notified when the user changes the active text size. Handler gets called with 2 params, the old size and the new size.
- * @param {Function} fn The function the event invokes.
- * @param {Object} scope The scope (this reference) in which the handler function executes. Defaults to the browser window.
- * @param {boolean} options Options object as passed to {@link Ext.Element#addListener}
- */
- onTextResize : function(fn, scope, options){
- if(!textEvent){
- textEvent = new Ext.util.Event();
- var textEl = new Ext.Element(document.createElement('div'));
- textEl.dom.className = 'x-text-resize';
- textEl.dom.innerHTML = 'X';
- textEl.appendTo(document.body);
- textSize = textEl.dom.offsetHeight;
- setInterval(function(){
- if(textEl.dom.offsetHeight != textSize){
- textEvent.fire(textSize, textSize = textEl.dom.offsetHeight);
- }
- }, this.textResizeInterval);
- }
- textEvent.addListener(fn, scope, options);
- },
+ /**
+ * True if the detected browser is Internet Explorer 6.x.
+ * @type Boolean
+ */
+ isIE6 : isIE6,
- /**
- * Removes the passed window resize listener.
- * @param {Function} fn The method the event invokes
- * @param {Object} scope The scope of handler
- */
- removeResizeListener : function(fn, scope){
- if(resizeEvent){
- resizeEvent.removeListener(fn, scope);
- }
- },
+ /**
+ * True if the detected browser is Internet Explorer 7.x.
+ * @type Boolean
+ */
+ isIE7 : isIE7,
- // private
- fireResize : function(){
- if(resizeEvent){
- resizeEvent.fire(D.getViewWidth(), D.getViewHeight());
- }
- },
+ /**
+ * True if the detected browser is Internet Explorer 8.x.
+ * @type Boolean
+ */
+ isIE8 : isIE8,
/**
- * The frequency, in milliseconds, to check for text resize events (defaults to 50)
- */
- textResizeInterval : 50,
+ * True if the detected browser is Internet Explorer 9.x.
+ * @type Boolean
+ */
+ isIE9 : isIE9,
- /**
- * Url used for onDocumentReady with using SSL (defaults to Ext.SSL_SECURE_URL)
- */
- ieDeferSrc : false,
-
- // protected, short accessor for useKeydown
- getKeyEvent : function(){
- return useKeydown ? 'keydown' : 'keypress';
- },
+ /**
+ * True if the detected browser uses the Gecko layout engine (e.g. Mozilla, Firefox).
+ * @type Boolean
+ */
+ isGecko : isGecko,
- // protected for use inside the framework
- // detects whether we should use keydown or keypress based on the browser.
- useKeydown: useKeydown
- };
-}());
+ /**
+ * True if the detected browser uses a Gecko 1.9+ layout engine (e.g. Firefox 3.x).
+ * @type Boolean
+ */
+ isGecko3 : isGecko3,
-Ext.EventManager.on = Ext.EventManager.addListener;
+ /**
+ * True if the detected browser uses a Gecko 2.0+ layout engine (e.g. Firefox 4.x).
+ * @type Boolean
+ */
+ isGecko4 : isGecko4,
+ /**
+ * True if the detected browser uses FireFox 3.0
+ * @type Boolean
+ */
-Ext.apply(Ext.EventObjectImpl.prototype, {
- /** Key constant @type Number */
- BACKSPACE: 8,
- /** Key constant @type Number */
- TAB: 9,
- /** Key constant @type Number */
- NUM_CENTER: 12,
- /** Key constant @type Number */
- ENTER: 13,
- /** Key constant @type Number */
- RETURN: 13,
- /** Key constant @type Number */
- SHIFT: 16,
- /** Key constant @type Number */
- CTRL: 17,
- CONTROL : 17, // legacy
- /** Key constant @type Number */
- ALT: 18,
- /** Key constant @type Number */
- PAUSE: 19,
- /** Key constant @type Number */
- CAPS_LOCK: 20,
- /** Key constant @type Number */
- ESC: 27,
- /** Key constant @type Number */
- SPACE: 32,
- /** Key constant @type Number */
- PAGE_UP: 33,
- PAGEUP : 33, // legacy
- /** Key constant @type Number */
- PAGE_DOWN: 34,
- PAGEDOWN : 34, // legacy
- /** Key constant @type Number */
- END: 35,
- /** Key constant @type Number */
- HOME: 36,
- /** Key constant @type Number */
- LEFT: 37,
- /** Key constant @type Number */
- UP: 38,
- /** Key constant @type Number */
- RIGHT: 39,
- /** Key constant @type Number */
- DOWN: 40,
- /** Key constant @type Number */
- PRINT_SCREEN: 44,
- /** Key constant @type Number */
- INSERT: 45,
- /** Key constant @type Number */
- DELETE: 46,
- /** Key constant @type Number */
- ZERO: 48,
- /** Key constant @type Number */
- ONE: 49,
- /** Key constant @type Number */
- TWO: 50,
- /** Key constant @type Number */
- THREE: 51,
- /** Key constant @type Number */
- FOUR: 52,
- /** Key constant @type Number */
- FIVE: 53,
- /** Key constant @type Number */
- SIX: 54,
- /** Key constant @type Number */
- SEVEN: 55,
- /** Key constant @type Number */
- EIGHT: 56,
- /** Key constant @type Number */
- NINE: 57,
- /** Key constant @type Number */
- A: 65,
- /** Key constant @type Number */
- B: 66,
- /** Key constant @type Number */
- C: 67,
- /** Key constant @type Number */
- D: 68,
- /** Key constant @type Number */
- E: 69,
- /** Key constant @type Number */
- F: 70,
- /** Key constant @type Number */
- G: 71,
- /** Key constant @type Number */
- H: 72,
- /** Key constant @type Number */
- I: 73,
- /** Key constant @type Number */
- J: 74,
- /** Key constant @type Number */
- K: 75,
- /** Key constant @type Number */
- L: 76,
- /** Key constant @type Number */
- M: 77,
- /** Key constant @type Number */
- N: 78,
- /** Key constant @type Number */
- O: 79,
- /** Key constant @type Number */
- P: 80,
- /** Key constant @type Number */
- Q: 81,
- /** Key constant @type Number */
- R: 82,
- /** Key constant @type Number */
- S: 83,
- /** Key constant @type Number */
- T: 84,
- /** Key constant @type Number */
- U: 85,
- /** Key constant @type Number */
- V: 86,
- /** Key constant @type Number */
- W: 87,
- /** Key constant @type Number */
- X: 88,
- /** Key constant @type Number */
- Y: 89,
- /** Key constant @type Number */
- Z: 90,
- /** Key constant @type Number */
- CONTEXT_MENU: 93,
- /** Key constant @type Number */
- NUM_ZERO: 96,
- /** Key constant @type Number */
- NUM_ONE: 97,
- /** Key constant @type Number */
- NUM_TWO: 98,
- /** Key constant @type Number */
- NUM_THREE: 99,
- /** Key constant @type Number */
- NUM_FOUR: 100,
- /** Key constant @type Number */
- NUM_FIVE: 101,
- /** Key constant @type Number */
- NUM_SIX: 102,
- /** Key constant @type Number */
- NUM_SEVEN: 103,
- /** Key constant @type Number */
- NUM_EIGHT: 104,
- /** Key constant @type Number */
- NUM_NINE: 105,
- /** Key constant @type Number */
- NUM_MULTIPLY: 106,
- /** Key constant @type Number */
- NUM_PLUS: 107,
- /** Key constant @type Number */
- NUM_MINUS: 109,
- /** Key constant @type Number */
- NUM_PERIOD: 110,
- /** Key constant @type Number */
- NUM_DIVISION: 111,
- /** Key constant @type Number */
- F1: 112,
- /** Key constant @type Number */
- F2: 113,
- /** Key constant @type Number */
- F3: 114,
- /** Key constant @type Number */
- F4: 115,
- /** Key constant @type Number */
- F5: 116,
- /** Key constant @type Number */
- F6: 117,
- /** Key constant @type Number */
- F7: 118,
- /** Key constant @type Number */
- F8: 119,
- /** Key constant @type Number */
- F9: 120,
- /** Key constant @type Number */
- F10: 121,
- /** Key constant @type Number */
- F11: 122,
- /** Key constant @type Number */
- F12: 123,
-
- /** @private */
- isNavKeyPress : function(){
- var me = this,
- k = this.normalizeKey(me.keyCode);
- return (k >= 33 && k <= 40) || // Page Up/Down, End, Home, Left, Up, Right, Down
- k == me.RETURN ||
- k == me.TAB ||
- k == me.ESC;
- },
+ isFF3_0 : isFF3_0,
+ /**
+ * True if the detected browser uses FireFox 3.5
+ * @type Boolean
+ */
- isSpecialKey : function(){
- var k = this.normalizeKey(this.keyCode);
- return (this.type == 'keypress' && this.ctrlKey) ||
- this.isNavKeyPress() ||
- (k == this.BACKSPACE) || // Backspace
- (k >= 16 && k <= 20) || // Shift, Ctrl, Alt, Pause, Caps Lock
- (k >= 44 && k <= 46); // Print Screen, Insert, Delete
- },
+ isFF3_5 : isFF3_5,
+ /**
+ * True if the detected browser uses FireFox 3.6
+ * @type Boolean
+ */
+ isFF3_6 : isFF3_6,
- getPoint : function(){
- return new Ext.lib.Point(this.xy[0], this.xy[1]);
- },
+ /**
+ * True if the detected platform is Linux.
+ * @type Boolean
+ */
+ isLinux : isLinux,
- /**
- * Returns true if the control, meta, shift or alt key was pressed during this event.
- * @return {Boolean}
- */
- hasModifier : function(){
- return ((this.ctrlKey || this.altKey) || this.shiftKey);
- }
-});/**
- * @class Ext.Element
- */
-Ext.Element.addMethods({
- /**
- * Stops the specified event(s) from bubbling and optionally prevents the default action
- * @param {String/Array} eventName an event / array of events to stop from bubbling
- * @param {Boolean} preventDefault (optional) true to prevent the default action too
- * @return {Ext.Element} this
- */
- swallowEvent : function(eventName, preventDefault) {
- var me = this;
- function fn(e) {
- e.stopPropagation();
- if (preventDefault) {
- e.preventDefault();
- }
- }
-
- if (Ext.isArray(eventName)) {
- Ext.each(eventName, function(e) {
- me.on(e, fn);
- });
- return me;
- }
- me.on(eventName, fn);
- return me;
- },
+ /**
+ * True if the detected platform is Windows.
+ * @type Boolean
+ */
+ isWindows : isWindows,
- /**
- * Create an event handler on this element such that when the event fires and is handled by this element,
- * it will be relayed to another object (i.e., fired again as if it originated from that object instead).
- * @param {String} eventName The type of event to relay
- * @param {Object} object Any object that extends {@link Ext.util.Observable} that will provide the context
- * for firing the relayed event
- */
- relayEvent : function(eventName, observable) {
- this.on(eventName, function(e) {
- observable.fireEvent(eventName, e);
- });
- },
+ /**
+ * True if the detected platform is Mac OS.
+ * @type Boolean
+ */
+ isMac : isMac,
- /**
- * Removes worthless text nodes
- * @param {Boolean} forceReclean (optional) By default the element
- * keeps track if it has been cleaned already so
- * you can call this over and over. However, if you update the element and
- * need to force a reclean, you can pass true.
- */
- clean : function(forceReclean) {
- var me = this,
- dom = me.dom,
- n = dom.firstChild,
- ni = -1;
+ /**
+ * The current version of WebKit (-1 if the browser does not use WebKit).
+ * @type Float
+ */
+ webKitVersion: webKitVersion ? parseFloat(webKitVersion[1]) : -1,
- if (Ext.Element.data(dom, 'isCleaned') && forceReclean !== true) {
- return me;
- }
+ /**
+ * URL to a 1x1 transparent gif image used by Ext to create inline icons with CSS background images.
+ * In older versions of IE, this defaults to "http://sencha.com/s.gif" and you should change this to a URL on your server.
+ * For other browsers it uses an inline data URL.
+ * @type String
+ */
+ BLANK_IMAGE_URL : (isIE6 || isIE7) ? 'http:/' + '/www.sencha.com/s.gif' : 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
- while (n) {
- var nx = n.nextSibling;
- if (n.nodeType == 3 && !(/\S/.test(n.nodeValue))) {
- dom.removeChild(n);
- } else {
- n.nodeIndex = ++ni;
- }
- n = nx;
- }
-
- Ext.Element.data(dom, 'isCleaned', true);
- return me;
- },
+ /**
+ *
Utility method for returning a default value if the passed value is empty.
+ *
The value is deemed to be empty if it is
+ *
null
+ *
undefined
+ *
an empty array
+ *
a zero length string (Unless the allowBlank parameter is true)
+ *
+ * @param {Mixed} value The value to test
+ * @param {Mixed} defaultValue The value to return if the original value is empty
+ * @param {Boolean} allowBlank (optional) true to allow zero length strings to qualify as non-empty (defaults to false)
+ * @return {Mixed} value, if non-empty, else defaultValue
+ * @deprecated 4.0.0 Use {@link Ext#valueFrom} instead
+ */
+ value : function(v, defaultValue, allowBlank){
+ return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
+ },
- /**
- * Direct access to the Updater {@link Ext.Updater#update} method. The method takes the same object
- * parameter as {@link Ext.Updater#update}
- * @return {Ext.Element} this
- */
- load : function() {
- var updateManager = this.getUpdater();
- updateManager.update.apply(updateManager, arguments);
-
- return this;
- },
+ /**
+ * Escapes the passed string for use in a regular expression
+ * @param {String} str
+ * @return {String}
+ * @deprecated 4.0.0 Use {@link Ext.String#escapeRegex} instead
+ */
+ escapeRe : function(s) {
+ return s.replace(/([-.*+?^${}()|[\]\/\\])/g, "\\$1");
+ },
- /**
- * Gets this element's {@link Ext.Updater Updater}
- * @return {Ext.Updater} The Updater
- */
- getUpdater : function() {
- return this.updateManager || (this.updateManager = new Ext.Updater(this));
+ /**
+ * Applies event listeners to elements by selectors when the document is ready.
+ * The event name is specified with an @ suffix.
+ *
+Ext.addBehaviors({
+ // add a listener for click on all anchors in element with id foo
+ '#foo a@click' : function(e, t){
+ // do something
},
- /**
- * Update the innerHTML of this element, optionally searching for and processing scripts
- * @param {String} html The new HTML
- * @param {Boolean} loadScripts (optional) True to look for and process scripts (defaults to false)
- * @param {Function} callback (optional) For async script loading you can be notified when the update completes
- * @return {Ext.Element} this
- */
- update : function(html, loadScripts, callback) {
- if (!this.dom) {
- return this;
- }
- html = html || "";
+ // add the same listener to multiple selectors (separated by comma BEFORE the @)
+ '#foo a, #bar span.some-class@mouseover' : function(){
+ // do something
+ }
+});
+ *
+ * @param {Object} obj The list of behaviors to apply
+ */
+ addBehaviors : function(o){
+ if(!Ext.isReady){
+ Ext.onReady(function(){
+ Ext.addBehaviors(o);
+ });
+ } else {
+ var cache = {}, // simple cache for applying multiple behaviors to same selector does query multiple times
+ parts,
+ b,
+ s;
+ for (b in o) {
+ if ((parts = b.split('@'))[1]) { // for Object prototype breakers
+ s = parts[0];
+ if(!cache[s]){
+ cache[s] = Ext.select(s);
+ }
+ cache[s].on(parts[1], o[b]);
+ }
+ }
+ cache = null;
+ }
+ },
- if (loadScripts !== true) {
- this.dom.innerHTML = html;
- if (typeof callback == 'function') {
- callback();
+ /**
+ * Returns the size of the browser scrollbars. This can differ depending on
+ * operating system settings, such as the theme or font size.
+ * @param {Boolean} force (optional) true to force a recalculation of the value.
+ * @return {Object} An object containing the width of a vertical scrollbar and the
+ * height of a horizontal scrollbar.
+ */
+ getScrollbarSize: function (force) {
+ if(!Ext.isReady){
+ return 0;
}
- return this;
- }
- var id = Ext.id(),
- dom = this.dom;
+ if(force === true || scrollbarSize === null){
+ // BrowserBug: IE9
+ // When IE9 positions an element offscreen via offsets, the offsetWidth is
+ // inaccurately reported. For IE9 only, we render on screen before removing.
+ var cssClass = Ext.isIE9 ? '' : Ext.baseCSSPrefix + 'hide-offsets',
+ // Append our div, do our calculation and then remove it
+ div = Ext.getBody().createChild('
'),
+ child = div.child('div', true),
+ w1 = child.offsetWidth;
- html += '';
+ div.setStyle('overflow', (Ext.isWebKit || Ext.isGecko) ? 'auto' : 'scroll');
- Ext.lib.Event.onAvailable(id, function() {
- var DOC = document,
- hd = DOC.getElementsByTagName("head")[0],
- re = /(?:
+ *
+ * ## Configuration
+ *
+ * This component allows several options for configuring how the target Flash movie is embedded. The most
+ * important is the required {@link #url} which points to the location of the Flash movie to load. Other
+ * configurations include:
+ *
+ * - {@link #backgroundColor}
+ * - {@link #wmode}
+ * - {@link #flashVars}
+ * - {@link #flashParams}
+ * - {@link #flashAttributes}
+ *
+ * ## Example usage:
+ *
+ * var win = Ext.widget('window', {
+ * title: "It's a tiger!",
+ * layout: 'fit',
+ * width: 300,
+ * height: 300,
+ * x: 20,
+ * y: 20,
+ * resizable: true,
+ * items: {
+ * xtype: 'flash',
+ * url: 'tiger.swf'
+ * }
+ * });
+ * win.show();
+ *
+ * ## Express Install
+ *
+ * Adobe provides a tool called [Express Install](http://www.adobe.com/devnet/flashplayer/articles/express_install.html)
+ * that offers users an easy way to upgrade their Flash player. If you wish to make use of this, you should set
+ * the static EXPRESS\_INSTALL\_URL property to the location of your Express Install SWF file:
+ *
+ * Ext.flash.Component.EXPRESS_INSTALL_URL = 'path/to/local/expressInstall.swf';
+ *
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.flash.Component', {
+ extend: 'Ext.Component',
+ alternateClassName: 'Ext.FlashComponent',
+ alias: 'widget.flash',
- 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';
- }
- }
+ /**
+ * @cfg {String} flashVersion
+ * Indicates the version the flash content was published for. Defaults to '9.0.115'.
+ */
+ flashVersion : '9.0.115',
- /**
- * 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');
+ /**
+ * @cfg {String} backgroundColor
+ * The background color of the SWF movie. Defaults to '#ffffff'.
+ */
+ backgroundColor: '#ffffff',
- Ext.apply(this, config);
+ /**
+ * @cfg {String} wmode
+ * The wmode of the flash object. This can be used to control layering. Defaults to 'opaque'.
+ * Set to 'transparent' to ignore the {@link #backgroundColor} and make the background of the Flash
+ * movie transparent.
+ */
+ wmode: 'opaque',
- 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;
+ /**
+ * @cfg {Object} flashVars
+ * A set of key value pairs to be passed to the flash object as flash variables. Defaults to undefined.
+ */
- if(this.handles.indexOf('n') != -1 || this.handles.indexOf('w') != -1){
- this.updateBox = true;
- }
+ /**
+ * @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.
+ */
- this.activeHandle = null;
+ /**
+ * @cfg {Object} flashAttributes
+ * A set of key value pairs to be passed to the flash object as attributes. Defaults to undefined.
+ */
- 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);
- }
- }
+ /**
+ * @cfg {String} url
+ * The URL of the SWF file to include. Required.
+ */
- 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
- ];
- }
+ /**
+ * @cfg {String/Number} swfWidth The width of the embedded SWF movie inside the component. Defaults to "100%"
+ * so that the movie matches the width of the component.
+ */
+ swfWidth: '100%',
- 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);
- }
- }
+ /**
+ * @cfg {String/Number} swfHeight The height of the embedded SWF movie inside the component. Defaults to "100%"
+ * so that the movie matches the height of the component.
+ */
+ 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.
+ */
+ expressInstall: false,
+
+ /**
+ * @property swf
+ * @type {Ext.core.Element}
+ * A reference to the object or embed element into which the SWF file is loaded. Only
+ * populated after the component is rendered and the SWF has been successfully embedded.
+ */
+
+ // Have to create a placeholder div with the swfId, which SWFObject will replace with the object/embed element.
+ renderTpl: [''],
+
+ initComponent: function() {
+ this.callParent();
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
+ * @event success
+ * Fired when the Flash movie has been successfully embedded
+ * @param {Ext.flash.Component} this
*/
- 'beforeresize',
+ 'success',
+
/**
- * @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
+ * @event failure
+ * Fired when the Flash movie embedding fails
+ * @param {Ext.flash.Component} this
*/
- 'resize'
+ 'failure'
);
+ },
- 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);
+ onRender: function() {
+ var me = this,
+ params, vars, undef,
+ swfId = me.getSwfId();
+
+ me.renderData.swfId = swfId;
+
+ me.callParent(arguments);
+
+ params = Ext.apply({
+ allowScriptAccess: 'always',
+ bgcolor: me.backgroundColor,
+ wmode: me.wmode
+ }, me.flashParams);
+
+ vars = Ext.apply({
+ allowedDomain: document.location.hostname
+ }, me.flashVars);
+
+ new swfobject.embedSWF(
+ me.url,
+ swfId,
+ me.swfWidth,
+ me.swfHeight,
+ me.flashVersion,
+ me.expressInstall ? me.statics.EXPRESS_INSTALL_URL : undef,
+ vars,
+ params,
+ me.flashAttributes,
+ Ext.bind(me.swfCallback, me)
+ );
},
/**
- * @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)
+ * @private
+ * The callback method for handling an embedding success or failure by SWFObject
+ * @param {Object} e The event object passed by SWFObject - see http://code.google.com/p/swfobject/wiki/api
*/
- animate : false,
+ swfCallback: function(e) {
+ var me = this;
+ if (e.success) {
+ me.swf = Ext.get(e.ref);
+ me.onSuccess();
+ me.fireEvent('success', me);
+ } else {
+ me.onFailure();
+ me.fireEvent('failure', me);
+ }
+ },
+
/**
- * @cfg {Mixed} constrainTo Constrain the resize to a particular element
+ * Retrieve the id of the SWF object/embed element
*/
+ getSwfId: function() {
+ return this.swfId || (this.swfId = "extswf" + this.getAutoId());
+ },
+
+ onSuccess: function() {
+ // swfobject forces visiblity:visible on the swf element, which prevents it
+ // from getting hidden when an ancestor is given visibility:hidden.
+ this.swf.setStyle('visibility', 'inherit');
+ },
+
+ onFailure: Ext.emptyFn,
+
+ beforeDestroy: function() {
+ var me = this,
+ swf = me.swf;
+ if (swf) {
+ swfobject.removeSWF(me.getSwfId());
+ Ext.destroy(swf);
+ delete me.swf;
+ }
+ me.callParent();
+ },
+
+ statics: {
+ /**
+ * Sets the url for installing flash if it doesn't exist. This should be set to a local resource.
+ * See http://www.adobe.com/devnet/flashplayer/articles/express_install.html for details.
+ * @static
+ * @type String
+ */
+ EXPRESS_INSTALL_URL: 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'
+ }
+});
+
+/**
+ * @class Ext.form.action.Action
+ * @extends Ext.Base
+ *
The subclasses of this class provide actions to perform upon {@link Ext.form.Basic Form}s.
+ *
Instances of this class are only created by a {@link Ext.form.Basic 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.Basic#submit submit},
+ * {@link Ext.form.Basic#load load} and {@link Ext.form.Basic#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.Basic#submit submit},
+ * {@link Ext.form.Basic#load load} and {@link Ext.form.Basic#doAction doAction}),
+ * and to the {@link Ext.form.Basic#actioncomplete actioncomplete} and
+ * {@link Ext.form.Basic#actionfailed actionfailed} event handlers.
+ */
+Ext.define('Ext.form.action.Action', {
+ alternateClassName: 'Ext.form.Action',
+
/**
- * @cfg {Boolean} disableTrackOver True to disable mouse tracking. This is only applied at config time. (defaults to false)
+ * @cfg {Ext.form.Basic} form The {@link Ext.form.Basic BasicForm} instance that
+ * is invoking this Action. Required.
*/
- disableTrackOver : false,
+
/**
- * @cfg {Boolean} draggable Convenience to initialize drag drop (defaults to false)
+ * @cfg {String} url The URL that the Action is to invoke. Will default to the {@link Ext.form.Basic#url url}
+ * configured on the {@link #form}.
*/
- draggable: false,
+
/**
- * @cfg {Number} duration Animation duration if animate = true (defaults to 0.35)
+ * @cfg {Boolean} reset When set to true, causes the Form to be
+ * {@link Ext.form.Basic#reset reset} on Action success. If specified, this happens
+ * before the {@link #success} callback is called and before the Form's
+ * {@link Ext.form.Basic#actioncomplete actioncomplete} event fires.
*/
- duration : 0.35,
+
/**
- * @cfg {Boolean} dynamic True to resize the element while dragging instead of using a proxy (defaults to false)
+ * @cfg {String} method The HTTP method to use to access the requested URL. Defaults to the
+ * {@link Ext.form.Basic#method BasicForm's method}, or 'POST' if not specified.
*/
- dynamic : false,
+
/**
- * @cfg {String} easing Animation easing if animate = true (defaults to 'easingOutStrong')
+ * @cfg {Object/String} params
Extra parameter values to pass. These are added to the Form's
+ * {@link Ext.form.Basic#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 Ext.Object.toQueryString}.
Extra headers to be sent in the AJAX request for submit and load actions. See
+ * {@link Ext.data.Connection#headers}.
*/
- enabled : true,
+
/**
- * @property enabled Writable. False if resizing is disabled.
- * @type Boolean
+ * @cfg {Number} timeout The number of seconds to wait for a server response before
+ * failing with the {@link #failureType} as {@link Ext.form.action.Action#CONNECT_FAILURE}. If not specified,
+ * defaults to the configured {@link Ext.form.Basic#timeout timeout} of the
+ * {@link #form}.
*/
+
/**
- * @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'.
+ * @cfg {Function} success The function to call when a valid success return packet is received.
+ * The function is passed the following parameters:
+ *
form : Ext.form.Basic
The form that requested the action
+ *
action : Ext.form.action.Action
The Action class. The {@link #result}
+ * property of this object may be examined to perform custom postprocessing.
+ *
*/
- handles : false,
+
/**
- * @cfg {Boolean} multiDirectional Deprecated. Deprecated style of adding multi-direction resize handles.
+ * @cfg {Function} failure The function to call when a failure packet was received, or when an
+ * error ocurred in the Ajax communication.
+ * The function is passed the following parameters:
+ *
form : Ext.form.Basic
The form that requested the action
+ *
action : Ext.form.action.Action
The 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.
+ *
*/
- multiDirectional : false,
+
/**
- * @cfg {Number} height The height of the element in pixels (defaults to null)
+ * @cfg {Object} scope The scope in which to call the configured success and failure
+ * callback functions (the this reference for the callback functions).
*/
- height : null,
+
/**
- * @cfg {Number} width The width of the element in pixels (defaults to null)
+ * @cfg {String} waitMsg The message to be displayed by a call to {@link Ext.window.MessageBox#wait}
+ * during the time the action is being processed.
*/
- width : null,
+
/**
- * @cfg {Number} heightIncrement The increment to snap the height resize in pixels
- * (only applies if {@link #dynamic}==true). Defaults to 0.
+ * @cfg {String} waitTitle The title to be displayed by a call to {@link Ext.window.MessageBox#wait}
+ * during the time the action is being processed.
*/
- heightIncrement : 0,
+
/**
- * @cfg {Number} widthIncrement The increment to snap the width resize in pixels
- * (only applies if {@link #dynamic}==true). Defaults to 0.
+ * @cfg {Boolean} submitEmptyText If set to true, the emptyText value will be sent with the form
+ * when it is submitted. Defaults to true.
*/
- widthIncrement : 0,
+
/**
- * @cfg {Number} minHeight The minimum height for the element (defaults to 5)
+ * @property type
+ * The type of action this Action instance performs.
+ * Currently only "submit" and "load" are supported.
+ * @type {String}
*/
- minHeight : 5,
+
/**
- * @cfg {Number} minWidth The minimum width for the element (defaults to 5)
+ * The type of failure detected will be one of these: {@link Ext.form.action.Action#CLIENT_INVALID},
+ * {@link Ext.form.action.Action#SERVER_INVALID}, {@link Ext.form.action.Action#CONNECT_FAILURE}, or
+ * {@link Ext.form.action.Action#LOAD_FAILURE}. Usage:
+ *
+ * @property failureType
+ * @type {String}
*/
- minWidth : 5,
+
/**
- * @cfg {Number} maxHeight The maximum height for the element (defaults to 10000)
+ * The raw XMLHttpRequest object used to perform the action.
+ * @property response
+ * @type {Object}
*/
- maxHeight : 10000,
+
/**
- * @cfg {Number} maxWidth The maximum width for the element (defaults to 10000)
+ * The decoded response object containing a boolean success property and
+ * other, action-specific properties.
+ * @property result
+ * @type {Object}
*/
- maxWidth : 10000,
+
/**
- * @cfg {Number} minX The minimum x for the element (defaults to 0)
+ * Creates new Action.
+ * @param {Object} config (optional) Config object.
*/
- minX: 0,
+ constructor: function(config) {
+ if (config) {
+ Ext.apply(this, config);
+ }
+
+ // Normalize the params option to an Object
+ var params = config.params;
+ if (Ext.isString(params)) {
+ this.params = Ext.Object.fromQueryString(params);
+ }
+ },
+
/**
- * @cfg {Number} minY The minimum x for the element (defaults to 0)
+ * Invokes this action using the current configuration.
*/
- minY: 0,
+ run: Ext.emptyFn,
+
/**
- * @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)
+ * @private
+ * @method onSuccess
+ * Callback method that gets invoked when the action completes successfully. Must be implemented by subclasses.
+ * @param {Object} response
*/
- pinned : false,
+
/**
- * @cfg {Boolean} preserveRatio True to preserve the original ratio between height
- * and width during resize (defaults to false)
+ * @private
+ * @method handleResponse
+ * Handles the raw response and builds a result object from it. Must be implemented by subclasses.
+ * @param {Object} response
*/
- preserveRatio : false,
+
/**
- * @cfg {Boolean/String/Element} resizeChild True to resize the first child, or id/element to resize (defaults to false)
+ * @private
+ * Handles a failure response.
+ * @param {Object} response
*/
- resizeChild : false,
+ onFailure : function(response){
+ this.response = response;
+ this.failureType = Ext.form.action.Action.CONNECT_FAILURE;
+ this.form.afterAction(this, false);
+ },
+
/**
- * @cfg {Boolean} transparent True for transparent handles. This is only applied at config time. (defaults to false)
+ * @private
+ * Validates that a response contains either responseText or responseXML and invokes
+ * {@link #handleResponse} to build the result object.
+ * @param {Object} response The raw response object.
+ * @return {Object/Boolean} result The result object as built by handleResponse, or true if
+ * the response had empty responseText and responseXML.
*/
- transparent: false,
+ processResponse : function(response){
+ this.response = response;
+ if (!response.responseText && !response.responseXML) {
+ return true;
+ }
+ return (this.result = this.handleResponse(response));
+ },
+
/**
- * @cfg {Ext.lib.Region} resizeRegion Constrain the resize to a particular region
+ * @private
+ * Build the URL for the AJAX request. Used by the standard AJAX submit and load actions.
+ * @return {String} The URL.
*/
+ getUrl: function() {
+ return this.url || this.form.url;
+ },
+
/**
- * @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)
+ * @private
+ * Determine the HTTP method to be used for the request.
+ * @return {String} The HTTP method
*/
+ getMethod: function() {
+ return (this.method || this.form.method || 'POST').toUpperCase();
+ },
+
/**
- * @cfg {String} handleCls A css class to add to each handle. Defaults to ''.
+ * @private
+ * Get the set of parameters specified in the BasicForm's baseParams and/or the params option.
+ * Items in params override items of the same name in baseParams.
+ * @return {Object} the full set of parameters
*/
-
+ getParams: function() {
+ return Ext.apply({}, this.params, this.form.baseParams);
+ },
/**
- * Perform a manual resize and fires the 'resize' event.
- * @param {Number} width
- * @param {Number} height
+ * @private
+ * Creates a callback object.
*/
- resizeTo : function(width, height){
- this.el.setSize(width, height);
- this.updateChildSize();
- this.fireEvent('resize', this, width, height, null);
+ createCallback: function() {
+ var me = this,
+ undef,
+ form = me.form;
+ return {
+ success: me.onSuccess,
+ failure: me.onFailure,
+ scope: me,
+ timeout: (this.timeout * 1000) || (form.timeout * 1000),
+ upload: form.fileUpload ? me.onSuccess : undef
+ };
},
- // 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'));
+ statics: {
+ /**
+ * @property CLIENT_INVALID
+ * Failure type returned when client side validation of the Form fails
+ * thus aborting a submit action. Client side validation is performed unless
+ * {@link Ext.form.action.Submit#clientValidation} is explicitly set to false.
+ * @type {String}
+ * @static
+ */
+ CLIENT_INVALID: 'client',
- 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]];
+ /**
+ * @property SERVER_INVALID
+ *
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
+ */
+ SERVER_INVALID: 'server',
- this.overlay.setSize(Ext.lib.Dom.getViewWidth(true), Ext.lib.Dom.getViewHeight(true));
- this.overlay.show();
+ /**
+ * @property CONNECT_FAILURE
+ * 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
+ */
+ CONNECT_FAILURE: 'connect',
- 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')
- );
- }
+ /**
+ * @property LOAD_FAILURE
+ * 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
+ */
+ LOAD_FAILURE: 'load'
- 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);
- },
+/**
+ * @class Ext.form.action.Submit
+ * @extends Ext.form.action.Action
+ *
A class which handles submission of data from {@link Ext.form.Basic Form}s
+ * and processes the returned response.
+ *
Instances of this class are only created by a {@link Ext.form.Basic Form} when
+ * {@link Ext.form.Basic#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.Basic}'s callback
+ * or event handler methods. The object decoded from this JSON is available in the
+ * {@link Ext.form.action.Action#result result} property.
+ *
Alternatively, if an {@link #errorReader} is specified as an {@link Ext.data.reader.Xml XmlReader}:
+<?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.Basic}'s callback
+ * or event handler methods. The XML document is available in the {@link #errorReader}'s {@link Ext.data.reader.Xml#xmlData xmlData} property.
+ */
+Ext.define('Ext.form.action.Submit', {
+ extend:'Ext.form.action.Action',
+ alternateClassName: 'Ext.form.Action.Submit',
+ alias: 'formaction.submit',
- // 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);
- }
+ type: 'submit',
+
+ /**
+ * @cfg {boolean} clientValidation Determines whether a Form's fields are validated
+ * in a final call to {@link Ext.form.Basic#isValid isValid} prior to submission.
+ * Pass false in the Form's submit options to prevent this. Defaults to true.
+ */
+
+ // inherit docs
+ run : function(){
+ var form = this.form;
+ if (this.clientValidation === false || form.isValid()) {
+ this.doSubmit();
+ } else {
+ // client validation failed
+ this.failureType = Ext.form.action.Action.CLIENT_INVALID;
+ form.afterAction(this, false);
}
},
- // private
- snap : function(value, inc, min){
- if(!inc || !value){
- return value;
+ /**
+ * @private
+ * Perform the submit of the form data.
+ */
+ doSubmit: function() {
+ var formEl,
+ ajaxOptions = Ext.apply(this.createCallback(), {
+ url: this.getUrl(),
+ method: this.getMethod(),
+ headers: this.headers
+ });
+
+ // For uploads we need to create an actual form that contains the file upload fields,
+ // and pass that to the ajax call so it can do its iframe-based submit method.
+ if (this.form.hasUpload()) {
+ formEl = ajaxOptions.form = this.buildForm();
+ ajaxOptions.isUpload = true;
+ } else {
+ ajaxOptions.params = this.getParams();
}
- var newValue = value;
- var m = value % inc;
- if(m > 0){
- if(m > (inc/2)){
- newValue = value + (inc-m);
- }else{
- newValue = value - m;
- }
+
+ Ext.Ajax.request(ajaxOptions);
+
+ if (formEl) {
+ Ext.removeNode(formEl);
}
- 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:
-
+ * @private
+ * Build the full set of parameters from the field values plus any additional configured params.
*/
- 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;
+ getParams: function() {
+ var nope = false,
+ configParams = this.callParent(),
+ fieldParams = this.form.getValues(nope, nope, this.submitEmptyText !== nope);
+ return Ext.apply({}, fieldParams, configParams);
},
- // 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
+ * Build a form element containing fields corresponding to all the parameters to be
+ * submitted (everything returned by {@link #getParams}.
+ * NOTE: the form element is automatically added to the DOM, so any code that uses
+ * it must remove it from the DOM after finishing with it.
+ * @return HTMLFormElement
+ */
+ buildForm: function() {
+ var fieldsSpec = [],
+ formSpec,
+ formEl,
+ basicForm = this.form,
+ params = this.getParams(),
+ uploadFields = [];
+
+ basicForm.getFields().each(function(field) {
+ if (field.isFileUpload()) {
+ uploadFields.push(field);
+ }
+ });
- // private
- onMouseMove : function(e){
- if(this.enabled && this.activeHandle){
- try{// try catch so if something goes wrong the user doesn't get hung
+ function addField(name, val) {
+ fieldsSpec.push({
+ tag: 'input',
+ type: 'hidden',
+ name: name,
+ value: Ext.String.htmlEncode(val)
+ });
+ }
- if(this.resizeRegion && !this.resizeRegion.contains(e.getPoint())) {
- return;
+ // Add the form field values
+ Ext.iterate(params, function(key, val) {
+ if (Ext.isArray(val)) {
+ Ext.each(val, function(v) {
+ addField(key, v);
+ });
+ } else {
+ addField(key, val);
}
+ });
- //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;
- }
+ formSpec = {
+ tag: 'form',
+ action: this.getUrl(),
+ method: this.getMethod(),
+ target: this.target || '_self',
+ style: 'display:none',
+ cn: fieldsSpec
+ };
- 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;
+ // Set the proper encoding for file uploads
+ if (uploadFields.length) {
+ formSpec.encoding = formSpec.enctype = 'multipart/form-data';
+ }
- }
- }
- this.proxy.setBounds(x, y, w, h);
- if(this.dynamic){
- this.resizeElement();
+ // Create the form
+ formEl = Ext.core.DomHelper.append(Ext.getBody(), formSpec);
+
+ // Special handling for file upload fields: since browser security measures prevent setting
+ // their values programatically, and prevent carrying their selected values over when cloning,
+ // we have to move the actual field instances out of their components and into the form.
+ Ext.Array.each(uploadFields, function(field) {
+ if (field.rendered) { // can only have a selected file value after being rendered
+ formEl.appendChild(field.extractFileInput());
}
- }catch(ex){}
- }
+ });
+
+ return formEl;
},
- // private
- handleOver : function(){
- if(this.enabled){
- this.el.addClass('x-resizable-over');
+
+
+ /**
+ * @private
+ */
+ onSuccess: function(response) {
+ var form = this.form,
+ success = true,
+ result = this.processResponse(response);
+ if (result !== true && !result.success) {
+ if (result.errors) {
+ form.markInvalid(result.errors);
+ }
+ this.failureType = Ext.form.action.Action.SERVER_INVALID;
+ success = false;
}
+ form.afterAction(this, success);
},
- // private
- handleOut : function(){
- if(!this.resizing){
- this.el.removeClass('x-resizable-over');
+ /**
+ * @private
+ */
+ handleResponse: function(response) {
+ var form = this.form,
+ errorReader = form.errorReader,
+ rs, errors, i, len, records;
+ if (errorReader) {
+ rs = errorReader.read(response);
+ records = rs.records;
+ errors = [];
+ if (records) {
+ for(i = 0, len = records.length; i < len; i++) {
+ errors[i] = records[i].data;
+ }
+ }
+ if (errors.length < 1) {
+ errors = null;
+ }
+ return {
+ success : rs.success,
+ errors : errors
+ };
}
- },
+ return Ext.decode(response.responseText);
+ }
+});
+
+/**
+ * @class Ext.util.ComponentDragger
+ * @extends Ext.dd.DragTracker
+ *
A subclass of Ext.dd.DragTracker which handles dragging any Component.
+ *
This is configured with a Component to be made draggable, and a config object for the
+ * {@link Ext.dd.DragTracker} class.
+ *
A {@link #} delegate may be provided which may be either the element to use as the mousedown target
+ * or a {@link Ext.DomQuery} selector to activate multiple mousedown targets.
+ */
+Ext.define('Ext.util.ComponentDragger', {
/**
- * Returns the element this component is bound to.
- * @return {Ext.Element}
+ * @cfg {Boolean} constrain
+ * Specify as true to constrain the Component to within the bounds of the {@link #constrainTo} region.
*/
- getEl : function(){
- return this.el;
- },
/**
- * Returns the resizeChild element (or null).
- * @return {Ext.Element}
+ * @cfg {String/Element} delegate
+ * Optional.
A {@link Ext.DomQuery DomQuery} selector which identifies child elements within the Component's encapsulating
+ * Element which are the drag handles. This limits dragging to only begin when the matching elements are mousedowned.
+ *
This may also be a specific child element within the Component's encapsulating element to use as the drag handle.
*/
- 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
+ * @cfg {Boolean} constrainDelegate
+ * Specify as true to constrain the drag handles within the {@link #constrainTo} region.
*/
- 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();
+ extend: 'Ext.dd.DragTracker',
+
+ autoStart: 500,
+
+ /**
+ * Creates new ComponentDragger.
+ * @param {object} comp The Component to provide dragging for.
+ * @param {object} config (optional) Config object
+ */
+ constructor: function(comp, config) {
+ this.comp = comp;
+ this.initialConstrainTo = config.constrainTo;
+ this.callParent([ config ]);
},
- syncHandleHeight : function(){
- var h = this.el.getHeight(true);
- if(this.west){
- this.west.el.setHeight(h);
- }
- if(this.east){
- this.east.el.setHeight(h);
- }
- }
-});
+ onStart: function(e) {
+ var me = this,
+ comp = me.comp;
-// 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'
-};
+ // Cache the start [X, Y] array
+ this.startPosition = comp.getPosition();
-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 client Component has a ghost method to show a lightweight version of itself
+ // then use that as a drag proxy unless configured to liveDrag.
+ if (comp.ghost && !comp.liveDrag) {
+ me.proxy = comp.ghost();
+ me.dragTarget = me.proxy.header.el;
}
- 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
- });
+
+ // Set the constrainTo Region before we start dragging.
+ if (me.constrain || me.constrainDelegate) {
+ me.constrainTo = me.calculateConstrainRegion();
}
},
- // private
- afterResize : function(rz){
- // do nothing
- },
- // private
- onMouseDown : function(e){
- this.rz.onMouseDown(this, e);
- },
- // private
- onMouseOver : function(e){
- this.rz.handleOver(this, e);
+ calculateConstrainRegion: function() {
+ var me = this,
+ comp = me.comp,
+ c = me.initialConstrainTo,
+ delegateRegion,
+ elRegion,
+ shadowSize = comp.el.shadow ? comp.el.shadow.offset : 0;
+
+ // The configured constrainTo might be a Region or an element
+ if (!(c instanceof Ext.util.Region)) {
+ c = Ext.fly(c).getViewRegion();
+ }
+
+ // Reduce the constrain region to allow for shadow
+ if (shadowSize) {
+ c.adjust(0, -shadowSize, -shadowSize, shadowSize);
+ }
+
+ // If they only want to constrain the *delegate* to within the constrain region,
+ // adjust the region to be larger based on the insets of the delegate from the outer
+ // edges of the Component.
+ if (!me.constrainDelegate) {
+ delegateRegion = Ext.fly(me.dragTarget).getRegion();
+ elRegion = me.proxy ? me.proxy.el.getRegion() : comp.el.getRegion();
+
+ c.adjust(
+ delegateRegion.top - elRegion.top,
+ delegateRegion.right - elRegion.right,
+ delegateRegion.bottom - elRegion.bottom,
+ delegateRegion.left - elRegion.left
+ );
+ }
+ return c;
},
- // private
- onMouseOut : function(e){
- this.rz.handleOut(this, e);
+
+ // Move either the ghost Component or the target Component to its new position on drag
+ onDrag: function(e) {
+ var me = this,
+ comp = (me.proxy && !me.comp.liveDrag) ? me.proxy : me.comp,
+ offset = me.getOffset(me.constrain || me.constrainDelegate ? 'dragTarget' : null);
+
+ comp.setPosition(me.startPosition[0] + offset[0], me.startPosition[1] + offset[1]);
},
- // private
- destroy : function(){
- Ext.destroy(this.el);
- this.el = null;
+
+ onEnd: function(e) {
+ if (this.proxy && !this.comp.liveDrag) {
+ this.comp.unghost();
+ }
}
});
/**
- * @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.form.Labelable
+
+A mixin which allows a component to be configured and decorated with a label and/or error message as is
+common for form fields. This is used by e.g. {@link Ext.form.field.Base} and {@link Ext.form.FieldContainer}
+to let them be managed by the Field layout.
+
+**NOTE**: This mixin is mainly for internal library use and most users should not need to use it directly. It
+is more likely you will want to use one of the component classes that import this mixin, such as
+{@link Ext.form.field.Base} or {@link Ext.form.FieldContainer}.
+
+Use of this mixin does not make a component a field in the logical sense, meaning it does not provide any
+logic or state related to values or validation; that is handled by the related {@link Ext.form.field.Field}
+mixin. These two mixins may be used separately (for example {@link Ext.form.FieldContainer} is Labelable but not a
+Field), or in combination (for example {@link Ext.form.field.Base} implements both and has logic for connecting the
+two.)
+
+Component classes which use this mixin should use the Field layout
+or a derivation thereof to properly size and position the label and message according to the component config.
+They must also call the {@link #initLabelable} method during component initialization to ensure the mixin gets
+set up correctly.
+
+ * @markdown
+ * @docauthor Jason Johnston
*/
-Ext.Window = Ext.extend(Ext.Panel, {
+Ext.define("Ext.form.Labelable", {
+ requires: ['Ext.XTemplate'],
+
+ /**
+ * @cfg {Array/String/Ext.XTemplate} labelableRenderTpl
+ * The rendering template for the field decorations. Component classes using this mixin should include
+ * logic to use this as their {@link Ext.AbstractComponent#renderTpl renderTpl}, and implement the
+ * {@link #getSubTplMarkup} method to generate the field body content.
+ */
+ labelableRenderTpl: [
+ '',
+ ' class="{labelCls}" style="{labelStyle}">',
+ '{fieldLabel}{labelSeparator}',
+ '',
+ '',
+ '
',
+ '',
+ '',
+ {
+ compiled: true,
+ disableFormats: true
+ }
+ ],
+
/**
- * @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).
+ * @cfg {Ext.XTemplate} activeErrorsTpl
+ * The template used to format the Array of error messages passed to {@link #setActiveErrors}
+ * into a single HTML string. By default this renders each message as an item in an unordered list.
*/
+ activeErrorsTpl: [
+ '',
+ '
class="last"
>{.}
',
+ ''
+ ],
+
/**
- * @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).
+ * @property isFieldLabelable
+ * @type Boolean
+ * Flag denoting that this object is labelable as a field. Always true.
*/
+ isFieldLabelable: true,
+
/**
- * @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).
+ * @cfg {String} formItemCls
+ * A CSS class to be applied to the outermost element to denote that it is participating in the form
+ * field layout. Defaults to 'x-form-item'.
*/
+ formItemCls: Ext.baseCSSPrefix + 'form-item',
+
/**
- * @cfg {String/Element} animateTarget
- * Id or element from which the window should animate while opening (defaults to null with no animation).
+ * @cfg {String} labelCls
+ * The CSS class to be applied to the label element. Defaults to 'x-form-item-label'.
*/
+ labelCls: Ext.baseCSSPrefix + 'form-item-label',
+
/**
- * @cfg {String} resizeHandles
- * A valid {@link Ext.Resizable} handles config string (defaults to 'all'). Only applies when resizable = true.
+ * @cfg {String} errorMsgCls
+ * The CSS class to be applied to the error message element. Defaults to 'x-form-error-msg'.
*/
+ errorMsgCls: Ext.baseCSSPrefix + 'form-error-msg',
+
/**
- * @cfg {Ext.WindowGroup} manager
- * A reference to the WindowGroup that should manage this window (defaults to {@link Ext.WindowMgr}).
+ * @cfg {String} baseBodyCls
+ * The CSS class to be applied to the body content element. Defaults to 'x-form-item-body'.
*/
+ baseBodyCls: Ext.baseCSSPrefix + 'form-item-body',
+
/**
- * @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.
+ * @cfg {String} fieldBodyCls
+ * An extra CSS class to be applied to the body content element in addition to {@link #fieldBodyCls}.
+ * Defaults to empty.
*/
+ fieldBodyCls: '',
+
/**
- * @cfg {Boolean} maximized
- * True to initially display the window in a maximized state. (Defaults to false).
+ * @cfg {String} clearCls
+ * The CSS class to be applied to the special clearing div rendered directly after the field
+ * contents wrapper to provide field clearing (defaults to 'x-clear').
*/
+ clearCls: Ext.baseCSSPrefix + 'clear',
/**
- * @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).
+ * @cfg {String} invalidCls
+ * The CSS class to use when marking the component invalid (defaults to 'x-form-invalid')
*/
- resizable : true,
+ invalidCls : Ext.baseCSSPrefix + 'form-invalid',
+
/**
- * @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);).
+ * @cfg {String} fieldLabel
+ * The label for the field. It gets appended with the {@link #labelSeparator}, and its position
+ * and sizing is determined by the {@link #labelAlign}, {@link #labelWidth}, and {@link #labelPad}
+ * configs. Defaults to undefined.
*/
- draggable : true,
+ fieldLabel: undefined,
+
/**
- * @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'.
+ * @cfg {String} labelAlign
+ *
Controls the position and alignment of the {@link #fieldLabel}. Valid values are:
+ *
+ *
"left" (the default) - The label is positioned to the left of the field, with its text
+ * aligned to the left. Its width is determined by the {@link #labelWidth} config.
+ *
"top" - The label is positioned above the field.
+ *
"right" - The label is positioned to the left of the field, with its text aligned
+ * to the right. Its width is determined by the {@link #labelWidth} config.
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}.
+ * @cfg {Number} labelWidth
+ * The width of the {@link #fieldLabel} in pixels. Only applicable if the {@link #labelAlign} is set
+ * to "left" or "right". Defaults to 100.
*/
- closeAction : 'close',
+ labelWidth: 100,
+
/**
- * @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}.
+ * @cfg {Number} labelPad
+ * The amount of space in pixels between the {@link #fieldLabel} and the input field. Defaults to 5.
*/
- constrain : false,
+ labelPad : 5,
+
/**
- * @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}.
+ * @cfg {String} labelSeparator
+ * Character(s) to be inserted at the end of the {@link #fieldLabel label text}.
*/
- constrainHeader : false,
+ labelSeparator : ':',
+
/**
- * @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).
+ * @cfg {String} labelStyle
+ *
A CSS style specification string to apply directly to this field's label. Defaults to undefined.
*/
- plain : false,
+
/**
- * @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.
+ * @cfg {Boolean} hideLabel
+ *
Set to true to completely hide the label element ({@link #fieldLabel} and {@link #labelSeparator}).
+ * Defaults to false.
+ *
Also see {@link #hideEmptyLabel}, which controls whether space will be reserved for an empty fieldLabel.
*/
- minimizable : false,
+ hideLabel: false,
+
/**
- * @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.
+ * @cfg {Boolean} hideEmptyLabel
+ *
When set to true, the label element ({@link #fieldLabel} and {@link #labelSeparator}) will be
+ * automatically hidden if the {@link #fieldLabel} is empty. Setting this to false will cause the empty
+ * label element to be rendered and space to be reserved for it; this is useful if you want a field without a label
+ * to line up with other labeled fields in the same form. Defaults to true.
+ *
If you wish to unconditionall hide the label even if a non-empty fieldLabel is configured, then set
+ * the {@link #hideLabel} config to true.
*/
- maximizable : false,
+ hideEmptyLabel: true,
+
/**
- * @cfg {Number} minHeight
- * The minimum height in pixels allowed for this window (defaults to 100). Only applies when resizable = true.
+ * @cfg {Boolean} preventMark
+ * true to disable displaying any {@link #setActiveError error message} set on this object.
+ * Defaults to false.
*/
- minHeight : 100,
+ preventMark: false,
+
/**
- * @cfg {Number} minWidth
- * The minimum width in pixels allowed for this window (defaults to 200). Only applies when resizable = true.
+ * @cfg {Boolean} autoFitErrors
+ * Whether to adjust the component's body area to make room for 'side' or 'under'
+ * {@link #msgTarget error messages}. Defaults to true.
*/
- minWidth : 200,
+ autoFitErrors: true,
+
/**
- * @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).
+ * @cfg {String} msgTarget
The location where the error message text 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.tip.QuickTipManager#init Ext.tip.QuickTipManager.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.
+ *
none Don't display any error message. This might be useful if you are implementing custom error display.
+ *
[element id] Add the error message directly to the innerHTML of the specified element.
+ *
*/
- expandOnShow : true,
-
+ msgTarget: 'qtip',
+
/**
- * @cfg {Number} showAnimDuration The number of seconds that the window show animation takes if enabled.
- * Defaults to 0.25
+ * @cfg {String} activeError
+ * If specified, then the component will be displayed with this value as its active error when
+ * first rendered. Defaults to undefined. Use {@link #setActiveError} or {@link #unsetActiveError} to
+ * change it after component creation.
*/
- showAnimDuration: 0.25,
-
+
+
/**
- * @cfg {Number} hideAnimDuration The number of seconds that the window hide animation takes if enabled.
- * Defaults to 0.25
+ * Performs initialization of this mixin. Component classes using this mixin should call this method
+ * during their own initialization.
*/
- hideAnimDuration: 0.25,
+ initLabelable: function() {
+ this.addCls(this.formItemCls);
- // inherited docs, same default
- collapsible : false,
+ this.addEvents(
+ /**
+ * @event errorchange
+ * Fires when the active error message is changed via {@link #setActiveError}.
+ * @param {Ext.form.Labelable} this
+ * @param {String} error The active error message
+ */
+ 'errorchange'
+ );
+ },
/**
- * @cfg {Boolean} initHidden
- * True to hide the window until show() is explicitly called (defaults to true).
- * @deprecated
+ * Returns the label for the field. Defaults to simply returning the {@link #fieldLabel} config. Can be
+ * overridden to provide
+ * @return {String} The configured field label, or empty string if not defined
*/
- initHidden : undefined,
+ getFieldLabel: function() {
+ return this.fieldLabel || '';
+ },
/**
- * @cfg {Boolean} hidden
- * Render this component hidden (default is true). If true, the
- * {@link #hide} method will be called internally.
+ * @protected
+ * Generates the arguments for the field decorations {@link #labelableRenderTpl rendering template}.
+ * @return {Object} The template arguments
*/
- hidden : true,
+ getLabelableRenderData: function() {
+ var me = this,
+ labelAlign = me.labelAlign,
+ labelPad = me.labelPad,
+ labelStyle;
+
+ // Calculate label styles up front rather than in the Field layout for speed; this
+ // is safe because label alignment/width/pad are not expected to change.
+ if (labelAlign === 'top') {
+ labelStyle = 'margin-bottom:' + labelPad + 'px;';
+ } else {
+ labelStyle = 'margin-right:' + labelPad + 'px;';
+ // Add the width for border-box browsers; will be set by the Field layout for content-box
+ if (Ext.isBorderBox) {
+ labelStyle += 'width:' + me.labelWidth + 'px;';
+ }
+ }
- // 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,
+ return Ext.copyTo(
+ {
+ inputId: me.getInputId(),
+ fieldLabel: me.getFieldLabel(),
+ labelStyle: labelStyle + (me.labelStyle || ''),
+ subTplMarkup: me.getSubTplMarkup()
+ },
+ me,
+ 'hideLabel,hideEmptyLabel,labelCls,fieldBodyCls,baseBodyCls,errorMsgCls,clearCls,labelSeparator',
+ true
+ );
+ },
- // 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',
+ /**
+ * @protected
+ * Returns the additional {@link Ext.AbstractComponent#renderSelectors} for selecting the field
+ * decoration elements from the rendered {@link #labelableRenderTpl}. Component classes using this mixin should
+ * be sure and merge this method's result into the component's {@link Ext.AbstractComponent#renderSelectors}
+ * before rendering.
+ */
+ getLabelableSelectors: function() {
+ return {
/**
- * @event maximize
- * Fires after the window has been maximized.
- * @param {Ext.Window} this
+ * @property labelEl
+ * @type Ext.core.Element
+ * The label Element for this component. Only available after the component has been rendered.
*/
- 'maximize',
+ labelEl: 'label.' + this.labelCls,
+
/**
- * @event minimize
- * Fires after the window has been minimized.
- * @param {Ext.Window} this
+ * @property bodyEl
+ * @type Ext.core.Element
+ * The div Element wrapping the component's contents. Only available after the component has been rendered.
*/
- 'minimize',
+ bodyEl: '.' + this.baseBodyCls,
+
/**
- * @event restore
- * Fires after the window has been restored to its original size after being maximized.
- * @param {Ext.Window} this
+ * @property errorEl
+ * @type Ext.core.Element
+ * The div Element that will contain the component's error message(s). Note that depending on the
+ * configured {@link #msgTarget}, this element may be hidden in favor of some other form of
+ * presentation, but will always be present in the DOM for use by assistive technologies.
*/
- 'restore'
- );
- // 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();
- }
- },
-
- // private
- getState : function(){
- return Ext.apply(Ext.Window.superclass.getState.call(this) || {}, this.getBox(true));
+ errorEl: '.' + this.errorMsgCls
+ };
},
- // private
- onRender : function(ct, position){
- Ext.Window.superclass.onRender.call(this, ct, position);
-
- if(this.plain){
- this.el.addClass('x-window-plain');
- }
-
- // 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);
-
- this.proxy = this.el.createProxy('x-window-proxy');
- this.proxy.enableDisplayMode('block');
-
- 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);
- }
+ /**
+ * @protected
+ * Gets the markup to be inserted into the outer template's bodyEl. Defaults to empty string, should
+ * be implemented by classes including this mixin as needed.
+ * @return {String} The markup to be inserted
+ */
+ getSubTplMarkup: function() {
+ return '';
},
- // private
- initEvents : function(){
- Ext.Window.superclass.initEvents.call(this);
- if(this.animateTarget){
- this.setAnimateTarget(this.animateTarget);
- }
-
- 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);
- }
-
- 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();
- }
+ /**
+ * Get the input id, if any, for this component. This is used as the "for" attribute on the label element.
+ * Implementing subclasses may also use this as e.g. the id for their own input element.
+ * @return {String} The input id
+ */
+ getInputId: function() {
+ return '';
},
- 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);
+ /**
+ * Gets the active error message for this component, if any. This does not trigger
+ * validation on its own, it merely returns any message that the component may already hold.
+ * @return {String} The active error message on the component; if there is no error, an empty string is returned.
+ */
+ getActiveError : function() {
+ return this.activeError || '';
},
- // private
- onEsc : function(k, e){
- e.stopEvent();
- this[this.closeAction]();
+ /**
+ * Tells whether the field currently has an active error message. This does not trigger
+ * validation on its own, it merely looks for any message that the component may already hold.
+ * @return {Boolean}
+ */
+ hasActiveError: function() {
+ return !!this.getActiveError();
},
- // 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);
+ /**
+ * Sets the active error message to the given string. This replaces the entire error message
+ * contents with the given string. Also see {@link #setActiveErrors} which accepts an Array of
+ * messages and formats them according to the {@link #activeErrorsTpl}.
+ *
+ * Note that this only updates the error message element's text and attributes, you'll have
+ * to call doComponentLayout to actually update the field's layout to match. If the field extends
+ * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#markInvalid markInvalid} instead.
+ *
+ * @param {String} msg The error message
+ */
+ setActiveError: function(msg) {
+ this.activeError = msg;
+ this.activeErrors = [msg];
+ this.renderActiveError();
},
- // private
- onDestroy : function(){
- if(this.manager){
- this.manager.unregister(this);
- }
- Ext.Window.superclass.onDestroy.call(this);
+ /**
+ * Gets an Array of any active error messages currently applied to the field. This does not trigger
+ * validation on its own, it merely returns any messages that the component may already hold.
+ * @return {Array} The active error messages on the component; if there are no errors, an empty Array is returned.
+ */
+ getActiveErrors: function() {
+ return this.activeErrors || [];
},
- // 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, [])
- });
- }
+ /**
+ * Set the active error message to an Array of error messages. The messages are formatted into
+ * a single message string using the {@link #activeErrorsTpl}. Also see {@link #setActiveError}
+ * which allows setting the entire error contents with a single string.
+ *
+ * Note that this only updates the error message element's text and attributes, you'll have
+ * to call doComponentLayout to actually update the field's layout to match. If the field extends
+ * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#markInvalid markInvalid} instead.
+ *
+ * @param {Array} errors The error messages
+ */
+ setActiveErrors: function(errors) {
+ this.activeErrors = errors;
+ this.activeError = this.getTpl('activeErrorsTpl').apply({errors: errors});
+ this.renderActiveError();
},
- // private
- resizerAction : function(){
- var box = this.proxy.getBox();
- this.proxy.hide();
- this.window.handleResize(box);
- return box;
+ /**
+ * Clears the active error message(s).
+ *
+ * Note that this only clears the error message element's text and attributes, you'll have
+ * to call doComponentLayout to actually update the field's layout to match. If the field extends
+ * {@link Ext.form.field.Base} you should call {@link Ext.form.field.Base#clearInvalid clearInvalid} instead.
+ */
+ unsetActiveError: function() {
+ delete this.activeError;
+ delete this.activeErrors;
+ this.renderActiveError();
},
- // 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
+ * Updates the rendered DOM to match the current activeError. This only updates the content and
+ * attributes, you'll have to call doComponentLayout to actually update the display.
+ */
+ renderActiveError: function() {
+ var me = this,
+ activeError = me.getActiveError(),
+ hasError = !!activeError;
- // private
- updateHandles : function(){
- if(Ext.isIE && this.resizer){
- this.resizer.syncHandleHeight();
- this.el.repaint();
+ if (activeError !== me.lastActiveError) {
+ me.fireEvent('errorchange', me, activeError);
+ me.lastActiveError = activeError;
}
- },
- // 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();
- }
+ if (me.rendered && !me.isDestroyed && !me.preventMark) {
+ // Add/remove invalid class
+ me.el[hasError ? 'addCls' : 'removeCls'](me.invalidCls);
+
+ // Update the aria-invalid attribute
+ me.getActionEl().dom.setAttribute('aria-invalid', hasError);
+
+ // Update the errorEl with the error message text
+ me.errorEl.dom.innerHTML = activeError;
}
- this.focus();
- this.updateHandles();
- this.saveState();
},
/**
- * Focuses the window. If a defaultButton is set, it will receive focus, otherwise the
- * window itself will receive focus.
+ * Applies a set of default configuration values to this Labelable instance. For each of the
+ * properties in the given object, check if this component hasOwnProperty that config; if not
+ * then it's inheriting a default value from its prototype and we should apply the default value.
+ * @param {Object} defaults The defaults to apply to the object.
*/
- 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 (ct != document.body && !Ext.lib.Region.getRegion(ct).contains(Ext.lib.Region.getRegion(el.dom))){
- return;
- }
+ setFieldDefaults: function(defaults) {
+ var me = this;
+ Ext.iterate(defaults, function(key, val) {
+ if (!me.hasOwnProperty(key)) {
+ me[key] = val;
}
- }
- f = f || this.focusEl;
- f.focus.defer(10, f);
+ });
},
/**
- * Sets the target element from which the window should animate while opening.
- * @param {String/Element} el The target element or id
+ * @protected Calculate and return the natural width of the bodyEl. Override to provide custom logic.
+ * Note for implementors: if at all possible this method should be overridden with a custom implementation
+ * that can avoid anything that would cause the browser to reflow, e.g. querying offsetWidth.
*/
- setAnimateTarget : function(el){
- el = Ext.get(el);
- this.animateTarget = el;
- },
+ getBodyNaturalWidth: function() {
+ return this.bodyEl.getWidth();
+ }
- // 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();
- }
- },
+/**
+ * @class Ext.form.field.Field
- /**
- * 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
- */
- 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 mixin provides a common interface for the logical behavior and state of form fields, including:
- // 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);
- }
+- Getter and setter methods for field values
+- Events and methods for tracking value and validity changes
+- Methods for triggering validation
- 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);
- },
+**NOTE**: When implementing custom fields, it is most likely that you will want to extend the {@link Ext.form.field.Base}
+component class rather than using this mixin directly, as BaseField contains additional logic for generating an
+actual DOM complete with {@link Ext.form.Labelable label and error message} display and a form input field,
+plus methods that bind the Field value getters and setters to the input field's value.
- // 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: this.showAnimDuration,
- opacity: 0.5
- }));
- },
+If you do want to implement this mixin directly and don't want to extend {@link Ext.form.field.Base}, then
+you will most likely want to override the following methods with custom implementations: {@link #getValue},
+{@link #setValue}, and {@link #getErrors}. Other methods may be overridden as needed but their base
+implementations should be sufficient for common cases. You will also need to make sure that {@link #initField}
+is called during the component's initialization.
+
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.field.Field', {
/**
- * 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
+ * @property isFormField
+ * @type {Boolean}
+ * Flag denoting that this component is a Field. Always true.
*/
- 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;
- },
+ isFormField : true,
- // 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);
- },
+ /**
+ * @cfg {Mixed} value A value to initialize this field with (defaults to undefined).
+ */
+
+ /**
+ * @cfg {String} name The name of the field (defaults to undefined). By default this is used as the parameter
+ * name when including the {@link #getSubmitData field value} in a {@link Ext.form.Basic#submit form submit()}.
+ * To prevent the field from being included in the form submit, set {@link #submitValue} to false.
+ */
- // 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: this.hideAnimDuration,
- easing: 'easeNone',
- opacity: 0
- }));
- },
+ /**
+ * @cfg {Boolean} disabled True to disable the field (defaults to false). Disabled Fields will not be
+ * {@link Ext.form.Basic#submit submitted}.
+ */
+ disabled : false,
/**
- * Method that is called immediately before the show event is fired.
- * Defaults to Ext.emptyFn.
+ * @cfg {Boolean} submitValue Setting this to false will prevent the field from being
+ * {@link Ext.form.Basic#submit submitted} even when it is not disabled. Defaults to true.
*/
- onShow : Ext.emptyFn,
+ submitValue: true,
/**
- * Method that is called immediately before the hide event is fired.
- * Defaults to Ext.emptyFn.
+ * @cfg {Boolean} validateOnChange
+ *
Specifies whether this field should be validated immediately whenever a change in its value is detected.
+ * Defaults to true. If the validation results in a change in the field's validity, a
+ * {@link #validitychange} event will be fired. This allows the field to show feedback about the
+ * validity of its contents immediately as the user is typing.
+ *
When set to false, feedback will not be immediate. However the form will still be validated
+ * before submitting if the clientValidation option to {@link Ext.form.Basic#doAction} is
+ * enabled, or if the field or form are validated manually.
+ *
See also {@link Ext.form.field.Base#checkChangeEvents}for controlling how changes to the field's value are detected.
*/
- onHide : Ext.emptyFn,
+ validateOnChange: true,
- // private
- onWindowResize : function(){
- if(this.maximized){
- this.fitContainer();
- }
- 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();
- },
+ /**
+ * @private
+ */
+ suspendCheckChange: 0,
- // 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)
- };
- }
+ /**
+ * Initializes this Field mixin on the current instance. Components using this mixin should call
+ * this method during their own initialization process.
+ */
+ initField: function() {
+ this.addEvents(
+ /**
+ * @event change
+ * Fires when a user-initiated change is detected in the value of the field.
+ * @param {Ext.form.field.Field} this
+ * @param {Mixed} newValue The new value
+ * @param {Mixed} oldValue The original value
+ */
+ 'change',
+ /**
+ * @event validitychange
+ * Fires when a change in the field's validity is detected.
+ * @param {Ext.form.field.Field} this
+ * @param {Boolean} isValid Whether or not the field is now valid
+ */
+ 'validitychange',
+ /**
+ * @event dirtychange
+ * Fires when a change in the field's {@link #isDirty} state is detected.
+ * @param {Ext.form.field.Field} this
+ * @param {Boolean} isDirty Whether or not the field is now dirty
+ */
+ 'dirtychange'
+ );
- var xy = this.el.getConstrainToXY(this.container, true, offsets);
- if(xy){
- this.setPosition(xy[0], xy[1]);
- }
- }
+ this.initValue();
},
- // 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;
- },
+ /**
+ * @protected
+ * Initializes the field's value based on the initial config.
+ */
+ initValue: function() {
+ var me = this;
- // 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;
+ /**
+ * @property originalValue
+ * @type Mixed
+ * 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.Basic#trackResetOnLoad trackResetOnLoad}
+ * setting is true.
+ */
+ me.originalValue = me.lastValue = me.value;
+
+ // Set the initial value - prevent validation on initial set
+ me.suspendCheckChange++;
+ me.setValue(me.value);
+ me.suspendCheckChange--;
},
/**
- * 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
+ * Returns the {@link Ext.form.field.Field#name name} attribute of the field. This is used as the parameter
+ * name when including the field value in a {@link Ext.form.Basic#submit form submit()}.
+ * @return {String} name The field {@link Ext.form.field.Field#name name}
*/
- minimize : function(){
- this.fireEvent('minimize', this);
- return this;
+ getName: function() {
+ return this.name;
},
/**
- *
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}.
+ * Returns the current data value of the field. The type of value returned is particular to the type of the
+ * particular field (e.g. a Date object for {@link Ext.form.field.Date}).
+ * @return {Mixed} value The field value
*/
- close : function(){
- if(this.fireEvent('beforeclose', this) !== false){
- if(this.hidden){
- this.doClose();
- }else{
- this.hide(null, this.doClose, this);
- }
- }
+ getValue: function() {
+ return this.value;
},
-
- // private
- doClose : function(){
- this.fireEvent('close', this);
- this.destroy();
+
+ /**
+ * Sets a data value into the field and runs the change detection and validation.
+ * @param {Mixed} value The value to set
+ * @return {Ext.form.field.Field} this
+ */
+ setValue: function(value) {
+ var me = this;
+ me.value = value;
+ me.checkChange();
+ return me;
},
/**
- * 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
+ * Returns whether two field {@link #getValue values} are logically equal. Field implementations may override
+ * this to provide custom comparison logic appropriate for the particular field's data type.
+ * @param {Mixed} value1 The first value to compare
+ * @param {Mixed} value2 The second value to compare
+ * @return {Boolean} True if the values are equal, false if inequal.
*/
- 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();
-
- 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');
+ isEqual: function(value1, value2) {
+ return String(value1) === String(value2);
+ },
- this.setPosition(0, 0);
- this.fitContainer();
- this.fireEvent('maximize', this);
+ /**
+ *
Returns the parameter(s) that would be included in a standard form submit for this field. Typically this
+ * will be an object with a single name-value pair, the name being this field's {@link #getName name} and the
+ * value being its current stringified value. More advanced field implementations may return more than one
+ * name-value pair.
+ *
Note that the values returned from this method are not guaranteed to have been successfully
+ * {@link #validate validated}.
+ * @return {Object} A mapping of submit parameter names to values; each value should be a string, or an array
+ * of strings if that particular name has multiple values. It can also return null if there are no
+ * parameters to be submitted.
+ */
+ getSubmitData: function() {
+ var me = this,
+ data = null;
+ if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+ data = {};
+ data[me.getName()] = '' + me.getValue();
}
- return this;
+ return data;
},
/**
- * 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
+ *
Returns the value(s) that should be saved to the {@link Ext.data.Model} instance for this field, when
+ * {@link Ext.form.Basic#updateRecord} is called. Typically this will be an object with a single name-value
+ * pair, the name being this field's {@link #getName name} and the value being its current data value. More
+ * advanced field implementations may return more than one name-value pair. The returned values will be
+ * saved to the corresponding field names in the Model.
+ *
Note that the values returned from this method are not guaranteed to have been successfully
+ * {@link #validate validated}.
+ * @return {Object} A mapping of submit parameter names to values; each value should be a string, or an array
+ * of strings if that particular name has multiple values. It can also return null if there are no
+ * parameters to be submitted.
*/
- 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.doConstrain();
- this.fireEvent('restore', this);
+ getModelData: function() {
+ var me = this,
+ data = null;
+ if (!me.disabled && !me.isFileUpload()) {
+ data = {};
+ data[me.getName()] = me.getValue();
}
- return this;
+ return data;
},
/**
- * A shortcut method for toggling between {@link #maximize} and {@link #restore} based on the current maximized
- * state of the window.
- * @return {Ext.Window} this
+ * Resets the current field value to the originally loaded value and clears any validation messages.
+ * See {@link Ext.form.Basic}.{@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}
*/
- toggleMaximize : function(){
- return this[this.maximized ? 'restore' : 'maximize']();
+ reset : function(){
+ var me = this;
+
+ me.setValue(me.originalValue);
+ me.clearInvalid();
+ // delete here so we reset back to the original state
+ delete me.wasValid;
},
- // private
- fitContainer : function(){
- var vs = this.container.getViewSize(false);
- this.setSize(vs.width, vs.height);
+ /**
+ * Resets the field's {@link #originalValue} property so it matches the current {@link #getValue value}.
+ * This is called by {@link Ext.form.Basic}.{@link Ext.form.Basic#setValues setValues} if the form's
+ * {@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad} property is set to true.
+ */
+ resetOriginalValue: function() {
+ this.originalValue = this.getValue();
+ this.checkDirty();
},
- // 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);
+ /**
+ *
Checks whether the value of the field has changed since the last time it was checked. If the value
+ * has changed, it:
+ *
+ *
Fires the {@link #change change event},
+ *
Performs validation if the {@link #validateOnChange} config is enabled, firing the
+ * {@link #validationchange validationchange event} if the validity has changed, and
+ *
Checks the {@link #isDirty dirty state} of the field and fires the {@link #dirtychange dirtychange event}
+ * if it has changed.
+ *
+ */
+ checkChange: function() {
+ if (!this.suspendCheckChange) {
+ var me = this,
+ newVal = me.getValue(),
+ oldVal = me.lastValue;
+ if (!me.isEqual(newVal, oldVal) && !me.isDestroyed) {
+ me.lastValue = newVal;
+ me.fireEvent('change', me, newVal, oldVal);
+ me.onChange(newVal, oldVal);
+ }
}
- this.el.setZIndex(++index);
- index += 5;
+ },
- if(this.resizer){
- this.resizer.proxy.setStyle('z-index', ++index);
+ /**
+ * @private
+ * Called when the field's value changes. Performs validation if the {@link #validateOnChange}
+ * config is enabled, and invokes the dirty check.
+ */
+ onChange: function(newVal, oldVal) {
+ if (this.validateOnChange) {
+ this.validate();
}
-
- this.lastZIndex = index;
+ this.checkDirty();
},
/**
- * 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
+ *
Returns true if the value of this Field has been changed from its {@link #originalValue}.
+ * Will always return false if the field is disabled.
+ *
Note that if the owning {@link Ext.form.Basic form} was configured with
+ * {@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}
+ * then the {@link #originalValue} is updated when the values are loaded by
+ * {@link Ext.form.Basic}.{@link Ext.form.Basic#setValues setValues}.
+ * @return {Boolean} True if this field has been changed from its original value (and
+ * is not disabled), false otherwise.
*/
- alignTo : function(element, position, offsets){
- var xy = this.el.getAlignToXY(element, position, offsets);
- this.setPagePosition(xy[0], xy[1]);
- return this;
+ isDirty : function() {
+ var me = this;
+ return !me.disabled && !me.isEqual(me.getValue(), me.originalValue);
},
/**
- * 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
- */
- 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});
+ * Checks the {@link #isDirty} state of the field and if it has changed since the last time
+ * it was checked, fires the {@link #dirtychange} event.
+ */
+ checkDirty: function() {
+ var me = this,
+ isDirty = me.isDirty();
+ if (isDirty !== me.wasDirty) {
+ me.fireEvent('dirtychange', me, isDirty);
+ me.onDirtyChange(isDirty);
+ me.wasDirty = isDirty;
}
- return this.doAnchor();
},
/**
- * Performs the anchor, using the saved anchorTarget property.
- * @return {Ext.Window} this
- * @private
+ * @private Called when the field's dirty state changes.
+ * @param {Boolean} isDirty
*/
- doAnchor : function(){
- var o = this.anchorTarget;
- this.alignTo(o.el, o.alignment, o.offsets);
- return this;
- },
+ onDirtyChange: Ext.emptyFn,
/**
- * Removes any existing anchor from this window. See {@link #anchorTo}.
- * @return {Ext.Window} this
+ *
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.
+ * @param {Mixed} value The value to get errors for (defaults to the current field value)
+ * @return {Array} All error messages for this field; an empty Array if none.
*/
- clearAnchor : function(){
- if(this.anchorTarget){
- Ext.EventManager.removeResizeListener(this.doAnchor, this);
- Ext.EventManager.un(window, 'scroll', this.doAnchor, this);
- delete this.anchorTarget;
- }
- return this;
+ getErrors: function(value) {
+ return [];
},
/**
- * 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
+ *
Returns whether or not the field value is currently valid by {@link #getErrors validating} the
+ * field's current value. The {@link #validitychange} event will not be fired; use {@link #validate}
+ * instead if you want the event to fire. Note: {@link #disabled} fields are always treated as valid.
+ *
Implementations are encouraged to ensure that this method does not have side-effects such as
+ * triggering error message display.
+ * @return {Boolean} True if the value is valid, else false
*/
- toFront : function(e){
- if(this.manager.bringToFront(this)){
- if(!e || !e.getTarget().focus){
- this.focus();
- }
- }
- return this;
+ isValid : function() {
+ var me = this;
+ return me.disabled || Ext.isEmpty(me.getErrors());
},
/**
- * 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)
+ *
Returns whether or not the field value is currently valid by {@link #getErrors validating} the
+ * field's current value, and fires the {@link #validitychange} event if the field's validity has
+ * changed since the last validation. Note: {@link #disabled} fields are always treated as valid.
+ *
Custom implementations of this method are allowed to have side-effects such as triggering error
+ * message display. To validate without side-effects, use {@link #isValid}.
+ * @return {Boolean} True if the value is valid, else false
*/
- setActive : function(active){
- if(active){
- if(!this.maximized){
- this.el.enableShadow(true);
- }
- this.fireEvent('activate', this);
- }else{
- this.el.disableShadow();
- this.fireEvent('deactivate', this);
+ validate : function() {
+ var me = this,
+ isValid = me.isValid();
+ if (isValid !== me.wasValid) {
+ me.wasValid = isValid;
+ me.fireEvent('validitychange', me, isValid);
}
+ return isValid;
},
/**
- * Sends this window to the back of (lower z-index than) any other visible windows
- * @return {Ext.Window} this
+ * A utility for grouping a set of modifications which may trigger value changes into a single
+ * transaction, to prevent excessive firing of {@link #change} events. This is useful for instance
+ * if the field has sub-fields which are being updated as a group; you don't want the container
+ * field to check its own changed state for each subfield change.
+ * @param fn A function containing the transaction code
*/
- toBack : function(){
- this.manager.sendToBack(this);
- return this;
+ batchChanges: function(fn) {
+ this.suspendCheckChange++;
+ fn();
+ this.suspendCheckChange--;
+ this.checkChange();
},
/**
- * Centers this window in the viewport
- * @return {Ext.Window} this
+ * Returns whether this Field is a file upload field; if it returns true, forms will use
+ * special techniques for {@link Ext.form.Basic#submit submitting the form} via AJAX. See
+ * {@link Ext.form.Basic#hasUpload} for details. If this returns true, the {@link #extractFileInput}
+ * method must also be implemented to return the corresponding file input element.
+ * @return {Boolean}
*/
- center : function(){
- var xy = this.el.getAlignToXY(this.container, 'c-c');
- this.setPagePosition(xy[0], xy[1]);
- return this;
- }
+ isFileUpload: function() {
+ return false;
+ },
/**
- * @cfg {Boolean} autoWidth @hide
- **/
-});
-Ext.reg('window', Ext.Window);
-
-// private - custom Window DD implementation
-Ext.Window.DD = Ext.extend(Ext.dd.DD, {
-
- constructor : 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;
- },
-
- moveOnly:true,
- headerOffsets:[100, 25],
- startDrag : function(){
- var w = this.win;
- this.proxy = w.ghost(w.initialConfig.cls);
- 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])});
- }
+ * Only relevant if the instance's {@link #isFileUpload} method returns true. Returns a reference
+ * to the file input DOM element holding the user's selected file. The input will be appended into
+ * the submission form and will not be returned, so this method should also create a replacement.
+ * @return {HTMLInputElement}
+ */
+ extractFileInput: function() {
+ return null;
},
- b4Drag : Ext.emptyFn,
- onDrag : function(e){
- this.alignElWithMouse(this.proxy, e.getPageX(), e.getPageY());
- },
+ /**
+ *
Associate one or more error messages with this field. Components using this mixin should implement
+ * this method to update the component's rendering to display the messages.
+ *
Note: this method does not cause the Field's {@link #validate} or {@link #isValid} methods 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.
+ * @param {String/Array} errors The error message(s) for the field.
+ * @method
+ */
+ markInvalid: Ext.emptyFn,
+
+ /**
+ *
Clear any invalid styles/messages for this field. Components using this mixin should implement
+ * this method to update the components rendering to clear any existing messages.
+ *
Note: this method does not cause the Field's {@link #validate} or {@link #isValid} methods to
+ * return true if the value does not pass validation. So simply clearing a field's errors
+ * will not necessarily allow submission of forms submitted with the {@link Ext.form.action.Submit#clientValidation}
+ * option set.
+ * @method
+ */
+ clearInvalid: Ext.emptyFn
- 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
+ * @class Ext.layout.component.field.Field
+ * @extends Ext.layout.component.Component
+ * Layout class for components with {@link Ext.form.Labelable field labeling}, handling the sizing and alignment of
+ * the form control, label, and error message treatment.
+ * @private
*/
-Ext.WindowGroup = function(){
- var list = {};
- var accessList = [];
- var front = null;
+Ext.define('Ext.layout.component.field.Field', {
- // private
- var sortWindows = function(d1, d2){
- return (!d1._lastAccess || d1._lastAccess < d2._lastAccess) ? -1 : 1;
- };
+ /* Begin Definitions */
- // 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();
- };
+ alias: ['layout.field'],
- // private
- var setActiveWin = function(win){
- if(win != front){
- if(front){
- front.setActive(false);
- }
- front = win;
- if(win){
- win.setActive(true);
- }
- }
- };
+ extend: 'Ext.layout.component.Component',
- // private
- var activateLast = function(){
- for(var i = accessList.length-1; i >=0; --i) {
- if(!accessList[i].hidden){
- setActiveWin(accessList[i]);
- return;
+ uses: ['Ext.tip.QuickTip', 'Ext.util.TextMetrics'],
+
+ /* End Definitions */
+
+ type: 'field',
+
+ beforeLayout: function(width, height) {
+ var me = this;
+ return me.callParent(arguments) || (!me.owner.preventMark && me.activeError !== me.owner.getActiveError());
+ },
+
+ onLayout: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ labelStrategy = me.getLabelStrategy(),
+ errorStrategy = me.getErrorStrategy(),
+ isDefined = Ext.isDefined,
+ isNumber = Ext.isNumber,
+ lastSize, autoWidth, autoHeight, info, undef;
+
+ lastSize = me.lastComponentSize || {};
+ if (!isDefined(width)) {
+ width = lastSize.width;
+ if (width < 0) { //first pass lastComponentSize.width is -Infinity
+ width = undef;
+ }
+ }
+ if (!isDefined(height)) {
+ height = lastSize.height;
+ if (height < 0) { //first pass lastComponentSize.height is -Infinity
+ height = undef;
+ }
+ }
+ autoWidth = !isNumber(width);
+ autoHeight = !isNumber(height);
+
+ info = {
+ autoWidth: autoWidth,
+ autoHeight: autoHeight,
+ width: autoWidth ? owner.getBodyNaturalWidth() : width, //always give a pixel width
+ height: height,
+ setOuterWidth: false, //whether the outer el width should be set to the calculated width
+
+ // insets for the bodyEl from each side of the component layout area
+ insets: {
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0
}
+ };
+
+ // NOTE the order of calculating insets and setting styles here is very important; we must first
+ // calculate and set horizontal layout alone, as the horizontal sizing of elements can have an impact
+ // on the vertical sizes due to wrapping, then calculate and set the vertical layout.
+
+ // perform preparation on the label and error (setting css classes, qtips, etc.)
+ labelStrategy.prepare(owner, info);
+ errorStrategy.prepare(owner, info);
+
+ // calculate the horizontal insets for the label and error
+ labelStrategy.adjustHorizInsets(owner, info);
+ errorStrategy.adjustHorizInsets(owner, info);
+
+ // set horizontal styles for label and error based on the current insets
+ labelStrategy.layoutHoriz(owner, info);
+ errorStrategy.layoutHoriz(owner, info);
+
+ // calculate the vertical insets for the label and error
+ labelStrategy.adjustVertInsets(owner, info);
+ errorStrategy.adjustVertInsets(owner, info);
+
+ // set vertical styles for label and error based on the current insets
+ labelStrategy.layoutVert(owner, info);
+ errorStrategy.layoutVert(owner, info);
+
+ // perform sizing of the elements based on the final dimensions and insets
+ if (autoWidth && autoHeight) {
+ // Don't use setTargetSize if auto-sized, so the calculated size is not reused next time
+ me.setElementSize(owner.el, (info.setOuterWidth ? info.width : undef), info.height);
+ } else {
+ me.setTargetSize((!autoWidth || info.setOuterWidth ? info.width : undef), info.height);
}
- // none to activate
- setActiveWin(null);
- };
+ me.sizeBody(info);
- return {
- /**
- * The starting z-index for windows in this WindowGroup (defaults to 9000)
- * @type Number The z-index value
- */
- zseed : 9000,
+ me.activeError = owner.getActiveError();
+ },
- /**
- *
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:
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);
- },
+ // size the bodyEl
+ me.setElementSize(owner.bodyEl, width, height);
- /**
- * 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];
- },
+ // size the bodyEl's inner contents if necessary
+ me.sizeBodyContents(width, height);
+ },
- /**
- * 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;
- },
+ /**
+ * Size the contents of the field body, given the full dimensions of the bodyEl. Does nothing by
+ * default, subclasses can override to handle their specific contents.
+ * @param {Number} width The bodyEl width
+ * @param {Number} height The bodyEl height
+ */
+ sizeBodyContents: Ext.emptyFn,
- /**
- * 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();
- }
- }
- },
+ /**
+ * Return the set of strategy functions from the {@link #labelStrategies labelStrategies collection}
+ * that is appropriate for the field's {@link Ext.form.Labelable#labelAlign labelAlign} config.
+ */
+ getLabelStrategy: function() {
+ var me = this,
+ strategies = me.labelStrategies,
+ labelAlign = me.owner.labelAlign;
+ return strategies[labelAlign] || strategies.base;
+ },
- /**
- * Gets the currently-active window in this WindowGroup.
- * @return {Ext.Window} The active window
- */
- getActive : function(){
- return front;
- },
+ /**
+ * Return the set of strategy functions from the {@link #errorStrategies errorStrategies collection}
+ * that is appropriate for the field's {@link Ext.form.Labelable#msgTarget msgTarget} config.
+ */
+ getErrorStrategy: function() {
+ var me = this,
+ owner = me.owner,
+ strategies = me.errorStrategies,
+ msgTarget = owner.msgTarget;
+ return !owner.preventMark && Ext.isString(msgTarget) ?
+ (strategies[msgTarget] || strategies.elementId) :
+ strategies.none;
+ },
- /**
- * 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;
+
+ /**
+ * Collection of named strategies for laying out and adjusting labels to accommodate error messages.
+ * An appropriate one will be chosen based on the owner field's {@link Ext.form.Labelable#labelAlign} config.
+ */
+ labelStrategies: (function() {
+ var applyIf = Ext.applyIf,
+ emptyFn = Ext.emptyFn,
+ base = {
+ prepare: function(owner, info) {
+ var cls = owner.labelCls + '-' + owner.labelAlign,
+ labelEl = owner.labelEl;
+ if (labelEl && !labelEl.hasCls(cls)) {
+ labelEl.addCls(cls);
+ }
+ },
+ adjustHorizInsets: emptyFn,
+ adjustVertInsets: emptyFn,
+ layoutHoriz: emptyFn,
+ layoutVert: emptyFn
+ },
+ left = applyIf({
+ prepare: function(owner, info) {
+ base.prepare(owner, info);
+ // If auto width, add the label width to the body's natural width.
+ if (info.autoWidth) {
+ info.width += (!owner.labelEl ? 0 : owner.labelWidth + owner.labelPad);
+ }
+ // Must set outer width to prevent field from wrapping below floated label
+ info.setOuterWidth = true;
+ },
+ adjustHorizInsets: function(owner, info) {
+ if (owner.labelEl) {
+ info.insets.left += owner.labelWidth + owner.labelPad;
+ }
+ },
+ layoutHoriz: function(owner, info) {
+ // For content-box browsers we can't rely on Labelable.js#getLabelableRenderData
+ // setting the width style because it needs to account for the final calculated
+ // padding/border styles for the label. So we set the width programmatically here to
+ // normalize content-box sizing, while letting border-box browsers use the original
+ // width style.
+ var labelEl = owner.labelEl;
+ if (labelEl && !owner.isLabelSized && !Ext.isBorderBox) {
+ labelEl.setWidth(owner.labelWidth);
+ owner.isLabelSized = true;
}
}
- }
- }
- };
-};
+ }, base);
-/**
- * @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.');
+ return {
+ base: base,
-// 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...
- }
-});
+ /**
+ * Label displayed above the bodyEl
+ */
+ top: applyIf({
+ adjustVertInsets: function(owner, info) {
+ var labelEl = owner.labelEl;
+ if (labelEl) {
+ info.insets.top += Ext.util.TextMetrics.measure(labelEl, owner.fieldLabel, info.width).height +
+ labelEl.getFrameWidth('tb') + owner.labelPad;
+ }
+ }
+ }, base),
-// 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
-});
-
'
- });
- 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'});
+ function setStyle(el, name, value) {
+ if (el.getStyle(name) !== value) {
+ el.setStyle(name, value);
}
- 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
- }
- // Append a space here for sizing. In IE, for some reason, it wraps text incorrectly without one in some cases
- msgEl.update(text ? 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;
-
- w = Math.max(Math.min(opt.width || iw+mw+fw+bw, opt.maxWidth || this.maxWidth),
- Math.max(opt.minWidth || this.minWidth, bwidth || 0));
+ var applyIf = Ext.applyIf,
+ emptyFn = Ext.emptyFn,
+ base = {
+ prepare: function(owner) {
+ setDisplayed(owner.errorEl, false);
+ },
+ adjustHorizInsets: emptyFn,
+ adjustVertInsets: emptyFn,
+ layoutHoriz: emptyFn,
+ layoutVert: emptyFn
+ };
- 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.
- }
- msgEl.update(text || ' ');
- dlg.setSize(w, 'auto').center();
- return this;
- },
+ return {
+ none: base,
- /**
- * 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;
- },
+ /**
+ * Error displayed as icon (with QuickTip on hover) to right of the bodyEl
+ */
+ side: applyIf({
+ prepare: function(owner) {
+ var errorEl = owner.errorEl;
+ errorEl.addCls(Ext.baseCSSPrefix + 'form-invalid-icon');
+ Ext.layout.component.field.Field.initTip();
+ errorEl.dom.setAttribute('data-errorqtip', owner.getActiveError() || '');
+ setDisplayed(errorEl, owner.hasActiveError());
+ },
+ adjustHorizInsets: function(owner, info) {
+ if (owner.autoFitErrors && owner.hasActiveError()) {
+ info.insets.right += owner.errorEl.getWidth();
+ }
+ },
+ layoutHoriz: function(owner, info) {
+ if (owner.hasActiveError()) {
+ setStyle(owner.errorEl, 'left', info.width - info.insets.right + 'px');
+ }
+ },
+ layoutVert: function(owner, info) {
+ if (owner.hasActiveError()) {
+ setStyle(owner.errorEl, 'top', info.insets.top + 'px');
+ }
+ }
+ }, base),
- /**
- * 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();
- },
+ /**
+ * Error message displayed underneath the bodyEl
+ */
+ under: applyIf({
+ prepare: function(owner) {
+ var errorEl = owner.errorEl,
+ cls = Ext.baseCSSPrefix + 'form-invalid-under';
+ if (!errorEl.hasCls(cls)) {
+ errorEl.addCls(cls);
+ }
+ setDisplayed(errorEl, owner.hasActiveError());
+ },
+ adjustVertInsets: function(owner, info) {
+ if (owner.autoFitErrors) {
+ info.insets.bottom += owner.errorEl.getHeight();
+ }
+ },
+ layoutHoriz: function(owner, info) {
+ var errorEl = owner.errorEl,
+ insets = info.insets;
- /**
- * 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;
- },
+ setStyle(errorEl, 'width', info.width - insets.right - insets.left + 'px');
+ setStyle(errorEl, 'marginLeft', insets.left + 'px');
+ }
+ }, base),
- /**
- * 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)
- * @param {String} icon A CSS classname specifying the icon's background image url, or empty string to clear the icon
- * @return {Ext.MessageBox} this
+ * Use a custom QuickTip instance separate from the main QuickTips singleton, so that we
+ * can give it a custom frame style. Responds to errorqtip rather than the qtip property.
*/
- 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 = '';
+ initTip: function() {
+ var tip = this.tip;
+ if (!tip) {
+ tip = this.tip = Ext.create('Ext.tip.QuickTip', {
+ baseCls: Ext.baseCSSPrefix + 'form-invalid-tip',
+ renderTo: Ext.getBody()
+ });
+ tip.tagConfig = Ext.apply({}, {attribute: 'errorqtip'}, tip.tagConfig);
}
- 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
+ * Destroy the error tip instance.
*/
- progress : function(title, msg, progressText){
- this.show({
- title : title,
- msg : msg,
- buttons: false,
- progress:true,
- closable:false,
- minWidth: this.minProgressWidth,
- progressText: progressText
- });
- return this;
- },
+ destroyTip: function() {
+ var tip = this.tip;
+ if (tip) {
+ tip.destroy();
+ delete this.tip;
+ }
+ }
+ }
- /**
- * 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;
- },
+/**
+ * @class Ext.form.field.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.field.Text#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.field.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.field.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.define('Ext.form.field.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;
- /**
- * 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;
- },
+ // All these messages and functions are configurable
+ return {
+ singleton: true,
+ alternateClassName: 'Ext.form.VTypes',
/**
- * 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
+ * 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.
*/
- 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;
+ 'email' : function(v){
+ return email.test(v);
},
-
- /**
- * 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
+ * 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
*/
- INFO : 'ext-mb-info',
+ 'emailText' : 'This field should be an e-mail address in the format "user@example.com"',
/**
- * The CSS class that provides the WARNING icon image
- * @type String
+ * 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
*/
- WARNING : 'ext-mb-warning',
+ 'emailMask' : /[a-z0-9_\.\-@\+]/i,
+
/**
- * The CSS class that provides the QUESTION icon image
- * @type String
+ * The function used to validate URLs
+ * @param {String} value The URL
+ * @return {Boolean} true if the RegExp test passed, and false if not.
*/
- QUESTION : 'ext-mb-question',
+ 'url' : function(v){
+ return url.test(v);
+ },
/**
- * The CSS class that provides the ERROR icon image
+ * 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
*/
- ERROR : 'ext-mb-error',
+ 'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"',
/**
- * The default height in pixels of the message box's multiline textarea if displayed (defaults to 75)
- * @type Number
+ * The function used to validate alpha values
+ * @param {String} value The value
+ * @return {Boolean} true if the RegExp test passed, and false if not.
*/
- defaultTextHeight : 75,
+ 'alpha' : function(v){
+ return alpha.test(v);
+ },
/**
- * The maximum width in pixels of the message box (defaults to 600)
- * @type Number
+ * The error text to display when the alpha validation function returns false. Defaults to:
+ * 'This field should only contain letters and _'
+ * @type String
*/
- maxWidth : 600,
+ 'alphaText' : 'This field should only contain letters and _',
/**
- * The minimum width in pixels of the message box (defaults to 100)
- * @type Number
+ * The keystroke filter mask to be applied on alpha input. Defaults to:
+ * /[a-z_]/i
+ * @type RegExp
*/
- minWidth : 100,
+ 'alphaMask' : /[a-z_]/i,
+
/**
- * 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
+ * The function used to validate alphanumeric values
+ * @param {String} value The value
+ * @return {Boolean} true if the RegExp test passed, and false if not.
*/
- minProgressWidth : 250,
+ 'alphanum' : function(v){
+ return alphanum.test(v);
+ },
/**
- * 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
+ * The error text to display when the alphanumeric validation function returns false. Defaults to:
+ * 'This field should only contain letters, numbers and _'
+ * @type String
*/
- minPromptWidth: 250,
+ 'alphanumText' : 'This field should only contain letters, numbers and _',
/**
- * 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
+ * The keystroke filter mask to be applied on alphanumeric input. Defaults to:
+ * /[a-z0-9_]/i
+ * @type RegExp
*/
- buttonText : {
- ok : "OK",
- cancel : "Cancel",
- yes : "Yes",
- no : "No"
- }
+ 'alphanumMask' : /[a-z0-9_]/i
};
-}();
+})());
/**
- * 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
+ * @private
+ * @class Ext.layout.component.field.Text
+ * @extends Ext.layout.component.field.Field
+ * Layout class for {@link Ext.form.field.Text} fields. Handles sizing the input field.
*/
-Ext.dd.PanelProxy = Ext.extend(Object, {
-
- constructor : function(panel, config){
- this.panel = panel;
- this.id = this.panel.id +'-ddproxy';
- Ext.apply(this, config);
- },
-
- /**
- * @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,
+Ext.define('Ext.layout.component.field.Text', {
+ extend: 'Ext.layout.component.field.Field',
+ alias: 'layout.textfield',
+ requires: ['Ext.util.TextMetrics'],
- // 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;
- },
+ type: 'textfield',
- /**
- * Gets the proxy's element
- * @return {Element} The proxy's element
- */
- getProxy : function(){
- return this.proxy;
- },
/**
- * Hides the proxy
+ * Allow layout to proceed if the {@link Ext.form.field.Text#grow} config is enabled and the value has
+ * changed since the last layout.
*/
- 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;
- }
+ beforeLayout: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ lastValue = this.lastValue,
+ value = owner.getRawValue();
+ this.lastValue = value;
+ return me.callParent(arguments) || (owner.grow && value !== lastValue);
},
+
/**
- * Shows the proxy
+ * Size the field body contents given the total dimensions of the bodyEl, taking into account the optional
+ * {@link Ext.form.field.Text#grow} configurations.
+ * @param {Number} width The bodyEl width
+ * @param {Number} height The bodyEl height
*/
- show : function(){
- if(!this.ghost){
- this.ghost = this.panel.createGhost(this.panel.initialConfig.cls, 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';
- }
+ sizeBodyContents: function(width, height) {
+ var size = this.adjustForGrow(width, height);
+ this.setElementSize(this.owner.inputEl, size[0], size[1]);
},
- // 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)
+ * Given the target bodyEl dimensions, adjust them if necessary to return the correct final
+ * size based on the text field's {@link Ext.form.field.Text#grow grow config}.
+ * @param {Number} width The bodyEl width
+ * @param {Number} height The bodyEl height
+ * @return {Array} [inputElWidth, inputElHeight]
*/
- moveProxy : function(parentNode, before){
- if(this.proxy){
- parentNode.insertBefore(this.proxy.dom, before);
+ adjustForGrow: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl, value, calcWidth,
+ result = [width, height];
+
+ if (owner.grow) {
+ inputEl = owner.inputEl;
+
+ // Find the width that contains the whole text value
+ value = (inputEl.dom.value || (owner.hasFocus ? '' : owner.emptyText) || '') + owner.growAppend;
+ calcWidth = inputEl.getTextWidth(value) + inputEl.getBorderWidth("lr") + inputEl.getPadding("lr");
+
+ // Constrain
+ result[0] = Ext.Number.constrain(calcWidth, owner.growMin,
+ Math.max(owner.growMin, Math.min(owner.growMax, Ext.isNumber(width) ? width : Infinity)));
}
+
+ return result;
}
+
});
-// private - DD implementation for Panels
-Ext.Panel.DD = Ext.extend(Ext.dd.DragSource, {
-
- constructor : 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,
- el = panel.body;
- if(h){
- this.setHandleElId(h.id);
- el = panel.header;
+/**
+ * @private
+ * @class Ext.layout.component.field.TextArea
+ * @extends Ext.layout.component.field.Field
+ * Layout class for {@link Ext.form.field.TextArea} fields. Handles sizing the textarea field.
+ */
+Ext.define('Ext.layout.component.field.TextArea', {
+ extend: 'Ext.layout.component.field.Text',
+ alias: 'layout.textareafield',
+
+ type: 'textareafield',
+
+
+ /**
+ * Given the target bodyEl dimensions, adjust them if necessary to return the correct final
+ * size based on the text field's {@link Ext.form.field.Text#grow grow config}. Overrides the
+ * textfield layout's implementation to handle height rather than width.
+ * @param {Number} width The bodyEl width
+ * @param {Number} height The bodyEl height
+ * @return {Array} [inputElWidth, inputElHeight]
+ */
+ adjustForGrow: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl, value, max,
+ curWidth, curHeight, calcHeight,
+ result = [width, height];
+
+ if (owner.grow) {
+ inputEl = owner.inputEl;
+ curWidth = inputEl.getWidth(true); //subtract border/padding to get the available width for the text
+ curHeight = inputEl.getHeight();
+
+ // Get and normalize the field value for measurement
+ value = inputEl.dom.value || ' ';
+ value += owner.growAppend;
+
+ // Translate newlines to tags
+ value = value.replace(/\n/g, ' ');
+
+ // Find the height that contains the whole text value
+ calcHeight = Ext.util.TextMetrics.measure(inputEl, value, curWidth).height +
+ inputEl.getBorderWidth("tb") + inputEl.getPadding("tb");
+
+ // Constrain
+ max = owner.growMax;
+ if (Ext.isNumber(height)) {
+ max = Math.min(max, height);
+ }
+ result[1] = Ext.Number.constrain(calcHeight, owner.growMin, max);
}
- el.setStyle('cursor', 'move');
- this.scroll = false;
- },
-
- showFrame: Ext.emptyFn,
- startDrag: Ext.emptyFn,
- b4StartDrag: function(x, y) {
- this.proxy.show();
- },
- b4MouseDown: function(e) {
- var x = e.getPageX(),
- 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);
+ return result;
}
-});/**
- * @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.
+
+});
+/**
+ * @class Ext.layout.container.Anchor
+ * @extends Ext.layout.container.Container
+ *
+ * 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.layout.container.AbstractContainer#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.
+ *
+ * {@img Ext.layout.container.Anchor/Ext.layout.container.Anchor.png Ext.layout.container.Anchor container layout}
+ *
+ * For example:
+ * Ext.create('Ext.Panel', {
+ * width: 500,
+ * height: 400,
+ * title: "AnchorLayout Panel",
+ * layout: 'anchor',
+ * renderTo: Ext.getBody(),
+ * items: [{
+ * xtype: 'panel',
+ * title: '75% Width and 20% Height',
+ * anchor: '75% 20%'
+ * },{
+ * xtype: 'panel',
+ * title: 'Offset -300 Width & -200 Height',
+ * anchor: '-300 -200'
+ * },{
+ * xtype: 'panel',
+ * title: 'Mixed Offset and Percent',
+ * anchor: '-250 20%'
+ * }]
+ * });
*/
-Ext.state.Provider = Ext.extend(Ext.util.Observable, {
-
- constructor : 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);
- },
-
- /**
- * 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);
- },
+Ext.define('Ext.layout.container.Anchor', {
+
+ /* Begin Definitions */
+
+ alias: 'layout.anchor',
+ extend: 'Ext.layout.container.Container',
+ alternateClassName: 'Ext.layout.AnchorLayout',
+
+ /* End Definitions */
/**
- * Sets the value for a key
- * @param {String} name The key name
- * @param {Mixed} value The value to set
+ * @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%'
+ *
+ *
+ *
+ *
*/
- set : function(name, value){
- this.state[name] = value;
- this.fireEvent("statechange", this, name, value);
- },
+
+ type: 'anchor',
/**
- * Decodes a string previously encoded with {@link #encodeValue}.
- * @param {String} value The value to decode
- * @return {Mixed} The decoded value
+ * @cfg {String} defaultAnchor
+ * Default anchor for all child container items applied if no anchor or specific width is set on the child item. Defaults to '100%'.
*/
- decodeValue : function(cookie){
- /**
- * a -> Array
- * n -> Number
- * d -> Date
- * b -> Boolean
- * s -> String
- * o -> Object
- * -> Empty (null)
- */
- var re = /^(a|n|d|b|s|o|e)\:(.*)$/,
- matches = re.exec(unescape(cookie)),
- all,
- type,
- v,
- kv;
- if(!matches || !matches[1]){
- return; // non state cookie
+ defaultAnchor: '100%',
+
+ parseAnchorRE: /^(r|right|b|bottom)$/i,
+
+ // private
+ onLayout: function() {
+ this.callParent(arguments);
+
+ var me = this,
+ size = me.getLayoutTargetSize(),
+ owner = me.owner,
+ target = me.getTarget(),
+ ownerWidth = size.width,
+ ownerHeight = size.height,
+ overflow = target.getStyle('overflow'),
+ components = me.getVisibleItems(owner),
+ len = components.length,
+ boxes = [],
+ box, newTargetSize, component, anchorSpec, calcWidth, calcHeight,
+ i, el, cleaner;
+
+ if (ownerWidth < 20 && ownerHeight < 20) {
+ return;
}
- type = matches[1];
- v = matches[2];
- switch(type){
- case 'e':
- return null;
- case 'n':
- return parseFloat(v);
- case 'd':
- return new Date(Date.parse(v));
- case 'b':
- return (v == '1');
- case 'a':
- all = [];
- if(v != ''){
- Ext.each(v.split('^'), function(val){
- all.push(this.decodeValue(val));
- }, this);
- }
- return all;
- case 'o':
- all = {};
- if(v != ''){
- Ext.each(v.split('^'), function(val){
- kv = val.split('=');
- all[kv[0]] = this.decodeValue(kv[1]);
- }, this);
- }
- return all;
- default:
- return v;
+
+ // Anchor layout uses natural HTML flow to arrange the child items.
+ // To ensure that all browsers (I'm looking at you IE!) add the bottom margin of the last child to the
+ // containing element height, we create a zero-sized element with style clear:both to force a "new line"
+ if (!me.clearEl) {
+ me.clearEl = target.createChild({
+ cls: Ext.baseCSSPrefix + 'clear',
+ role: 'presentation'
+ });
}
- },
- /**
- * 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,
- flat = '',
- i = 0,
- len,
- key;
- if(v == null){
- return 'e:1';
- }else 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)){
- for(len = v.length; i < len; i++){
- flat += this.encodeValue(v[i]);
- if(i != len - 1){
- flat += '^';
+ // Work around WebKit RightMargin bug. We're going to inline-block all the children only ONCE and remove it when we're done
+ if (!Ext.supports.RightMargin) {
+ cleaner = Ext.core.Element.getRightMarginFixCleaner(target);
+ target.addCls(Ext.baseCSSPrefix + 'inline-children');
+ }
+
+ for (i = 0; i < len; i++) {
+ component = components[i];
+ el = component.el;
+
+ anchorSpec = component.anchorSpec;
+ if (anchorSpec) {
+ if (anchorSpec.right) {
+ calcWidth = me.adjustWidthAnchor(anchorSpec.right(ownerWidth) - el.getMargin('lr'), component);
+ } else {
+ calcWidth = undefined;
}
- }
- enc = 'a:' + flat;
- }else if(typeof v == 'object'){
- for(key in v){
- if(typeof v[key] != 'function' && v[key] !== undefined){
- flat += key + '=' + this.encodeValue(v[key]) + '^';
+ if (anchorSpec.bottom) {
+ calcHeight = me.adjustHeightAnchor(anchorSpec.bottom(ownerHeight) - el.getMargin('tb'), component);
+ } else {
+ calcHeight = undefined;
}
+
+ boxes.push({
+ component: component,
+ anchor: true,
+ width: calcWidth || undefined,
+ height: calcHeight || undefined
+ });
+ } else {
+ boxes.push({
+ component: component,
+ anchor: false
+ });
}
- 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);
- },
+ // Work around WebKit RightMargin bug. We're going to inline-block all the children only ONCE and remove it when we're done
+ if (!Ext.supports.RightMargin) {
+ target.removeCls(Ext.baseCSSPrefix + 'inline-children');
+ cleaner();
+ }
- /**
- * Clears a value from the state
- * @param {String} name The key name
- */
- clear : function(key){
- provider.clear(key);
- },
+ for (i = 0; i < len; i++) {
+ box = boxes[i];
+ me.setItemSize(box.component, box.width, box.height);
+ }
- /**
- * Gets the currently configured state provider
- * @return {Provider} The state provider
- */
- getProvider : function(){
- return provider;
+ if (overflow && overflow != 'hidden' && !me.adjustmentPass) {
+ newTargetSize = me.getLayoutTargetSize();
+ if (newTargetSize.width != size.width || newTargetSize.height != size.height) {
+ me.adjustmentPass = true;
+ me.onLayout();
+ }
}
- };
-}();
-/**
- * @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 = Ext.extend(Ext.state.Provider, {
-
- constructor : 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();
+
+ delete me.adjustmentPass;
},
-
+
// private
- set : function(name, value){
- if(typeof value == "undefined" || value === null){
- this.clear(name);
- return;
+ parseAnchor: function(a, start, cstart) {
+ if (a && a != 'none') {
+ var ratio;
+ // standard anchor
+ if (this.parseAnchorRE.test(a)) {
+ var diff = cstart - start;
+ return function(v) {
+ return v - diff;
+ };
+ }
+ // percentage
+ else if (a.indexOf('%') != -1) {
+ ratio = parseFloat(a.replace('%', '')) * 0.01;
+ return function(v) {
+ return Math.floor(v * ratio);
+ };
+ }
+ // simple offset adjustment
+ else {
+ a = parseInt(a, 10);
+ if (!isNaN(a)) {
+ return function(v) {
+ return v + a;
+ };
+ }
+ }
}
- this.setCookie(name, value);
- Ext.state.CookieProvider.superclass.set.call(this, name, value);
+ return null;
},
// private
- clear : function(name){
- this.clearCookie(name);
- Ext.state.CookieProvider.superclass.clear.call(this, name);
+ adjustWidthAnchor: function(value, comp) {
+ return value;
},
// private
- readCookies : function(){
- var cookies = {},
- c = document.cookie + ";",
- re = /\s?(.*?)=(.*?);/g,
- matches,
- name,
- value;
- while((matches = re.exec(c)) != null){
- name = matches[1];
- value = matches[2];
- if(name && name.substring(0,3) == "ys-"){
- cookies[name.substr(3)] = this.decodeValue(value);
+ adjustHeightAnchor: function(value, comp) {
+ return value;
+ },
+
+ configureItem: function(item) {
+ var me = this,
+ owner = me.owner,
+ anchor= item.anchor,
+ anchorsArray,
+ anchorSpec,
+ anchorWidth,
+ anchorHeight;
+
+ if (!item.anchor && item.items && !Ext.isNumber(item.width) && !(Ext.isIE6 && Ext.isStrict)) {
+ item.anchor = anchor = me.defaultAnchor;
+ }
+
+ // find the container anchoring size
+ if (owner.anchorSize) {
+ if (typeof owner.anchorSize == 'number') {
+ anchorWidth = owner.anchorSize;
+ }
+ else {
+ anchorWidth = owner.anchorSize.width;
+ anchorHeight = owner.anchorSize.height;
}
}
- return cookies;
- },
+ else {
+ anchorWidth = owner.initialConfig.width;
+ anchorHeight = owner.initialConfig.height;
+ }
- // 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" : "");
- },
+ if (anchor) {
+ // cache all anchor values
+ anchorsArray = anchor.split(' ');
+ item.anchorSpec = anchorSpec = {
+ right: me.parseAnchor(anchorsArray[0], item.initialConfig.width, anchorWidth),
+ bottom: me.parseAnchor(anchorsArray[1], item.initialConfig.height, anchorHeight)
+ };
- // 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" : "");
+ if (anchorSpec.right) {
+ item.layoutManagedWidth = 1;
+ } else {
+ item.layoutManagedWidth = 2;
+ }
+
+ if (anchorSpec.bottom) {
+ item.layoutManagedHeight = 1;
+ } else {
+ item.layoutManagedHeight = 2;
+ }
+ } else {
+ item.layoutManagedWidth = 2;
+ item.layoutManagedHeight = 2;
+ }
+ this.callParent(arguments);
}
-});/**
- * @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}.
A class which handles loading of data from a server into the Fields of an {@link Ext.form.Basic}.
+ *
Instances of this class are only created by a {@link Ext.form.Basic Form} when
+ * {@link Ext.form.Basic#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.Field#setValue setValue} method.
+ *
+ *
JSON Packets
+ *
By default, response packets are assumed to be JSON, so for the following form load call:
Other data may be placed into the response for processing the {@link Ext.form.Basic Form}'s
+ * callback or event handler methods. The object decoded from this JSON is available in the
+ * {@link Ext.form.action.Action#result result} property.
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.ZIndexManager} or managed by the {@link Ext.WindowManager} 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}.
+ *
As with all {@link Ext.container.Container Container}s, it is important to consider how you want the Window
+ * to size and arrange any child Components. Choose an appropriate {@link #layout} configuration which lays out
+ * child Components in the required manner.
+Ext.create('Ext.window.Window', {
+ title: 'Hello',
+ height: 200,
+ width: 400,
+ layout: 'fit',
+ items: { // Let's put an empty grid in just to illustrate fit layout
+ xtype: 'grid',
+ border: false,
+ columns: [{header: 'World'}], // One header just for show. There's no data,
+ store: Ext.create('Ext.data.ArrayStore', {}) // A dummy empty data store
+ }
+}).show();
+
*/
-Ext.DataView = Ext.extend(Ext.BoxComponent, {
+Ext.define('Ext.window.Window', {
+ extend: 'Ext.panel.Panel',
+
+ alternateClassName: 'Ext.Window',
+
+ requires: ['Ext.util.ComponentDragger', 'Ext.util.Region', 'Ext.EventManager'],
+
+ alias: 'widget.window',
+
/**
- * @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 {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.core.Element Element) (The Element that the Window is rendered to).
+ */
+ /**
+ * @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.core.Element Element) (The Element that the Window is rendered to).
+ */
+ /**
+ * @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).
+ */
+ /**
+ * @cfg {String/Element} animateTarget
+ * Id or element from which the window should animate while opening (defaults to null with no animation).
+ */
+ /**
+ * @cfg {String/Number/Component} defaultFocus
+ *
Specifies a Component to receive focus when this Window is focused.
+ *
This may be one of:
+ *
The index of a footer Button.
+ *
The id or {@link Ext.AbstractComponent#itemId} of a descendant 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 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.
*/
/**
- * @cfg {Ext.data.Store} store
- * The {@link Ext.data.Store} to bind this DataView to.
+ * @cfg {Boolean} maximized
+ * True to initially display the window in a maximized state. (Defaults to false).
*/
+
/**
- * @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 {String} baseCls
+ * The base CSS class to apply to this panel's element (defaults to 'x-window').
+ */
+ baseCls: Ext.baseCSSPrefix + 'window',
+
/**
- * @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 {Mixed} resizable
+ *
Specify as true to allow user resizing at each edge and corner of the window, false to disable
+ * resizing (defaults to true).
+ *
This may also be specified as a config object to
*/
+ resizable: true,
+
/**
- * @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} 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);).
*/
+ draggable: true,
+
/**
- * @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 {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}.
*/
+ constrain: false,
+
/**
- * @cfg {String} overClass
- * A CSS class to apply to each item in the view on mouseover (defaults to undefined).
+ * @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}.
*/
+ constrainHeader: false,
+
/**
- * @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 {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).
*/
+ plain: false,
+
/**
- * @cfg {String} selectedClass
- * A CSS class to apply to each selected item in the view (defaults to 'x-view-selected').
+ * @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.
*/
- selectedClass : "x-view-selected",
+ minimizable: false,
+
/**
- * @cfg {String} emptyText
- * The text to display in the view when there is no data to display (defaults to '').
+ * @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.
*/
- emptyText : "",
+ maximizable: false,
+
+ // inherit docs
+ minHeight: 100,
+
+ // inherit docs
+ minWidth: 200,
/**
- * @cfg {Boolean} deferEmptyText True to defer emptyText being applied until the store's first load
+ * @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).
*/
- deferEmptyText: true,
+ expandOnShow: true,
+
+ // inherited docs, same default
+ collapsible: false,
+
/**
- * @cfg {Boolean} trackOver True to enable mouseenter and mouseleave events
+ * @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'.
*/
- trackOver: false,
-
+ closable: true,
+
/**
- * @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)
+ * @cfg {Boolean} hidden
+ * Render this Window hidden (default is true). If true, the
+ * {@link #hide} method will be called internally.
*/
- blockRefresh: false,
+ hidden: true,
- //private
- last: false,
+ // Inherit docs from Component. Windows render to the body on first show.
+ autoRender: true,
- // 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);
- }
+ // Inherit docs from Component. Windows hide using visibility.
+ hideMode: 'visibility',
- 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",
+ /** @cfg {Boolean} floating @hide Windows are always floating*/
+ floating: true,
+
+ ariaRole: 'alertdialog',
+
+ itemCls: 'x-window-item',
+
+ overlapHeader: true,
+
+ ignoreHeaderBorderManagement: true,
+
+ // private
+ initComponent: function() {
+ var me = this;
+ me.callParent();
+ me.addEvents(
/**
- * @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
+ * @event activate
+ * Fires after the window has been visually activated via {@link #setActive}.
+ * @param {Ext.window.Window} this
*/
- "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
+ * @event deactivate
+ * Fires after the window has been visually deactivated via {@link #setActive}.
+ * @param {Ext.window.Window} this
*/
- "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
+ * @event resize
+ * Fires after the window has been resized.
+ * @param {Ext.window.Window} this
+ * @param {Number} width The window's new width
+ * @param {Number} height The window's new height
*/
- "contextmenu",
+ 'resize',
/**
- * @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
+ * @event maximize
+ * Fires after the window has been maximized.
+ * @param {Ext.window.Window} this
*/
- "containercontextmenu",
+ 'maximize',
/**
- * @event selectionchange
- * Fires when the selected nodes change.
- * @param {Ext.DataView} this
- * @param {Array} selections Array of the selected nodes
+ * @event minimize
+ * Fires after the window has been minimized.
+ * @param {Ext.window.Window} this
*/
- "selectionchange",
-
+ 'minimize',
/**
- * @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
+ * @event restore
+ * Fires after the window has been restored to its original size after being maximized.
+ * @param {Ext.window.Window} this
*/
- "beforeselect"
+ 'restore'
);
- this.store = Ext.StoreMgr.lookup(this.store);
- this.all = new Ext.CompositeElementLite();
- this.selected = new Ext.CompositeElementLite();
- },
-
- // 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 (me.plain) {
+ me.addClsWithUI('plain');
}
- if(this.store){
- this.bindStore(this.store, true);
+ if (me.modal) {
+ me.ariaRole = 'dialog';
}
},
- /**
- * 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(),
- records = this.store.getRange();
-
- el.update('');
- if(records.length < 1){
- if(!this.deferEmptyText || this.hasSkippedEmptyText){
- el.update(this.emptyText);
+ // State Management
+ // private
+
+ initStateEvents: function(){
+ var events = this.stateEvents;
+ // push on stateEvents if they don't exist
+ Ext.each(['maximize', 'restore', 'resize', 'dragend'], function(event){
+ if (Ext.Array.indexOf(events, event)) {
+ events.push(event);
}
- 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;
+ });
+ this.callParent();
},
- getTemplateTarget: function(){
- return this.el;
- },
+ getState: function() {
+ var me = this,
+ state = me.callParent() || {},
+ maximized = !!me.maximized;
- /**
- * 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;
+ state.maximized = maximized;
+ Ext.apply(state, {
+ size: maximized ? me.restoreSize : me.getSize(),
+ pos: maximized ? me.restorePos : me.getPosition()
+ });
+ return state;
},
- /**
- *
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 = [],
- i = 0,
- len = records.length;
- for(; i < len; i++){
- r[r.length] = this.prepareData(records[i].data, startIndex + i, records[i]);
+ applyState: function(state){
+ var me = this;
+
+ if (state) {
+ me.maximized = state.maximized;
+ if (me.maximized) {
+ me.hasSavedRestore = true;
+ me.restoreSize = state.size;
+ me.restorePos = state.pos;
+ } else {
+ Ext.apply(me, {
+ width: state.size.width,
+ height: state.size.height,
+ x: state.pos[0],
+ y: state.pos[1]
+ });
+ }
}
- return r;
},
// private
- bufferRender : function(records, index){
- var div = document.createElement('div');
- this.tpl.overwrite(div, this.collectData(records, index));
- return Ext.query(this.itemSelector, div);
+ onMouseDown: function () {
+ if (this.floating) {
+ this.toFront();
+ }
},
// private
- onUpdate : function(ds, record){
- var index = this.store.indexOf(record);
- if(index > -1){
- var sel = this.isSelected(index),
- original = this.all.elements[index],
- node = this.bufferRender([record], index)[0];
+ onRender: function(ct, position) {
+ var me = this;
+ me.callParent(arguments);
+ me.focusEl = me.el;
- this.all.replaceElement(index, node, true);
- if(sel){
- this.selected.replaceElement(original, node);
- this.all.item(index).addClass(this.selectedClass);
- }
- this.updateIndexes(index, index);
+ // Double clicking a header will toggleMaximize
+ if (me.maximizable) {
+ me.header.on({
+ dblclick: {
+ fn: me.toggleMaximize,
+ element: 'el',
+ scope: me
+ }
+ });
}
},
// private
- onAdd : function(ds, records, index){
- if(this.all.getCount() === 0){
- this.refresh();
- return;
+ afterRender: function() {
+ var me = this,
+ hidden = me.hidden,
+ keyMap;
+
+ me.hidden = false;
+ // Component's afterRender sizes and positions the Component
+ me.callParent();
+ me.hidden = hidden;
+
+ // Create the proxy after the size has been applied in Component.afterRender
+ me.proxy = me.getProxy();
+
+ // clickToRaise
+ me.mon(me.el, 'mousedown', me.onMouseDown, me);
+
+ // Initialize
+ if (me.maximized) {
+ me.maximized = false;
+ me.maximize();
}
- 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));
- }else{
- n = this.all.last().insertSibling(nodes, 'after', true);
- a.push.apply(a, nodes);
+
+ if (me.closable) {
+ keyMap = me.getKeyMap();
+ keyMap.on(27, me.onEsc, me);
+
+ //if (hidden) { ? would be consistent w/before/afterShow...
+ keyMap.disable();
+ //}
}
- 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();
+ if (!hidden) {
+ me.syncMonitorWindowResize();
+ me.doConstrain();
}
},
/**
- * Refreshes an individual node's data from the store.
- * @param {Number} index The item's data index in the store
+ * @private
+ * @override
+ * Override Component.initDraggable.
+ * Window uses the header element as the delegate.
*/
- refreshNode : function(index){
- this.onUpdate(this.store, this.store.getAt(index));
- },
+ initDraggable: function() {
+ var me = this,
+ ddConfig;
- // 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;
+ if (!me.header) {
+ me.updateHeader(true);
}
- },
-
- /**
- * Returns the store associated with this DataView.
- * @return {Ext.data.Store} The store
- */
- getStore : function(){
- return this.store;
- },
+
+ /*
+ * Check the header here again. If for whatever reason it wasn't created in
+ * updateHeader (preventHeader) then we'll just ignore the rest since the
+ * header acts as the drag handle.
+ */
+ if (me.header) {
+ ddConfig = Ext.applyIf({
+ el: me.el,
+ delegate: '#' + me.header.id
+ }, me.draggable);
- /**
- * 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.onDataChanged, 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);
+ // Add extra configs if Window is specified to be constrained
+ if (me.constrain || me.constrainHeader) {
+ ddConfig.constrain = me.constrain;
+ ddConfig.constrainDelegate = me.constrainHeader;
+ ddConfig.constrainTo = me.constrainTo || me.container;
}
- if(!store){
- this.store = null;
- }
- }
- if(store){
- store = Ext.StoreMgr.lookup(store);
- store.on({
- scope: this,
- beforeload: this.onBeforeLoad,
- datachanged: this.onDataChanged,
- add: this.onAdd,
- remove: this.onRemove,
- update: this.onUpdate,
- clear: this.refresh
- });
+
+ /**
+ *
If this Window is configured {@link #draggable}, this property will contain
+ * an instance of {@link Ext.util.ComponentDragger} (A subclass of {@link Ext.dd.DragTracker DragTracker})
+ * which handles dragging the Window's DOM Element, and constraining according to the {@link #constrain}
+ * and {@link #constrainHeader} .
+ *
This has implementations of onBeforeStart, onDrag and onEnd
+ * which perform the dragging action. If extra logic is needed at these points, use
+ * {@link Ext.Function#createInterceptor createInterceptor} or {@link Ext.Function#createSequence createSequence} to
+ * augment the existing implementations.
+ * @type Ext.util.ComponentDragger
+ * @property dd
+ */
+ me.dd = Ext.create('Ext.util.ComponentDragger', this, ddConfig);
+ me.relayEvents(me.dd, ['dragstart', 'drag', 'dragend']);
}
- this.store = store;
- if(store){
- this.refresh();
+ },
+
+ // private
+ onEsc: function(k, e) {
+ e.stopEvent();
+ this[this.closeAction]();
+ },
+
+ // private
+ beforeDestroy: function() {
+ var me = this;
+ if (me.rendered) {
+ delete this.animateTarget;
+ me.hide();
+ Ext.destroy(
+ me.keyMap
+ );
}
+ me.callParent();
},
-
+
/**
* @private
- * Calls this.refresh if this.blockRefresh is not true
+ * @override
+ * Contribute class-specific tools to the header.
+ * Called by Panel's initTools.
*/
- onDataChanged: function() {
- if (this.blockRefresh !== true) {
- this.refresh.apply(this, arguments);
+ addTools: function() {
+ var me = this;
+
+ // Call Panel's initTools
+ me.callParent();
+
+ if (me.minimizable) {
+ me.addTool({
+ type: 'minimize',
+ handler: Ext.Function.bind(me.minimize, me, [])
+ });
+ }
+ if (me.maximizable) {
+ me.addTool({
+ type: 'maximize',
+ handler: Ext.Function.bind(me.maximize, me, [])
+ });
+ me.addTool({
+ type: 'restore',
+ handler: Ext.Function.bind(me.restore, me, []),
+ hidden: true
+ });
}
},
/**
- * 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
+ * Gets the configured default focus item. If a {@link #defaultFocus} is set, it will receive focus, otherwise the
+ * Container itself will receive focus.
*/
- findItemFromChild : function(node){
- return Ext.fly(node).findParent(this.itemSelector, this.getTemplateTarget());
- },
+ getFocusEl: function() {
+ var me = this,
+ f = me.focusEl,
+ defaultComp = me.defaultButton || me.defaultFocus,
+ t = typeof db,
+ el,
+ ct;
- // private
- onClick : function(e){
- var item = e.getTarget(this.itemSelector, this.getTemplateTarget()),
- index;
- if(item){
- index = this.indexOf(item);
- if(this.onItemClick(item, index, e) !== false){
- this.fireEvent("click", this, index, item, e);
- }
- }else{
- if(this.fireEvent("containerclick", this, e) !== false){
- this.onContainerClick(e);
+ if (Ext.isDefined(defaultComp)) {
+ if (Ext.isNumber(defaultComp)) {
+ f = me.query('button')[defaultComp];
+ } else if (Ext.isString(defaultComp)) {
+ f = me.down('#' + defaultComp);
+ } else {
+ f = defaultComp;
}
}
- },
-
- onContainerClick : function(e){
- this.clearSelections();
+ return f || me.focusEl;
},
// private
- onContextMenu : function(e){
- var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
- if(item){
- this.fireEvent("contextmenu", this, this.indexOf(item), item, e);
- }else{
- this.fireEvent("containercontextmenu", this, e);
+ beforeShow: function() {
+ this.callParent();
+
+ if (this.expandOnShow) {
+ this.expand(false);
}
},
// private
- onDblClick : function(e){
- var item = e.getTarget(this.itemSelector, this.getTemplateTarget());
- if(item){
- this.fireEvent("dblclick", this, this.indexOf(item), item, e);
+ afterShow: function(animateTarget) {
+ var me = this,
+ animating = animateTarget || me.animateTarget;
+
+
+ if (animating) {
+ /*
+ * If we're animating, constrain the positioning before calling the
+ * superclass, otherwise we'll be animating to the unconstrained
+ * window position.
+ */
+ me.doConstrain();
}
- },
+ // Perform superclass's afterShow tasks
+ // Which might include animating a proxy from an animTarget
+ me.callParent(arguments);
- // 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);
+ if (me.maximized) {
+ me.fitContainer();
}
- },
- // 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;
- }
+ me.syncMonitorWindowResize();
+ if (!animating) {
+ me.doConstrain();
+ }
+
+ if (me.keyMap) {
+ me.keyMap.enable();
}
},
// 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();
+ doClose: function() {
+ var me = this;
+
+ // immediate close
+ if (me.hidden) {
+ me.fireEvent('close', me);
+ me[me.closeAction]();
+ } else {
+ // close after hiding
+ me.hide(me.animTarget, me.doClose, me);
}
- return true;
},
// private
- doSingleSelection : function(item, index, e){
- if(e.ctrlKey && this.isSelected(index)){
- this.deselect(index);
- }else{
- this.select(index, false);
+ afterHide: function() {
+ var me = this;
+
+ // No longer subscribe to resizing now that we're hidden
+ me.syncMonitorWindowResize();
+
+ // Turn off keyboard handling once window is hidden
+ if (me.keyMap) {
+ me.keyMap.disable();
}
+
+ // Perform superclass's afterHide tasks.
+ me.callParent(arguments);
},
// 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);
- }
+ onWindowResize: function() {
+ if (this.maximized) {
+ this.fitContainer();
}
+ this.doConstrain();
},
/**
- * Gets the number of selected nodes.
- * @return {Number} The node count
+ * 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.Window} this
*/
- getSelectionCount : function(){
- return this.selected.getCount();
+ minimize: function() {
+ this.fireEvent('minimize', this);
+ return this;
},
- /**
- * Gets the currently selected nodes.
- * @return {Array} An array of HTMLElements
- */
- getSelectedNodes : function(){
- return this.selected.elements;
- },
+ afterCollapse: function() {
+ var me = this;
- /**
- * Gets the indexes of the selected nodes.
- * @return {Array} An array of numeric indexes
- */
- getSelectedIndexes : function(){
- var indexes = [],
- selected = this.selected.elements,
- i = 0,
- len = selected.length;
-
- for(; i < len; i++){
- indexes.push(selected[i].viewIndex);
+ if (me.maximizable) {
+ me.tools.maximize.hide();
+ me.tools.restore.hide();
}
- return indexes;
+ if (me.resizer) {
+ me.resizer.disable();
+ }
+ me.callParent(arguments);
},
- /**
- * Gets an array of the selected records
- * @return {Array} An array of {@link Ext.data.Record} objects
- */
- getSelectedRecords : function(){
- return this.getRecords(this.selected.elements);
- },
+ afterExpand: function() {
+ var me = this;
- /**
- * 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
- */
- getRecords : function(nodes){
- var records = [],
- i = 0,
- len = nodes.length;
-
- for(; i < len; i++){
- records[records.length] = this.store.getAt(nodes[i].viewIndex);
+ if (me.maximized) {
+ me.tools.restore.show();
+ } else if (me.maximizable) {
+ me.tools.maximize.show();
}
- return records;
+ if (me.resizer) {
+ me.resizer.enable();
+ }
+ me.callParent(arguments);
},
/**
- * Gets a record from a node
- * @param {HTMLElement} node The node to evaluate
- * @return {Record} record The {@link Ext.data.Record} object
+ * 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.Window} this
*/
- getRecord : function(node){
- return this.store.getAt(node.viewIndex);
- },
+ maximize: function() {
+ var me = this;
- /**
- * Clears all selections.
- * @param {Boolean} suppressEvent (optional) True to skip firing of the selectionchange event
- */
- clearSelections : function(suppressEvent, skipUpdate){
- if((this.multiSelect || this.singleSelect) && this.selected.getCount() > 0){
- if(!skipUpdate){
- this.selected.removeClass(this.selectedClass);
+ if (!me.maximized) {
+ me.expand(false);
+ if (!me.hasSavedRestore) {
+ me.restoreSize = me.getSize();
+ me.restorePos = me.getPosition(true);
}
- this.selected.clear();
- this.last = false;
- if(!suppressEvent){
- this.fireEvent("selectionchange", this, this.selected.elements);
+ if (me.maximizable) {
+ me.tools.maximize.hide();
+ me.tools.restore.show();
}
- }
- },
-
- /**
- * 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));
- },
+ me.maximized = true;
+ me.el.disableShadow();
- /**
- * 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;
+ if (me.dd) {
+ me.dd.disable();
}
- Ext.fly(node).removeClass(this.selectedClass);
- this.fireEvent("selectionchange", this, this.selected.elements);
+ if (me.collapseTool) {
+ me.collapseTool.hide();
+ }
+ me.el.addCls(Ext.baseCSSPrefix + 'window-maximized');
+ me.container.addCls(Ext.baseCSSPrefix + 'window-maximized-ct');
+
+ me.syncMonitorWindowResize();
+ me.setPosition(0, 0);
+ me.fitContainer();
+ me.fireEvent('maximize', me);
}
+ return me;
},
/**
- * 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
+ * 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.Window} this
*/
- 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);
+ restore: function() {
+ var me = this,
+ tools = me.tools;
+
+ if (me.maximized) {
+ delete me.hasSavedRestore;
+ me.removeCls(Ext.baseCSSPrefix + 'window-maximized');
+
+ // Toggle tool visibility
+ if (tools.restore) {
+ tools.restore.hide();
}
- if(!suppressEvent){
- this.fireEvent("selectionchange", this, this.selected.elements);
+ if (tools.maximize) {
+ tools.maximize.show();
}
- } else{
- var node = this.getNode(nodeInfo);
- if(!keepExisting){
- this.clearSelections(true);
+ if (me.collapseTool) {
+ me.collapseTool.show();
}
- 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);
- }
- }
+
+ // Restore the position/sizing
+ me.setPosition(me.restorePos);
+ me.setSize(me.restoreSize);
+
+ // Unset old position/sizing
+ delete me.restorePos;
+ delete me.restoreSize;
+
+ me.maximized = false;
+
+ me.el.enableShadow(true);
+
+ // Allow users to drag and drop again
+ if (me.dd) {
+ me.dd.enable();
}
- }
- },
- /**
- * 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);
- },
+ me.container.removeCls(Ext.baseCSSPrefix + 'window-maximized-ct');
- /**
- * 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];
+ me.syncMonitorWindowResize();
+ me.doConstrain();
+ me.fireEvent('restore', me);
}
- return nodeInfo;
+ return me;
},
/**
- * 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
+ * Synchronizes the presence of our listener for window resize events. This method
+ * should be called whenever this status might change.
+ * @private
*/
- getNodes : function(start, end){
- var ns = this.all.elements,
- nodes = [],
- i;
-
- start = start || 0;
- end = !Ext.isDefined(end) ? Math.max(ns.length - 1, 0) : end;
- 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]);
+ syncMonitorWindowResize: function () {
+ var me = this,
+ currentlyMonitoring = me._monitoringResize,
+ // all the states where we should be listening to window resize:
+ yes = me.monitorResize || me.constrain || me.constrainHeader || me.maximized,
+ // all the states where we veto this:
+ veto = me.hidden || me.destroying || me.isDestroyed;
+
+ if (yes && !veto) {
+ // we should be listening...
+ if (!currentlyMonitoring) {
+ // but we aren't, so set it up
+ Ext.EventManager.onWindowResize(me.onWindowResize, me);
+ me._monitoringResize = true;
}
+ } else if (currentlyMonitoring) {
+ // we should not be listening, but we are, so tear it down
+ Ext.EventManager.removeResizeListener(me.onWindowResize, me);
+ me._monitoringResize = false;
}
- return nodes;
},
/**
- * 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
+ * A shortcut method for toggling between {@link #maximize} and {@link #restore} based on the current maximized
+ * state of the window.
+ * @return {Ext.window.Window} this
*/
- indexOf : function(node){
- node = this.getNode(node);
- if(Ext.isNumber(node.viewIndex)){
- return node.viewIndex;
- }
- return this.all.indexOf(node);
- },
+ toggleMaximize: function() {
+ return this[this.maximized ? 'restore': 'maximize']();
+ }
- // private
- onBeforeLoad : function(){
- if(this.loadingText){
- this.clearSelections(false, true);
- this.getTemplateTarget().update('
'+this.loadingText+'
');
- this.all.clear();
+ /**
+ * @cfg {Boolean} autoWidth @hide
+ * Absolute positioned element and therefore cannot support autoWidth.
+ * A width is a required configuration.
+ **/
+});
+/**
+ * @class Ext.form.field.Base
+ * @extends Ext.Component
+
+Base class for form fields that provides default event handling, rendering, and other common functionality
+needed by all form field types. Utilizes the {@link Ext.form.field.Field} mixin for value handling and validation,
+and the {@link Ext.form.Labelable} mixin to provide label and error message display.
+
+In most cases you will want to use a subclass, such as {@link Ext.form.field.Text} or {@link Ext.form.field.Checkbox},
+rather than creating instances of this class directly. However if you are implementing a custom form field,
+using this as the parent class is recommended.
+
+__Values and Conversions__
+
+Because BaseField implements the Field mixin, it has a main value that can be initialized with the
+{@link #value} config and manipulated via the {@link #getValue} and {@link #setValue} methods. This main
+value can be one of many data types appropriate to the current field, for instance a {@link Ext.form.field.Date Date}
+field would use a JavaScript Date object as its value type. However, because the field is rendered as a HTML
+input, this value data type can not always be directly used in the rendered field.
+
+Therefore BaseField introduces the concept of a "raw value". This is the value of the rendered HTML input field,
+and is normally a String. The {@link #getRawValue} and {@link #setRawValue} methods can be used to directly
+work with the raw value, though it is recommended to use getValue and setValue in most cases.
+
+Conversion back and forth between the main value and the raw value is handled by the {@link #valueToRaw} and
+{@link #rawToValue} methods. If you are implementing a subclass that uses a non-String value data type, you
+should override these methods to handle the conversion.
+
+__Rendering__
+
+The content of the field body is defined by the {@link #fieldSubTpl} XTemplate, with its argument data
+created by the {@link #getSubTplData} method. Override this template and/or method to create custom
+field renderings.
+{@img Ext.form.BaseField/Ext.form.BaseField.png Ext.form.BaseField BaseField component}
+__Example usage:__
+
+ // A simple subclass of BaseField that creates a HTML5 search field. Redirects to the
+ // searchUrl when the Enter key is pressed.
+ Ext.define('Ext.form.SearchField', {
+ extend: 'Ext.form.field.Base',
+ alias: 'widget.searchfield',
+
+ inputType: 'search',
+
+ // Config defining the search URL
+ searchUrl: 'http://www.google.com/search?q={0}',
+
+ // Add specialkey listener
+ initComponent: function() {
+ this.callParent();
+ this.on('specialkey', this.checkEnterKey, this);
+ },
+
+ // Handle enter key presses, execute the search if the field has a value
+ checkEnterKey: function(field, e) {
+ var value = this.getValue();
+ if (e.getKey() === e.ENTER && !Ext.isEmpty(value)) {
+ location.href = Ext.String.format(this.searchUrl, value);
+ }
}
- },
+ });
- onDestroy : function(){
- this.all.clear();
- this.selected.clear();
- Ext.DataView.superclass.onDestroy.call(this);
- this.bindStore(null);
- }
-});
+ Ext.create('Ext.form.Panel', {
+ title: 'BaseField Example',
+ bodyPadding: 5,
+ width: 250,
+
+ // Fields will be arranged vertically, stretched to full width
+ layout: 'anchor',
+ defaults: {
+ anchor: '100%'
+ },
+ items: [{
+ xtype: 'searchfield',
+ fieldLabel: 'Search',
+ name: 'query'
+ }]
+ renderTo: Ext.getBody()
+ });
-/**
- * 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
+ *
+ * @markdown
+ * @docauthor Jason Johnston
*/
-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();
+Ext.define('Ext.form.field.Base', {
+ extend: 'Ext.Component',
+ mixins: {
+ labelable: 'Ext.form.Labelable',
+ field: 'Ext.form.field.Field'
+ },
+ alias: 'widget.field',
+ alternateClassName: ['Ext.form.Field', 'Ext.form.BaseField'],
+ requires: ['Ext.util.DelayedTask', 'Ext.XTemplate', 'Ext.layout.component.field.Field'],
+
+ fieldSubTpl: [
+ 'name="{name}" ',
+ 'size="{size}" ',
+ 'tabIndex="{tabIdx}" ',
+ 'class="{fieldCls} {typeCls}" autocomplete="off" />',
+ {
+ compiled: true,
+ disableFormats: true
+ }
+ ],
-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'
- }]
-});
+ /**
+ * @cfg {String} name The name of the field (defaults to undefined). This is used as the parameter
+ * name when including the field value in a {@link Ext.form.Basic#submit form submit()}. If no name is
+ * configured, it falls back to the {@link #inputId}. To prevent the field from being included in the
+ * form submit, set {@link #submitValue} to false.
+ */
-// 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);
+ /**
+ * @cfg {String} inputType
+ *
The type attribute for input fields -- e.g. radio, text, password, file (defaults to 'text').
+ * The extended types supported by HTML5 inputs (url, email, etc.) may also be used, though using them
+ * will cause older browsers to fall back to 'text'.
+ *
The type 'password' must be used to render that field type currently -- there is no separate Ext
+ * component for that. You can use {@link Ext.form.field.File} which creates a custom-rendered file upload
+ * field, but if you want a plain unstyled file input you can use a BaseField with inputType:'file'.
+ */
+ inputType: 'text',
-// 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 {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 {Boolean} hideHeaders
- * true to hide the {@link #internalTpl header row} (defaults to false so
- * the {@link #internalTpl header row} will be shown).
+ * @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')
*/
+ invalidText : 'The value in this field is invalid',
+
/**
- * @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.
+ * @cfg {String} fieldCls The default CSS class for the field input (defaults to 'x-form-field')
*/
- itemSelector: 'dl',
+ fieldCls : Ext.baseCSSPrefix + 'form-field',
+
/**
- * @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
+ * @cfg {String} fieldStyle Optional CSS style(s) to be applied to the {@link #inputEl field input element}.
+ * Should be a valid argument to {@link Ext.core.Element#applyStyles}. Defaults to undefined. See also the
+ * {@link #setFieldStyle} method for changing the style after initialization.
*/
- 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
+ * @cfg {String} focusCls The CSS class to use when the field receives focus (defaults to 'x-form-focus')
*/
- overClass:'x-list-over',
+ focusCls : Ext.baseCSSPrefix + 'form-focus',
+
/**
- * @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 {String} dirtyCls The CSS class to use when the field value {@link #isDirty is dirty}.
*/
+ dirtyCls : Ext.baseCSSPrefix + 'form-dirty',
+
/**
- * @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.
+ * @cfg {Array} checkChangeEvents
+ *
A list of event names that will be listened for on the field's {@link #inputEl input element}, which
+ * will cause the field's value to be checked for changes. If a change is detected, the
+ * {@link #change change event} will be fired, followed by validation if the {@link #validateOnChange}
+ * option is enabled.
+ *
Defaults to ['change', 'propertychange'] in Internet Explorer, and ['change', 'input',
+ * 'textInput', 'keyup', 'dragdrop'] in other browsers. This catches all the ways that field values
+ * can be changed in most supported browsers; the only known exceptions at the time of writing are:
+ *
+ *
Safari 3.2 and older: cut/paste in textareas via the context menu, and dragging text into textareas
+ *
Opera 10 and 11: dragging text into text fields and textareas, and cut via the context menu in text
+ * fields and textareas
+ *
Opera 9: Same as Opera 10 and 11, plus paste from context menu in text fields and textareas
+ *
+ *
If you need to guarantee on-the-fly change notifications including these edge cases, you can call the
+ * {@link #checkChange} method on a repeating interval, e.g. using {@link Ext.TaskManager}, or if the field is
+ * within a {@link Ext.form.Panel}, you can use the FormPanel's {@link Ext.form.Panel#pollForChanges}
+ * configuration to set up such a task automatically.
*/
- scrollOffset : undefined,
+ checkChangeEvents: Ext.isIE && (!document.documentMode || document.documentMode < 9) ?
+ ['change', 'propertychange'] :
+ ['change', 'input', 'textInput', 'keyup', 'dragdrop'],
+
/**
- * @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).
+ * @cfg {Number} checkChangeBuffer
+ * Defines a timeout in milliseconds for buffering {@link #checkChangeEvents} that fire in rapid succession.
+ * Defaults to 50 milliseconds.
*/
- columnResize: true,
+ checkChangeBuffer: 50,
+
+ componentLayout: 'field',
+
/**
- * @cfg {Array} columns An array of column configuration objects, for example:
- *
- * 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} 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 Date; 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.field.Trigger#hideTrigger hideTrigger}.
*/
+ readOnly : false,
+
/**
- * @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).
+ * @cfg {String} readOnlyCls The CSS class applied to the component's main element when it is {@link #readOnly}.
*/
- columnSort: true,
+ readOnlyCls: Ext.baseCSSPrefix + 'form-readonly',
+
/**
- * @cfg {String/Array} internalTpl
- * The template to be used for the header row. See {@link #tpl} for more details.
+ * @cfg {String} inputId
+ * The id that will be given to the generated input DOM element. Defaults to an automatically generated id.
+ * If you configure this manually, you must make sure it is unique in the document.
*/
- /*
- * IE has issues when setting percentage based widths to 100%. Default to 99.
+ /**
+ * @cfg {Boolean} validateOnBlur
+ * Whether the field should validate when it loses focus (defaults to true). This will cause fields
+ * to be validated as the user steps through the fields in the form regardless of whether they are making
+ * changes to those fields along the way. See also {@link #validateOnChange}.
*/
- maxColumnWidth: Ext.isIE ? 99 : 100,
+ validateOnBlur: true,
- 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(
- '
+ * @param {Ext.form.field.Base} this
+ * @param {Ext.EventObject} e The event object
+ */
+ 'specialkey'
+ );
+
+ // Init mixins
+ me.initLabelable();
+ me.initField();
+
+ // Default name to inputId
+ if (!me.name) {
+ me.name = me.getInputId();
+ }
},
- onRender : function(){
- this.autoEl = {
- cls: 'x-list-wrap'
- };
- Ext.list.ListView.superclass.onRender.apply(this, arguments);
+ /**
+ * Returns the input id for this field. If none was specified via the {@link #inputId} config,
+ * then an id will be automatically generated.
+ */
+ getInputId: function() {
+ return this.inputId || (this.inputId = Ext.id());
+ },
- this.internalTpl.overwrite(this.el, {columns: this.columns});
+ /**
+ * @protected Creates and returns the data object to be used when rendering the {@link #fieldSubTpl}.
+ * @return {Object} The template data
+ */
+ getSubTplData: function() {
+ var me = this,
+ type = me.inputType,
+ inputId = me.getInputId();
+
+ return Ext.applyIf(me.subTplData, {
+ id: inputId,
+ name: me.name || inputId,
+ type: type,
+ size: me.size || 20,
+ cls: me.cls,
+ fieldCls: me.fieldCls,
+ tabIdx: me.tabIndex,
+ typeCls: Ext.baseCSSPrefix + 'form-' + (type === 'password' ? 'text' : type)
+ });
+ },
- this.innerBody = Ext.get(this.el.dom.childNodes[1].firstChild);
- this.innerHd = Ext.get(this.el.dom.firstChild.firstChild);
+ /**
+ * @protected
+ * Gets the markup to be inserted into the outer template's bodyEl. For fields this is the
+ * actual input element.
+ */
+ getSubTplMarkup: function() {
+ return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
+ },
- if(this.hideHeaders){
- this.el.dom.firstChild.style.display = 'none';
+ initRenderTpl: function() {
+ var me = this;
+ if (!me.hasOwnProperty('renderTpl')) {
+ me.renderTpl = me.getTpl('labelableRenderTpl');
}
+ return me.callParent();
},
- getTemplateTarget : function(){
- return this.innerBody;
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
},
/**
- *
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 : 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.
+ * Set the {@link #fieldStyle CSS style} of the {@link #inputEl field input element}.
+ * @param {String/Object/Function} style The style(s) to apply. Should be a valid argument to
+ * {@link Ext.core.Element#applyStyles}.
*/
- 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);
+ setFieldStyle: function(style) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+ inputEl.applyStyles(style);
}
+ me.fieldStyle = style;
},
// private
- onResize : function(w, h){
- var body = this.innerBody.dom,
- header = this.innerHd.dom,
- scrollWidth = w - Ext.num(this.scrollOffset, Ext.getScrollBarWidth()) + 'px',
- parentNode;
-
- if(!body){
- return;
+ onRender : function() {
+ var me = this,
+ fieldStyle = me.fieldStyle,
+ renderSelectors = me.renderSelectors;
+
+ Ext.applyIf(renderSelectors, me.getLabelableSelectors());
+
+ Ext.applyIf(renderSelectors, {
+ /**
+ * @property inputEl
+ * @type Ext.core.Element
+ * The input Element for this Field. Only available after the field has been rendered.
+ */
+ inputEl: '.' + me.fieldCls
+ });
+
+ me.callParent(arguments);
+
+ // Make the stored rawValue get set as the input element's value
+ me.setRawValue(me.rawValue);
+
+ if (me.readOnly) {
+ me.setReadOnly(true);
}
- parentNode = body.parentNode;
- if(Ext.isNumber(w)){
- if(this.reserveScrollOffset || ((parentNode.offsetWidth - parentNode.clientWidth) > 10)){
- body.style.width = scrollWidth;
- header.style.width = scrollWidth;
- }else{
- body.style.width = w + 'px';
- header.style.width = w + 'px';
- setTimeout(function(){
- if((parentNode.offsetWidth - parentNode.clientWidth) > 10){
- body.style.width = scrollWidth;
- header.style.width = scrollWidth;
- }
- }, 10);
- }
+ if (me.disabled) {
+ me.disable();
}
- if(Ext.isNumber(h)){
- parentNode.style.height = Math.max(0, h - header.parentNode.offsetHeight) + 'px';
+ if (fieldStyle) {
+ me.setFieldStyle(fieldStyle);
}
+
+ me.renderActiveError();
},
- updateIndexes : function(){
- Ext.list.ListView.superclass.updateIndexes.apply(this, arguments);
- this.verifyInternalSize();
+ initAria: function() {
+ var me = this;
+ me.callParent();
+
+ // Associate the field to the error message element
+ me.getActionEl().dom.setAttribute('aria-describedby', Ext.id(me.errorEl));
},
- findHeaderIndex : function(header){
- header = header.dom || header;
- var parentNode = header.parentNode,
- children = parentNode.parentNode.childNodes,
- i = 0,
- c;
- for(; c = children[i]; i++){
- if(c == parentNode){
- return i;
- }
- }
- return -1;
+ getFocusEl: function() {
+ return this.inputEl;
},
- setHdWidths : function(){
- var els = this.innerHd.dom.getElementsByTagName('div'),
- i = 0,
- columns = this.columns,
- len = columns.length;
-
- for(; i < len; i++){
- els[i].style.width = (columns[i].width*100) + '%';
+ isFileUpload: function() {
+ return this.inputType === 'file';
+ },
+
+ extractFileInput: function() {
+ var me = this,
+ fileInput = me.isFileUpload() ? me.inputEl.dom : null,
+ clone;
+ if (fileInput) {
+ clone = fileInput.cloneNode(true);
+ fileInput.parentNode.replaceChild(clone, fileInput);
+ me.inputEl = Ext.get(clone);
}
- }
-});
+ return fileInput;
+ },
-Ext.reg('listview', Ext.list.ListView);
+ // private override to use getSubmitValue() as a convenience
+ getSubmitData: function() {
+ var me = this,
+ data = null,
+ val;
+ if (!me.disabled && me.submitValue && !me.isFileUpload()) {
+ val = me.getSubmitValue();
+ if (val !== null) {
+ data = {};
+ data[me.getName()] = val;
+ }
+ }
+ return data;
+ },
-// 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.
+ *
Returns the value that would be included in a standard form submit for this field. This will be combined
+ * with the field's name to form a name=value pair in the {@link #getSubmitData submitted parameters}.
+ * If an empty string is returned then just the name= will be submitted; if null is returned
+ * then nothing will be submitted.
+ *
Note that the value returned will have been {@link #processRawValue processed} but may or may not have
+ * been successfully {@link #validate validated}.
+ * @return {String} The value to be submitted, or null.
*/
- 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,
+ getSubmitValue: function() {
+ return this.processRawValue(this.getRawValue());
+ },
/**
- * @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 the raw value of the field, without performing any normalization, conversion, or validation.
+ * To get a normalized and converted value see {@link #getValue}.
+ * @return {String} value The raw String value of the field
*/
+ getRawValue: function() {
+ var me = this,
+ v = (me.inputEl ? me.inputEl.getValue() : Ext.value(me.rawValue, ''));
+ me.rawValue = v;
+ return v;
+ },
/**
- * @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.
+ * Sets the field's raw value directly, bypassing {@link #valueToRaw value conversion}, change detection, and
+ * validation. To set the value with these additional inspections see {@link #setValue}.
+ * @param {Mixed} value The value to set
+ * @return {Mixed} value The field value that is set
*/
-
- 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);
- }
-});
+ setRawValue: function(value) {
+ var me = this;
+ value = Ext.value(value, '');
+ me.rawValue = value;
-Ext.reg('lvcolumn', Ext.list.Column);
+ // Some Field subclasses may not render an inputEl
+ if (me.inputEl) {
+ me.inputEl.dom.value = value;
+ }
+ return value;
+ },
-/**
- * @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);
- }
-});
-
-Ext.reg('lvnumbercolumn', Ext.list.NumberColumn);
-
-/**
- * @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.
Converts a mixed-type value to a raw representation suitable for displaying in the field. This allows
+ * controlling how value objects passed to {@link #setValue} are shown to the user, including localization.
+ * For instance, for a {@link Ext.form.field.Date}, this would control how a Date object passed to {@link #setValue}
+ * would be converted to a String for display in the field.
+ *
See {@link #rawToValue} for the opposite conversion.
+ *
The base implementation simply does a standard toString conversion, and converts
+ * {@link Ext#isEmpty empty values} to an empty string.
+ * @param {Mixed} value The mixed-type value to convert to the raw representation.
+ * @return {Mixed} The converted raw value.
+ */
+ valueToRaw: function(value) {
+ return '' + Ext.value(value, '');
+ },
-/**
- * @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').
+ *
Converts a raw input field value into a mixed-type value that is suitable for this particular field type.
+ * This allows controlling the normalization and conversion of user-entered values into field-type-appropriate
+ * values, e.g. a Date object for {@link Ext.form.field.Date}, and is invoked by {@link #getValue}.
+ *
It is up to individual implementations to decide how to handle raw values that cannot be successfully
+ * converted to the desired object type.
+ *
See {@link #valueToRaw} for the opposite conversion.
+ *
The base implementation does no conversion, returning the raw value untouched.
+ * @param {Mixed} rawValue
+ * @return {Mixed} The converted value.
*/
- trueText: 'true',
+ rawToValue: function(rawValue) {
+ return rawValue;
+ },
+
/**
- * @cfg {String} falseText
- * The string returned by the renderer when the column value is falsey (but not undefined) (defaults to
- * 'false').
+ * Performs any necessary manipulation of a raw field value to prepare it for {@link #rawToValue conversion}
+ * and/or {@link #validate validation}, for instance stripping out ignored characters. In the base implementation
+ * it does nothing; individual subclasses may override this as needed.
+ * @param {Mixed} value The unprocessed string value
+ * @return {Mixed} The processed string value
*/
- falseText: 'false',
+ processRawValue: function(value) {
+ return value;
+ },
+
/**
- * @cfg {String} undefinedText
- * The string returned by the renderer when the column value is undefined (defaults to ' ').
+ * Returns the current data value of the field. The type of value returned is particular to the type of the
+ * particular field (e.g. a Date object for {@link Ext.form.field.Date}), as the result of calling {@link #rawToValue} on
+ * the field's {@link #processRawValue processed} String value. To return the raw String value, see {@link #getRawValue}.
+ * @return {Mixed} value The field value
*/
- 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);
- }
-});
+ getValue: function() {
+ var me = this,
+ val = me.rawToValue(me.processRawValue(me.getRawValue()));
+ me.value = val;
+ return val;
+ },
-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)
+ * Sets a data value into the field and runs the change detection and validation. To set the value directly
+ * without these inspections see {@link #setRawValue}.
+ * @param {Mixed} value The value to set
+ * @return {Ext.form.field.Field} this
*/
- minPct: .05,
+ setValue: function(value) {
+ var me = this;
+ me.setRawValue(me.valueToRaw(value));
+ return me.mixins.field.setValue.call(me, value);
+ },
- constructor: function(config){
- Ext.apply(this, config);
- Ext.list.ColumnResizer.superclass.constructor.call(this);
+
+ //private
+ onDisable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+ inputEl.dom.disabled = true;
+ }
},
- init : function(listView){
- this.view = listView;
- listView.on('render', this.initEvents, this);
+
+ //private
+ onEnable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+ inputEl.dom.disabled = false;
+ }
},
- 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 handleWidth = 5,
- x = e.getPageX(),
- header = e.getTarget('em', 3, true);
- if(header){
- var region = header.getRegion(),
- style = header.dom.style,
- parentNode = header.dom.parentNode;
-
- if(x - region.left <= handleWidth && parentNode != parentNode.parentNode.firstChild){
- this.activeHd = Ext.get(parentNode.previousSibling.firstChild);
- style.cursor = Ext.isWebKit ? 'e-resize' : 'col-resize';
- } else if(region.right - x <= handleWidth && parentNode != parentNode.parentNode.lastChild.previousSibling){
- this.activeHd = header;
- style.cursor = Ext.isWebKit ? 'w-resize' : 'col-resize';
- } else{
- delete this.activeHd;
- style.cursor = '';
- }
+ /**
+ * Sets the read only state of this field.
+ * @param {Boolean} readOnly Whether the field should be read only.
+ */
+ setReadOnly: function(readOnly) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+ inputEl.dom.readOnly = readOnly;
+ inputEl.dom.setAttribute('aria-readonly', readOnly);
}
+ me[readOnly ? 'addCls' : 'removeCls'](me.readOnlyCls);
+ me.readOnly = readOnly;
},
- onBeforeStart : function(e){
- this.dragHd = this.activeHd;
- return !!this.dragHd;
+ // private
+ fireKey: function(e){
+ if(e.isSpecialKey()){
+ this.fireEvent('specialkey', this, Ext.create('Ext.EventObjectImpl', e));
+ }
},
- onStart: function(e){
-
+ // private
+ initEvents : function(){
var me = this,
- view = me.view,
- dragHeader = me.dragHd,
- x = me.tracker.getXY()[0];
-
- me.proxy = view.el.createChild({cls:'x-list-resizer'});
- me.dragX = dragHeader.getX();
- me.headerIndex = view.findHeaderIndex(dragHeader);
-
- me.headersDisabled = view.disableHeaders;
- view.disableHeaders = true;
-
- me.proxy.setHeight(view.el.getHeight());
- me.proxy.setX(me.dragX);
- me.proxy.setWidth(x - me.dragX);
-
- this.setBoundaries();
-
+ inputEl = me.inputEl,
+ onChangeTask,
+ onChangeEvent;
+ if (inputEl) {
+ me.mon(inputEl, Ext.EventManager.getKeyEvent(), me.fireKey, me);
+ me.mon(inputEl, 'focus', me.onFocus, me);
+
+ // 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)
+ me.mon(inputEl, 'blur', me.onBlur, me, me.inEditor ? {buffer:10} : null);
+
+ // listen for immediate value changes
+ onChangeTask = Ext.create('Ext.util.DelayedTask', me.checkChange, me);
+ me.onChangeEvent = onChangeEvent = function() {
+ onChangeTask.delay(me.checkChangeBuffer);
+ };
+ Ext.each(me.checkChangeEvents, function(eventName) {
+ if (eventName === 'propertychange') {
+ me.usesPropertychange = true;
+ }
+ me.mon(inputEl, eventName, onChangeEvent);
+ }, me);
+ }
+ me.callParent();
},
-
- // Sets up the boundaries for the drag/drop operation
- setBoundaries: function(relativeX){
- var view = this.view,
- headerIndex = this.headerIndex,
- width = view.innerHd.getWidth(),
- relativeX = view.innerHd.getX(),
- minWidth = Math.ceil(width * this.minPct),
- maxWidth = width - minWidth,
- numColumns = view.columns.length,
- headers = view.innerHd.select('em', true),
- minX = minWidth + relativeX,
- maxX = maxWidth + relativeX,
- header;
-
- if (numColumns == 2) {
- this.minX = minX;
- this.maxX = maxX;
- }else{
- header = headers.item(headerIndex + 2);
- this.minX = headers.item(headerIndex).getX() + minWidth;
- this.maxX = header ? header.getX() - minWidth : maxX;
- if (headerIndex == 0) {
- // First
- this.minX = minX;
- } else if (headerIndex == numColumns - 2) {
- // Last
- this.maxX = maxX;
- }
+
+ doComponentLayout: function() {
+ var me = this,
+ inputEl = me.inputEl,
+ usesPropertychange = me.usesPropertychange,
+ ename = 'propertychange',
+ onChangeEvent = me.onChangeEvent;
+
+ // In IE if propertychange is one of the checkChangeEvents, we need to remove
+ // the listener prior to layout and re-add it after, to prevent it from firing
+ // needlessly for attribute and style changes applied to the inputEl.
+ if (usesPropertychange) {
+ me.mun(inputEl, ename, onChangeEvent);
+ }
+ me.callParent(arguments);
+ if (usesPropertychange) {
+ me.mon(inputEl, ename, onChangeEvent);
}
},
- onDrag: function(e){
+ // private
+ preFocus: Ext.emptyFn,
+
+ // private
+ onFocus: function() {
var me = this,
- cursorX = me.tracker.getXY()[0].constrain(me.minX, me.maxX);
-
- me.proxy.setWidth(cursorX - this.dragX);
+ focusCls = me.focusCls,
+ inputEl = me.inputEl;
+ me.preFocus();
+ if (focusCls && inputEl) {
+ inputEl.addCls(focusCls);
+ }
+ if (!me.hasFocus) {
+ me.hasFocus = true;
+ me.fireEvent('focus', me);
+ }
},
- onEnd: function(e){
- /* calculate desired width by measuring proxy and then remove it */
- var newWidth = this.proxy.getWidth(),
- index = this.headerIndex,
- view = this.view,
- columns = view.columns,
- width = view.innerHd.getWidth(),
- newPercent = Math.ceil(newWidth * view.maxColumnWidth / width) / 100,
- disabled = this.headersDisabled,
- headerCol = columns[index],
- otherCol = columns[index + 1],
- totalPercent = headerCol.width + otherCol.width;
-
- this.proxy.remove();
-
- headerCol.width = newPercent;
- otherCol.width = totalPercent - newPercent;
-
- delete this.dragHd;
- view.setHdWidths();
- view.refresh();
-
- setTimeout(function(){
- view.disableHeaders = disabled;
- }, 100);
- }
-});
+ // private
+ beforeBlur : Ext.emptyFn,
+
+ // private
+ onBlur : function(){
+ var me = this,
+ focusCls = me.focusCls,
+ inputEl = me.inputEl;
+ me.beforeBlur();
+ if (focusCls && inputEl) {
+ inputEl.removeCls(focusCls);
+ }
+ if (me.validateOnBlur) {
+ me.validate();
+ }
+ me.hasFocus = false;
+ me.fireEvent('blur', me);
+ me.postBlur();
+ },
+
+ // private
+ postBlur : Ext.emptyFn,
+
-// 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"])
+ * @private Called when the field's dirty state changes. Adds/removes the {@link #dirtyCls} on the main element.
+ * @param {Boolean} isDirty
*/
- sortClasses : ["sort-asc", "sort-desc"],
-
- constructor: function(config){
- Ext.apply(this, config);
- Ext.list.Sorter.superclass.constructor.call(this);
+ onDirtyChange: function(isDirty) {
+ this[isDirty ? 'addCls' : 'removeCls'](this.dirtyCls);
},
- 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]);
+ /**
+ * Returns whether or not the field value is currently valid by
+ * {@link #getErrors validating} the {@link #processRawValue processed raw value}
+ * of the field. Note: {@link #disabled} fields are always treated as valid.
+ * @return {Boolean} True if the value is valid, else false
+ */
+ isValid : function() {
+ var me = this;
+ return me.disabled || me.validateValue(me.processRawValue(me.getRawValue()));
},
- 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;
+
+ /**
+ *
Uses {@link #getErrors} to build an array of validation errors. If any errors are found, they are passed
+ * to {@link #markInvalid} 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 {@link #getErrors} should be overridden instead.
+ * @param {Mixed} value The value to validate
+ * @return {Boolean} True if all validations passed, false if one or more failed
+ */
+ validateValue: function(value) {
+ var me = this,
+ errors = me.getErrors(value),
+ isValid = Ext.isEmpty(errors);
+ if (!me.preventMark) {
+ if (isValid) {
+ me.clearInvalid();
+ } else {
+ me.markInvalid(errors);
}
}
- if(sortColumn != -1){
- var sortDir = state.direction;
- this.updateSortIcon(sortColumn, sortDir);
+
+ return isValid;
+ },
+
+ /**
+ *
Display one or more error messages associated with this field, using {@link #msgTarget} to determine how to
+ * display the messages and applying {@link #invalidCls} to the field's UI element.
+ *
Note: this method does not cause the Field's {@link #validate} or {@link #isValid} methods 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.
+ * @param {String/Array} errors The validation message(s) to display.
+ */
+ markInvalid : function(errors) {
+ // Save the message and fire the 'invalid' event
+ var me = this,
+ oldMsg = me.getActiveError();
+ me.setActiveErrors(Ext.Array.from(errors));
+ if (oldMsg !== me.getActiveError()) {
+ me.doComponentLayout();
}
},
- 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]);
+ /**
+ *
Clear any invalid styles/messages for this field.
+ *
Note: this method does not cause the Field's {@link #validate} or {@link #isValid} methods to
+ * return true if the value does not pass validation. So simply clearing a field's errors
+ * will not necessarily allow submission of forms submitted with the {@link Ext.form.action.Submit#clientValidation}
+ * option set.
+ */
+ clearInvalid : function() {
+ // Clear the message and fire the 'valid' event
+ var me = this,
+ hadError = me.hasActiveError();
+ me.unsetActiveError();
+ if (hadError) {
+ me.doComponentLayout();
+ }
},
- 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);
+ /**
+ * @private Overrides the method from the Ext.form.Labelable mixin to also add the invalidCls to the inputEl,
+ * as that is required for proper styling in IE with nested fields (due to lack of child selector)
+ */
+ renderActiveError: function() {
+ var me = this,
+ hasError = me.hasActiveError();
+ if (me.inputEl) {
+ // Add/remove invalid class
+ me.inputEl[hasError ? 'addCls' : 'removeCls'](me.invalidCls + '-field');
}
+ me.mixins.labelable.renderActiveError.call(me);
+ },
+
+
+ getActionEl: function() {
+ return this.inputEl || this.el;
}
-});
-// 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:
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'}
- ]
});
-// 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.
- *
- *
- *
+/**
+ * @class Ext.form.field.Text
+ * @extends Ext.form.field.Base
+
+A 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.field.TextArea}
+and {@link Ext.form.field.ComboBox}). Has support for empty-field placeholder values (see {@link #emptyText}).
+
+#Validation#
+
+The Text field has a useful set of validations built in:
+
+- {@link #allowBlank} for making the field required
+- {@link #minLength} for requiring a minimum value length
+- {@link #maxLength} for setting a maximum value length (with {@link #enforceMaxLength} to add it
+ as the `maxlength` attribute on the input element)
+- {@link #regex} to specify a custom regular expression for validation
+
+In addition, custom validations may be added:
+
+- {@link #vtype} specifies a virtual type implementation from {@link Ext.form.field.VTypes} which can contain
+ custom validation logic
+- {@link #validator} allows a custom arbitrary function to be called during validation
+
+The details around how and when each of these validation options get used are described in the
+documentation for {@link #getErrors}.
+
+By default, the field value is checked for validity immediately while the user is typing in the
+field. This can be controlled with the {@link #validateOnChange}, {@link #checkChangeEvents}, and
+{@link #checkChangeBugger} configurations. Also see the details on Form Validation in the
+{@link Ext.form.Panel} class documentation.
+
+#Masking and Character Stripping#
+
+Text fields can be configured with custom regular expressions to be applied to entered values before
+validation: see {@link #maskRe} and {@link #stripCharsRe} for details.
+{@img Ext.form.Text/Ext.form.Text.png Ext.form.Text component}
+#Example usage:#
+
+ Ext.create('Ext.form.Panel', {
+ title: 'Contact Info',
+ width: 300,
+ bodyPadding: 10,
+ renderTo: Ext.getBody(),
+ items: [{
+ xtype: 'textfield',
+ name: 'name',
+ fieldLabel: 'Name',
+ allowBlank: false // requires a non-empty value
+ }, {
+ xtype: 'textfield',
+ name: 'email',
+ fieldLabel: 'Email Address',
+ vtype: 'email' // requires value to be a valid email address format
+ }]
+ });
+
*
- * @extends Ext.Panel
- * @constructor
- * @param {Object} config The configuration options
- * @xtype tabpanel
+ * @markdown
+ * @docauthor Jason Johnston
*/
-Ext.TabPanel = Ext.extend(Ext.Panel, {
+Ext.define('Ext.form.field.Text', {
+ extend:'Ext.form.field.Base',
+ alias: 'widget.textfield',
+ requires: ['Ext.form.field.VTypes', 'Ext.layout.component.field.Text'],
+ alternateClassName: ['Ext.form.TextField', 'Ext.form.Text'],
+
/**
- * @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} 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 undefined).
+ * Note: only applies if {@link #vtype} is set, else ignored.
*/
+
/**
- * @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 {RegExp} stripCharsRe A JavaScript RegExp object used to strip unwanted content from the value
+ * before validation (defaults to undefined).
*/
+
/**
- * @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 {Number} size An initial value for the 'size' attribute on the text input element. This is only
+ * used if the field has no configured {@link #width} and is not given a width by its container's layout.
+ * Defaults to 20.
*/
- deferredRender : true,
+ size: 20,
+
/**
- * @cfg {Number} tabWidth The initial width in pixels of each new tab (defaults to 120).
+ * @cfg {Boolean} grow true if this field should automatically grow and shrink to its content
+ * (defaults to false)
+ */
+
+ /**
+ * @cfg {Number} growMin The minimum width to allow when {@link #grow} = true (defaults
+ * to 30)
*/
- tabWidth : 120,
+ growMin : 30,
+
/**
- * @cfg {Number} minTabWidth The minimum width in pixels for each tab when {@link #resizeTabs} = true (defaults to 30).
+ * @cfg {Number} growMax The maximum width to allow when {@link #grow} = true (defaults
+ * to 800)
*/
- minTabWidth : 30,
+ growMax : 800,
+
/**
- * @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 {String} growAppend
+ * A string that will be appended to the field's current value for the purposes of calculating the target
+ * field size. Only used when the {@link #grow} config is true. Defaults to a single capital "W"
+ * (the widest character in common fonts) to leave enough space for the next typed character and avoid the
+ * field value shifting before the width is adjusted.
*/
- resizeTabs : false,
+ growAppend: 'W',
+
/**
- * @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 {String} vtype A validation type name as defined in {@link Ext.form.field.VTypes} (defaults to undefined)
*/
- 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.
+ * @cfg {RegExp} maskRe An input mask regular expression that will be used to filter keystrokes that do
+ * not match (defaults to undefined)
*/
- scrollIncrement : 0,
+
/**
- * @cfg {Number} scrollRepeatInterval Number of milliseconds between each scroll while a tab scroll button is
- * continuously pressed (defaults to 400).
+ * @cfg {Boolean} disableKeyFilter Specify true to disable input keystroke filtering (defaults
+ * to false)
*/
- scrollRepeatInterval : 400,
+
/**
- * @cfg {Float} scrollDuration The number of milliseconds that each scroll animation should last (defaults
- * to .35). Only applies when {@link #animScroll} = true.
+ * @cfg {Boolean} allowBlank Specify false to validate that the value's length is > 0 (defaults to
+ * true)
*/
- scrollDuration : 0.35,
+ allowBlank : true,
+
/**
- * @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.
+ * @cfg {Number} minLength Minimum input field length required (defaults to 0)
*/
- animScroll : true,
+ minLength : 0,
+
/**
- * @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 {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 the {@link Ext.form.field.Text#enforceMaxLength enforceMaxLength} option.
*/
- tabPosition : 'top',
+ maxLength : Number.MAX_VALUE,
+
/**
- * @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
-});
+ * @cfg {Boolean} enforceMaxLength True to set the maxLength property on the underlying input field. Defaults to false
+ */
-// 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>
-
+ /**
+ * @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)
+ */
+
+ /**
+ * @cfg {String} blankText The error text to display if the {@link #allowBlank} validation
+ * fails (defaults to 'This field is required')
*/
- autoTabs : false,
+ blankText : 'This field is required',
+
/**
- * @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 {Function} validator
+ *
A custom validation function to be called during field validation ({@link #getErrors})
+ * (defaults to undefined). 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
+ *
*/
- 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).
+ * @cfg {RegExp} regex A JavaScript RegExp object to be tested against the field value during validation
+ * (defaults to undefined). If the test fails, the field will be marked invalid using
+ * {@link #regexText}.
*/
- 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)
+ * @cfg {String} regexText The error text to display if {@link #regex} is used and the
+ * test fails during validation (defaults to '')
*/
- tabMargin : 2,
+ regexText : '',
+
/**
- * @cfg {Boolean} plain true to render the tab strip without a background container image
- * (defaults to false).
+ * @cfg {String} emptyText
+ *
The default text to place into an empty field (defaults to undefined).
+ *
Note that normally this value will be submitted to the server if this field is enabled; to prevent this
+ * you can set the {@link Ext.form.action.Action#submitEmptyText submitEmptyText} option of
+ * {@link Ext.form.Basic#submit} to false.
+ *
Also note that if you use {@link #inputType inputType}:'file', {@link #emptyText} is not
+ * supported and should be avoided.
*/
- plain : false,
+
/**
- * @cfg {Number} wheelIncrement For scrolling tabs, the number of pixels to increment on mouse wheel
- * scrolling (defaults to 20).
+ * @cfg {String} emptyCls 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.
*/
- wheelIncrement : 20,
+ emptyCls : Ext.baseCSSPrefix + 'form-empty-field',
- /*
- * 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 : '__',
+ ariaRole: 'textbox',
- // private
- itemCls : 'x-tab-item',
+ /**
+ * @cfg {Boolean} enableKeyEvents true to enable the proxying of key events for the HTML input field (defaults to false)
+ */
- // private config overrides
- elements : 'body',
- headerAsText : false,
- frame : false,
- hideBorders :true,
+ componentLayout: 'textfield',
- // private
initComponent : function(){
- this.frame = false;
- Ext.TabPanel.superclass.initComponent.call(this);
+ this.callParent();
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
+ * @event autosize
+ * Fires when the {@link #autoSize} function is triggered and the field is
+ * resized according to the {@link #grow}/{@link #growMin}/{@link #growMax} configs as a result.
+ * This event provides a hook for the developer to apply additional logic at runtime to resize the
+ * field if needed.
+ * @param {Ext.form.field.Text} this This text field
+ * @param {Number} width The new field width
*/
- 'beforetabchange',
+ 'autosize',
+
/**
- * @event tabchange
- * Fires after the active tab has changed.
- * @param {TabPanel} this
- * @param {Panel} tab The new active tab
+ * @event keydown
+ * Keydown input field event. This event only fires if {@link #enableKeyEvents}
+ * is set to true.
+ * @param {Ext.form.field.Text} this This text field
+ * @param {Ext.EventObject} e
*/
- 'tabchange',
+ 'keydown',
/**
- * @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
+ * @event keyup
+ * Keyup input field event. This event only fires if {@link #enableKeyEvents}
+ * is set to true.
+ * @param {Ext.form.field.Text} 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.field.Text} this This text field
+ * @param {Ext.EventObject} e
*/
- 'contextmenu'
+ 'keypress'
);
- /**
- * @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';
+ // private
+ initEvents : function(){
+ var me = this,
+ el = me.inputEl;
+
+ me.callParent();
+ if(me.selectOnFocus || me.emptyText){
+ me.mon(el, 'mousedown', me.onMouseDown, me);
}
- if(!this.stack){
- this.stack = Ext.TabPanel.AccessStack();
+ if(me.maskRe || (me.vtype && me.disableKeyFilter !== true && (me.maskRe = Ext.form.field.VTypes[me.vtype+'Mask']))){
+ me.mon(el, 'keypress', me.filterKeys, me);
+ }
+
+ if (me.enableKeyEvents) {
+ me.mon(el, {
+ scope: me,
+ keyup: me.onKeyUp,
+ keydown: me.onKeyDown,
+ keypress: me.onKeyPress
+ });
}
- this.initItems();
},
- // private
- onRender : function(ct, position){
- Ext.TabPanel.superclass.onRender.call(this, ct, position);
+ /**
+ * @private override - treat undefined and null values as equal to an empty string value
+ */
+ isEqual: function(value1, value2) {
+ return String(Ext.value(value1, '')) === String(Ext.value(value2, ''));
+ },
+
+ /**
+ * @private
+ * If grow=true, invoke the autoSize method when the field's value is changed.
+ */
+ onChange: function() {
+ this.callParent();
+ this.autoSize();
+ },
+
+ afterRender: function(){
+ var me = this;
+ if (me.enforceMaxLength) {
+ me.inputEl.dom.maxLength = me.maxLength;
+ }
+ me.applyEmptyText();
+ me.autoSize();
+ me.callParent();
+ },
- if(this.plain){
- var pos = this.tabPosition == 'top' ? 'header' : 'footer';
- this[pos].addClass('x-tab-panel-'+pos+'-plain');
+ onMouseDown: function(e){
+ var me = this;
+ if(!me.hasFocus){
+ me.mon(me.inputEl, 'mouseup', Ext.emptyFn, me, { single: true, preventDefault: true });
}
+ },
- var st = this[this.stripTarget];
+ /**
+ * Performs any necessary manipulation of a raw String value to prepare it for {@link #stringToValue conversion}
+ * and/or {@link #validate validation}. For text fields this applies the configured {@link #stripCharsRe} to the
+ * raw value.
+ * @param {String} value The unprocessed string value
+ * @return {String} The processed string value
+ */
+ processRawValue: function(value) {
+ var me = this,
+ stripRe = me.stripCharsRe,
+ newValue;
+
+ if (stripRe) {
+ newValue = value.replace(stripRe, '');
+ if (newValue !== value) {
+ me.setRawValue(newValue);
+ value = newValue;
+ }
+ }
+ return value;
+ },
- this.stripWrap = st.createChild({cls:'x-tab-strip-wrap', cn:{
- tag:'ul', cls:'x-tab-strip x-tab-strip-'+this.tabPosition}});
+ //private
+ onDisable: function(){
+ this.callParent();
+ if (Ext.isIE) {
+ this.inputEl.dom.unselectable = 'on';
+ }
+ },
- 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);
+ //private
+ onEnable: function(){
+ this.callParent();
+ if (Ext.isIE) {
+ this.inputEl.dom.unselectable = '';
+ }
+ },
- // 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'});
+ onKeyDown: function(e) {
+ this.fireEvent('keydown', this, e);
+ },
- this.body.addClass('x-tab-panel-body-'+this.tabPosition);
+ onKeyUp: function(e) {
+ this.fireEvent('keyup', this, e);
+ },
- /**
- * @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:
'
- );
- tt.disableFormats = true;
- tt.compile();
- Ext.TabPanel.prototype.itemTpl = tt;
- }
- this.items.each(this.initTab, this);
+ /**
+ * Resets the current field value to the originally-loaded value and clears any validation messages.
+ * Also adds {@link #emptyText} and {@link #emptyCls} if the
+ * original value was blank.
+ */
+ reset : function(){
+ this.callParent();
+ this.applyEmptyText();
+ },
+
+ applyEmptyText : function(){
+ var me = this,
+ emptyText = me.emptyText,
+ isEmpty;
+
+ if (me.rendered && emptyText) {
+ isEmpty = me.getRawValue().length < 1 && !me.hasFocus;
+
+ if (Ext.supports.Placeholder) {
+ me.inputEl.dom.placeholder = emptyText;
+ } else if (isEmpty) {
+ me.setRawValue(emptyText);
+ }
+
+ //all browsers need this because of a styling issue with chrome + placeholders.
+ //the text isnt vertically aligned when empty (and using the placeholder)
+ if (isEmpty) {
+ me.inputEl.addCls(me.emptyCls);
+ }
+
+ me.autoSize();
+ }
},
// private
- afterRender : function(){
- Ext.TabPanel.superclass.afterRender.call(this);
- if(this.autoTabs){
- this.readTabs(false);
+ preFocus : function(){
+ var me = this,
+ inputEl = me.inputEl,
+ emptyText = me.emptyText,
+ isEmpty;
+
+ if (emptyText && !Ext.supports.Placeholder && inputEl.dom.value === emptyText) {
+ me.setRawValue('');
+ isEmpty = true;
+ inputEl.removeCls(me.emptyCls);
+ } else if (Ext.supports.Placeholder) {
+ me.inputEl.removeCls(me.emptyCls);
}
- if(this.activeTab !== undefined){
- var item = Ext.isObject(this.activeTab) ? this.activeTab : this.items.get(this.activeTab);
- delete this.activeTab;
- this.setActiveTab(item);
+ if (me.selectOnFocus || isEmpty) {
+ inputEl.dom.select();
}
},
- // 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);
+ onFocus: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (me.emptyText) {
+ me.autoSize();
}
},
// private
- findTargets : function(e){
- var item = null,
- itemEl = e.getTarget('li:not(.x-tab-edge)', this.strip);
-
- 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
- };
+ postBlur : function(){
+ this.applyEmptyText();
},
// private
- onStripMouseDown : function(e){
- if(e.button !== 0){
+ filterKeys : function(e){
+ if(e.ctrlKey){
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);
- }
+ var key = e.getKey(),
+ charCode = String.fromCharCode(e.getCharCode());
+
+ if(Ext.isGecko && (e.isNavKeyPress() || key === e.BACKSPACE || (key === e.DELETE && e.button === -1))){
+ return;
+ }
+
+ if(!Ext.isGecko && e.isSpecialKey() && !charCode){
return;
}
- if(t.item && t.item != this.activeTab){
- this.setActiveTab(t.item);
+ if(!this.maskRe.test(charCode)){
+ e.stopEvent();
}
},
- // private
- onStripContextMenu : function(e){
- e.preventDefault();
- var t = this.findTargets(e);
- if(t.item){
- this.fireEvent('contextmenu', this, t.item, e);
+ /**
+ * Returns the raw String value of the field, without performing any normalization, conversion, or validation.
+ * Gets the current value of the input element if the field has been rendered, ignoring the value if it is the
+ * {@link #emptyText}. To get a normalized and converted value see {@link #getValue}.
+ * @return {String} value The raw String value of the field
+ */
+ getRawValue: function() {
+ var me = this,
+ v = me.callParent();
+ if (v === me.emptyText) {
+ v = '';
}
+ return v;
},
/**
- * True to scan the markup in this tab panel for {@link #autoTabs} using the
- * {@link #autoTabSelector}
- * @param {Boolean} removeExisting True to remove existing tabs
+ * Sets a data value into the field and runs the change detection and validation. Also applies any configured
+ * {@link #emptyText} for text fields. To set the value directly without these inspections see {@link #setRawValue}.
+ * @param {Mixed} value The value to set
+ * @return {Ext.form.field.Text} this
*/
- 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
- });
+ setValue: function(value) {
+ var me = this,
+ inputEl = me.inputEl;
+
+ if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
+ inputEl.removeCls(me.emptyCls);
}
+
+ me.callParent(arguments);
+
+ me.applyEmptyText();
+ return me;
},
- // 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);
-
- tabEl.hover(function(){
- if(!item.disabled){
- tabEl.addClass(cls);
- }
- }, function(){
- tabEl.removeClass(cls);
- });
+ /**
+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:
- if(item.tabTip){
- tabEl.child('span.x-tab-strip-text', true).qtip = item.tabTip;
- }
- item.tabEl = el;
+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).
- // 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});
+2. **Basic Validation**
- item.on({
- scope: this,
- disable: this.onItemDisabled,
- enable: this.onItemEnabled,
- titlechange: this.onItemTitleChanged,
- iconchange: this.onItemIconChanged,
- beforeshow: this.onBeforeShowItem
- });
- },
+ 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}`)
- /**
- *
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;
- }
+ If the passed value does not satisfy the `{@link #maxLength}`
+ specified, validation halts.
- return {
- id: this.id + this.idDelimiter + item.getItemId(),
- text: item.title,
- cls: cls,
- iconCls: item.iconCls || ''
- };
- },
+3. **Preconfigured Validation Types (VTypes)**
- // private
- onAdd : function(c){
- Ext.TabPanel.superclass.onAdd.call(this, c);
- if(this.rendered){
- var items = this.items;
- this.initTab(c, items.indexOf(c));
- this.delegateUpdates();
- }
- },
+ If none of the prior validation steps halts validation, a field
+ configured with a `{@link #vtype}` will utilize the
+ corresponding {@link Ext.form.field.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.
- // 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);
- },
+4. **Field specific regex test**
- // 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 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
+ * @markdown
+ */
+ getErrors: function(value) {
+ var me = this,
+ errors = me.callParent(arguments),
+ validator = me.validator,
+ emptyText = me.emptyText,
+ allowBlank = me.allowBlank,
+ vtype = me.vtype,
+ vtypes = Ext.form.field.VTypes,
+ regex = me.regex,
+ format = Ext.String.format,
+ msg;
+
+ value = value || me.processRawValue(me.getRawValue());
+
+ if (Ext.isFunction(validator)) {
+ msg = validator.call(me, value);
+ if (msg !== true) {
+ errors.push(msg);
}
}
- if(!this.destroying){
- this.delegateUpdates();
- }
- },
- // private
- onBeforeShowItem : function(item){
- if(item != this.activeTab){
- this.setActiveTab(item);
- return false;
+ if (value.length < 1 || value === emptyText) {
+ if (!allowBlank) {
+ errors.push(me.blankText);
+ }
+ //if value is blank, there cannot be any additional errors
+ return errors;
}
- },
- // private
- onItemDisabled : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).addClass('x-item-disabled');
+ if (value.length < me.minLength) {
+ errors.push(format(me.minLengthText, me.minLength));
}
- this.stack.remove(item);
- },
- // private
- onItemEnabled : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).removeClass('x-item-disabled');
+ if (value.length > me.maxLength) {
+ errors.push(format(me.maxLengthText, me.maxLength));
}
- },
- // private
- onItemTitleChanged : function(item){
- var el = this.getTabEl(item);
- if(el){
- Ext.fly(el).child('span.x-tab-strip-text', true).innerHTML = item.title;
+ if (vtype) {
+ if(!vtypes[vtype](value, me)){
+ errors.push(me.vtypeText || vtypes[vtype +'Text']);
+ }
}
- },
- //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');
+ if (regex && !regex.test(value)) {
+ errors.push(me.regexText || me.invalidText);
}
- },
-
- /**
- * 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;
- },
- // private
- onResize : function(){
- Ext.TabPanel.superclass.onResize.apply(this, arguments);
- this.delegateUpdates();
+ return errors;
},
/**
- * Suspends any internal calculations or scrolling while doing a bulk operation. See {@link #endUpdate}
+ * 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)
*/
- beginUpdate : function(){
- this.suspendUpdates = true;
+ selectText : function(start, end){
+ var me = this,
+ v = me.getRawValue(),
+ doFocus = true,
+ el = me.inputEl.dom,
+ undef,
+ range;
+
+ if (v.length > 0) {
+ start = start === undef ? 0 : start;
+ end = end === undef ? v.length : end;
+ if (el.setSelectionRange) {
+ el.setSelectionRange(start, end);
+ }
+ else if(el.createTextRange) {
+ range = el.createTextRange();
+ range.moveStart('character', start);
+ range.moveEnd('character', end - v.length);
+ range.select();
+ }
+ doFocus = Ext.isGecko || Ext.isOpera;
+ }
+ if (doFocus) {
+ me.focus();
+ }
},
/**
- * Resumes calculations and scrolling at the end of a bulk operation. See {@link #beginUpdate}
+ * 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 if the
+ * width changes.
*/
- endUpdate : function(){
- this.suspendUpdates = false;
- this.delegateUpdates();
+ autoSize: function() {
+ var me = this,
+ width;
+ if (me.grow && me.rendered) {
+ me.doComponentLayout();
+ width = me.inputEl.getWidth();
+ if (width !== me.lastInputWidth) {
+ me.fireEvent('autosize', width);
+ me.lastInputWidth = width;
+ }
+ }
},
- /**
- * Hides the tab strip item for the passed tab
- * @param {Number/String/Panel} item The tab index, id or item
- */
- hideTabStripItem : function(item){
- item = this.getComponent(item);
- var el = this.getTabEl(item);
- if(el){
- el.style.display = 'none';
- this.delegateUpdates();
- }
- this.stack.remove(item);
+ initAria: function() {
+ this.callParent();
+ this.getActionEl().dom.setAttribute('aria-required', this.allowBlank === false);
},
/**
- * Unhides the tab strip item for the passed tab
- * @param {Number/String/Panel} item The tab index, id or item
+ * @protected override
+ * To get the natural width of the inputEl, we do a simple calculation based on the
+ * 'size' config. We use hard-coded numbers to approximate what browsers do natively,
+ * to avoid having to read any styles which would hurt performance.
*/
- unhideTabStripItem : function(item){
- item = this.getComponent(item);
- var el = this.getTabEl(item);
- if(el){
- el.style.display = '';
- this.delegateUpdates();
- }
- },
+ getBodyNaturalWidth: function() {
+ return Math.round(this.size * 6.5) + 20;
+ }
- // private
- delegateUpdates : function(){
- var rendered = this.rendered;
- if(this.suspendUpdates){
- return;
- }
- if(this.resizeTabs && rendered){
- this.autoSizeTabs();
- }
- if(this.enableTabScroll && rendered){
- this.autoScrollTabs();
- }
- },
+});
- // private
- autoSizeTabs : function(){
- var count = this.items.length,
- ce = this.tabPosition != 'bottom' ? 'header' : 'footer',
- ow = this[ce].dom.offsetWidth,
- aw = this[ce].dom.clientWidth;
+/**
+ * @class Ext.form.field.TextArea
+ * @extends Ext.form.field.Text
+
+This class creates a multiline text field, which can be used as a direct replacement for traditional
+textarea fields. In addition, it supports automatically {@link #grow growing} the height of the textarea to
+fit its content.
+
+All of the configuration options from {@link Ext.form.field.Text} can be used on TextArea.
+{@img Ext.form.TextArea/Ext.form.TextArea.png Ext.form.TextArea component}
+Example usage:
+
+ Ext.create('Ext.form.FormPanel', {
+ title : 'Sample TextArea',
+ width : 400,
+ bodyPadding: 10,
+ renderTo : Ext.getBody(),
+ items: [{
+ xtype : 'textareafield',
+ grow : true,
+ name : 'message',
+ fieldLabel: 'Message',
+ anchor : '100%'
+ }]
+ });
- if(!this.resizeTabs || count < 1 || !aw){ // !aw for display:none
- return;
- }
+Some other useful configuration options when using {@link #grow} are {@link #growMin} and {@link #growMax}. These
+allow you to set the minimum and maximum grow heights for the textarea.
- 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';
+ * @docauthor Robert Dougan
+ */
+Ext.define('Ext.form.field.TextArea', {
+ extend:'Ext.form.field.Text',
+ alias: ['widget.textareafield', 'widget.textarea'],
+ alternateClassName: 'Ext.form.TextArea',
+ requires: ['Ext.XTemplate', 'Ext.layout.component.field.TextArea'],
+
+ fieldSubTpl: [
+ '',
+ {
+ compiled: true,
+ disableFormats: true
}
- },
+ ],
- // private
- adjustBodyWidth : function(w){
- if(this.header){
- this.header.setWidth(w);
- }
- if(this.footer){
- this.footer.setWidth(w);
- }
- return w;
- },
+ /**
+ * @cfg {Number} growMin The minimum height to allow when {@link Ext.form.field.Text#grow grow}=true
+ * (defaults to 60)
+ */
+ growMin: 60,
/**
- * 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}.
+ * @cfg {Number} growMax The maximum height to allow when {@link Ext.form.field.Text#grow grow}=true
+ * (defaults to 1000)
*/
- 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');
- }
- }
- this.activeTab = item;
- if(item){
- var el = this.getTabEl(item);
- Ext.fly(el).addClass('x-tab-strip-active');
- this.stack.add(item);
+ growMax: 1000,
- this.layout.setActiveItem(item);
- // Need to do this here, since setting the active tab slightly changes the size
- this.delegateUpdates();
- if(this.scrolling){
- this.scrollToTab(item, this.animScroll);
- }
- }
- this.fireEvent('tabchange', this, item);
- }
- },
+ /**
+ * @cfg {String} growAppend
+ * A string that will be appended to the field's current value for the purposes of calculating the target
+ * field size. Only used when the {@link #grow} config is true. Defaults to a newline for TextArea
+ * to ensure there is always a space below the current line.
+ */
+ growAppend: '\n-',
/**
- * 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.
+ * @cfg {Number} cols An initial value for the 'cols' attribute on the textarea element. This is only
+ * used if the component has no configured {@link #width} and is not given a width by its container's
+ * layout. Defaults to 20.
*/
- getActiveTab : function(){
- return this.activeTab || null;
- },
+ cols: 20,
/**
- * Gets the specified tab by id.
- * @param {String} id The tab id
- * @return {Panel} The tab
+ * @cfg {Number} cols An initial value for the 'cols' attribute on the textarea element. This is only
+ * used if the component has no configured {@link #width} and is not given a width by its container's
+ * layout. Defaults to 4.
*/
- getItem : function(item){
- return this.getComponent(item);
- },
+ rows: 4,
- // 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 || cw < 20){ // 20 to prevent display:none issues
- return;
- }
- if(count == 0 || l <= tw){
- // ensure the width is set if there's no tabs
- 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();
- }
- },
+ /**
+ * @cfg {Boolean} enterIsSpecial
+ * True if you want the enter key to be classed as a special key. Special keys are generally navigation
+ * keys (arrows, space, enter). Setting the config property to true would mean that you could not insert
+ * returns into the textarea.
+ * (defaults to false)
+ */
+ enterIsSpecial: false,
- // private
- createScrollers : function(){
- this.pos.addClass('x-tab-scrolling-' + this.tabPosition);
- var h = this.stripWrap.dom.offsetHeight;
+ /**
+ * @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,
- // 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;
+ // private
+ componentLayout: 'textareafield',
- // 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
+ // private
+ onRender: function(ct, position) {
+ var me = this;
+ Ext.applyIf(me.subTplData, {
+ cols: me.cols,
+ rows: me.rows
});
- this.scrollRight = sr;
- },
- // private
- getScrollWidth : function(){
- return this.edge.getOffsetsTo(this.stripWrap)[0] + this.getScrollPos();
+ me.callParent(arguments);
},
// private
- getScrollPos : function(){
- return parseInt(this.stripWrap.dom.scrollLeft, 10) || 0;
- },
+ afterRender: function(){
+ var me = this;
- // private
- getScrollArea : function(){
- return parseInt(this.stripWrap.dom.clientWidth, 10) || 0;
- },
+ me.callParent(arguments);
- // private
- getScrollAnim : function(){
- return {duration:this.scrollDuration, callback: this.updateScrollButtons, scope: this};
+ if (me.grow) {
+ if (me.preventScrollbars) {
+ me.inputEl.setStyle('overflow', 'hidden');
+ }
+ me.inputEl.setHeight(me.growMin);
+ }
},
// private
- getScrollIncrement : function(){
- return this.scrollIncrement || (this.resizeTabs ? this.lastTabWidth+2 : 100);
+ fireKey: function(e) {
+ if (e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() !== e.ENTER || e.hasModifier()))) {
+ this.fireEvent('specialkey', this, e);
+ }
},
/**
- * 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
+ * Automatically grows the field to accomodate the height of the text up to the maximum field height allowed.
+ * This only takes effect if {@link #grow} = true, and fires the {@link #autosize} event if
+ * the height changes.
*/
+ autoSize: function() {
+ var me = this,
+ height;
- 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);
+ if (me.grow && me.rendered) {
+ me.doComponentLayout();
+ height = me.inputEl.getHeight();
+ if (height !== me.lastInputHeight) {
+ me.fireEvent('autosize', height);
+ me.lastInputHeight = height;
+ }
}
},
// private
- scrollTo : function(pos, animate){
- this.stripWrap.scrollTo('left', pos, animate ? this.getScrollAnim() : false);
- if(!animate){
- this.updateScrollButtons();
- }
+ initAria: function() {
+ this.callParent(arguments);
+ this.getActionEl().dom.setAttribute('aria-multiline', true);
},
- onWheel : function(e){
- var d = e.getWheelDelta()*this.wheelIncrement*-1;
- e.stopEvent();
+ /**
+ * @protected override
+ * To get the natural width of the textarea element, we do a simple calculation based on the
+ * 'cols' config. We use hard-coded numbers to approximate what browsers do natively,
+ * to avoid having to read any styles which would hurt performance.
+ */
+ getBodyNaturalWidth: function() {
+ return Math.round(this.cols * 6.5) + 20;
+ }
- var pos = this.getScrollPos(),
- newpos = pos + d,
- sw = this.getScrollWidth()-this.getScrollArea();
+});
- var s = Math.max(0, Math.min(sw, newpos));
- if(s != pos){
- this.scrollTo(s, false);
- }
- },
- // 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);
- }
- },
+/**
+ * @class Ext.window.MessageBox
+ * @extends Ext.window.Window
- // private
- onScrollLeft : function(){
- var pos = this.getScrollPos(),
- s = Math.max(0, pos - this.getScrollIncrement());
- if(s != pos){
- this.scrollTo(s, this.animScroll);
+Utility class for generating different styles of message boxes. The singleton instance, `Ext.Msg` can also be used.
+Note that a 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).
+
+{@img Ext.window.MessageBox/messagebox1.png alert MessageBox}
+{@img Ext.window.MessageBox/messagebox2.png prompt MessageBox}
+{@img Ext.window.MessageBox/messagebox3.png show MessageBox}
+#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...
}
- },
+ });
- // 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');
- },
+ // 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,
+ animateTarget: 'elId',
+ icon: Ext.window.MessageBox.QUESTION
+ });
- // 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);
- }
+ * @markdown
+ * @singleton
+ */
+Ext.define('Ext.window.MessageBox', {
+ extend: 'Ext.window.Window',
+
+ requires: [
+ 'Ext.toolbar.Toolbar',
+ 'Ext.form.field.Text',
+ 'Ext.form.field.TextArea',
+ 'Ext.button.Button',
+ 'Ext.layout.container.Anchor',
+ 'Ext.layout.container.HBox',
+ 'Ext.ProgressBar'
+ ],
+
+ alternateClassName: 'Ext.MessageBox',
+
+ alias: 'widget.messagebox',
/**
- * @cfg {Boolean} collapsible
- * @hide
+ * Button config that displays a single OK button
+ * @type Number
*/
+ OK : 1,
/**
- * @cfg {String} header
- * @hide
+ * Button config that displays a single Yes button
+ * @type Number
*/
+ YES : 2,
/**
- * @cfg {Boolean} headerAsText
- * @hide
+ * Button config that displays a single No button
+ * @type Number
*/
+ NO : 4,
/**
- * @property header
- * @hide
+ * Button config that displays a single Cancel button
+ * @type Number
*/
+ CANCEL : 8,
/**
- * @cfg title
- * @hide
+ * Button config that displays OK and Cancel buttons
+ * @type Number
*/
+ OKCANCEL : 9,
/**
- * @cfg {Array} tools
- * @hide
+ * Button config that displays Yes and No buttons
+ * @type Number
*/
+ YESNO : 6,
/**
- * @cfg {Array} toolTemplate
- * @hide
+ * Button config that displays Yes, No and Cancel buttons
+ * @type Number
*/
+ YESNOCANCEL : 14,
/**
- * @cfg {Boolean} hideCollapseTool
- * @hide
+ * The CSS class that provides the INFO icon image
+ * @type String
*/
+ INFO : 'ext-mb-info',
/**
- * @cfg {Boolean} titleCollapse
- * @hide
+ * The CSS class that provides the WARNING icon image
+ * @type String
*/
+ WARNING : 'ext-mb-warning',
/**
- * @cfg {Boolean} collapsed
- * @hide
+ * The CSS class that provides the QUESTION icon image
+ * @type String
*/
+ QUESTION : 'ext-mb-question',
/**
- * @cfg {String} layout
- * @hide
+ * The CSS class that provides the ERROR icon image
+ * @type String
+ */
+ ERROR : 'ext-mb-error',
+
+ // hide it by offsets. Windows are hidden on render by default.
+ hideMode: 'offsets',
+ closeAction: 'hide',
+ resizable: false,
+ title: ' ',
+
+ width: 600,
+ height: 500,
+ minWidth: 250,
+ maxWidth: 600,
+ minHeight: 110,
+ maxHeight: 500,
+ constrain: true,
+
+ cls: Ext.baseCSSPrefix + 'message-box',
+
+ layout: {
+ type: 'anchor'
+ },
+
+ /**
+ * The default height in pixels of the message box's multiline textarea if displayed (defaults to 75)
+ * @type Number
*/
+ defaultTextHeight : 75,
/**
- * @cfg {Boolean} preventBodyReset
- * @hide
+ * 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
*/
-});
-Ext.reg('tabpanel', Ext.TabPanel);
+ 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.window.MessageBox.buttonText.yes = "oui"; //french
+ * @type Object
+ */
+ buttonText: {
+ ok: 'OK',
+ yes: 'Yes',
+ no: 'No',
+ cancel: 'Cancel'
+ },
-/**
- * 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;
+ buttonIds: [
+ 'ok', 'yes', 'no', 'cancel'
+ ],
+
+ titleText: {
+ confirm: 'Confirm',
+ prompt: 'Prompt',
+ wait: 'Loading...',
+ alert: 'Attention'
+ },
+
+ iconHeight: 35,
+
+ makeButton: function(btnIdx) {
+ var btnId = this.buttonIds[btnIdx];
+ return Ext.create('Ext.button.Button', {
+ handler: this.btnCallback,
+ itemId: btnId,
+ scope: this,
+ text: this.buttonText[btnId],
+ minWidth: 75
+ });
+ },
+
+ btnCallback: function(btn) {
+ var me = this,
+ value,
+ field;
+
+ if (me.cfg.prompt || me.cfg.multiline) {
+ if (me.cfg.multiline) {
+ field = me.textArea;
+ } else {
+ field = me.textField;
+ }
+ value = field.getValue();
+ field.reset();
+ }
+
+ // Important not to have focus remain in the hidden Window; Interferes with DnD.
+ btn.blur();
+ me.hide();
+ me.userCallback(btn.itemId, value, me.cfg);
+ },
+
+ hide: function() {
+ var me = this;
+ me.dd.endDrag();
+ me.progressBar.reset();
+ me.removeCls(me.cfg.cls);
+ me.callParent();
+ },
+
+ initComponent: function() {
+ var me = this,
+ i, button;
+
+ me.title = ' ';
+
+ me.topContainer = Ext.create('Ext.container.Container', {
+ anchor: '100%',
+ style: {
+ padding: '10px',
+ overflow: 'hidden'
+ },
+ items: [
+ me.iconComponent = Ext.create('Ext.Component', {
+ cls: 'ext-mb-icon',
+ width: 50,
+ height: me.iconHeight,
+ style: {
+ 'float': 'left'
+ }
+ }),
+ me.promptContainer = Ext.create('Ext.container.Container', {
+ layout: {
+ type: 'anchor'
+ },
+ items: [
+ me.msg = Ext.create('Ext.Component', {
+ autoEl: { tag: 'span' },
+ cls: 'ext-mb-text'
+ }),
+ me.textField = Ext.create('Ext.form.field.Text', {
+ anchor: '100%',
+ enableKeyEvents: true,
+ listeners: {
+ keydown: me.onPromptKey,
+ scope: me
+ }
+ }),
+ me.textArea = Ext.create('Ext.form.field.TextArea', {
+ anchor: '100%',
+ height: 75
+ })
+ ]
+ })
+ ]
+ });
+ me.progressBar = Ext.create('Ext.ProgressBar', {
+ anchor: '-10',
+ style: 'margin-left:10px'
+ });
+
+ me.items = [me.topContainer, me.progressBar];
+
+ // Create the buttons based upon passed bitwise config
+ me.msgButtons = [];
+ for (i = 0; i < 4; i++) {
+ button = me.makeButton(i);
+ me.msgButtons[button.itemId] = button;
+ me.msgButtons.push(button);
+ }
+ me.bottomTb = Ext.create('Ext.toolbar.Toolbar', {
+ ui: 'footer',
+ dock: 'bottom',
+ layout: {
+ pack: 'center'
+ },
+ items: [
+ me.msgButtons[0],
+ me.msgButtons[1],
+ me.msgButtons[2],
+ me.msgButtons[3]
+ ]
+ });
+ me.dockedItems = [me.bottomTb];
+
+ me.callParent();
+ },
+
+ onPromptKey: function(textField, e) {
+ var me = this,
+ blur;
+
+ if (e.keyCode === Ext.EventObject.RETURN || e.keyCode === 10) {
+ if (me.msgButtons.ok.isVisible()) {
+ blur = true;
+ me.msgButtons.ok.handler.call(me, me.msgButtons.ok);
+ } else if (me.msgButtons.yes.isVisible()) {
+ me.msgButtons.yes.handler.call(me, me.msgButtons.yes);
+ blur = true;
+ }
+
+ if (blur) {
+ me.textField.blur();
+ }
+ }
+ },
+
+ reconfigure: function(cfg) {
+ var me = this,
+ buttons = cfg.buttons || 0,
+ hideToolbar = true,
+ initialWidth = me.maxWidth,
+ i;
+
+ cfg = cfg || {};
+ me.cfg = cfg;
+ if (cfg.width) {
+ initialWidth = cfg.width;
+ }
+
+ // Default to allowing the Window to take focus.
+ delete me.defaultFocus;
+
+ // clear any old animateTarget
+ me.animateTarget = cfg.animateTarget || undefined;
+
+ // Defaults to modal
+ me.modal = cfg.modal !== false;
+
+ // Show the title
+ if (cfg.title) {
+ me.setTitle(cfg.title||' ');
+ }
+
+ if (!me.rendered) {
+ me.width = initialWidth;
+ me.render(Ext.getBody());
+ } else {
+ me.hidden = false;
+ me.setSize(initialWidth, me.maxHeight);
+ }
+ me.setPosition(-10000, -10000);
+
+ // Hide or show the close tool
+ me.closable = cfg.closable && !cfg.wait;
+ if (cfg.closable === false) {
+ me.tools.close.hide();
+ } else {
+ me.tools.close.show();
+ }
+
+ // Hide or show the header
+ if (!cfg.title && !me.closable) {
+ me.header.hide();
+ } else {
+ me.header.show();
+ }
+
+ // Default to dynamic drag: drag the window, not a ghost
+ me.liveDrag = !cfg.proxyDrag;
+
+ // wrap the user callback
+ me.userCallback = Ext.Function.bind(cfg.callback ||cfg.fn || Ext.emptyFn, cfg.scope || Ext.global);
+
+ // Hide or show the icon Component
+ me.setIcon(cfg.icon);
+
+ // Hide or show the message area
+ if (cfg.msg) {
+ me.msg.update(cfg.msg);
+ me.msg.show();
+ } else {
+ me.msg.hide();
+ }
+
+ // Hide or show the input field
+ if (cfg.prompt || cfg.multiline) {
+ me.multiline = cfg.multiline;
+ if (cfg.multiline) {
+ me.textArea.setValue(cfg.value);
+ me.textArea.setHeight(cfg.defaultTextHeight || me.defaultTextHeight);
+ me.textArea.show();
+ me.textField.hide();
+ me.defaultFocus = me.textArea;
+ } else {
+ me.textField.setValue(cfg.value);
+ me.textArea.hide();
+ me.textField.show();
+ me.defaultFocus = me.textField;
+ }
+ } else {
+ me.textArea.hide();
+ me.textField.hide();
+ }
-// 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();
+ // Hide or show the progress bar
+ if (cfg.progress || cfg.wait) {
+ me.progressBar.show();
+ me.updateProgress(0, cfg.progressText);
+ if(cfg.wait === true){
+ me.progressBar.wait(cfg.waitConfig);
}
- },
+ } else {
+ me.progressBar.hide();
+ }
- remove : function(item){
- var s = [];
- for(var i = 0, len = items.length; i < len; i++) {
- if(items[i] != item){
- s.push(items[i]);
+ // Hide or show buttons depending on flag value sent.
+ for (i = 0; i < 4; i++) {
+ if (buttons & Math.pow(2, i)) {
+
+ // Default to focus on the first visible button if focus not already set
+ if (!me.defaultFocus) {
+ me.defaultFocus = me.msgButtons[i];
}
+ me.msgButtons[i].show();
+ hideToolbar = false;
+ } else {
+ me.msgButtons[i].hide();
}
- items = s;
- },
+ }
+
+ // Hide toolbar if no buttons to show
+ if (hideToolbar) {
+ me.bottomTb.hide();
+ } else {
+ me.bottomTb.show();
+ }
+ me.hidden = true;
+ },
+
+ /**
+ * 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:
+ *
animateTarget : String/Element
An id or Element from which the message box should animate as it
+ * opens and closes (defaults to undefined)
+ *
buttons : Number
A bitwise button specifier consisting of the sum of any of the following constants:
+ *
Ext.window.MessageBox.OK
+ *
Ext.window.MessageBox.YES
+ *
Ext.window.MessageBox.NO
+ *
Ext.window.MessageBox.CANCEL
+ *
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 (this reference) in which the function will be executed.
+ *
icon : String
A CSS class that provides a background image to be used as the body icon for the
+ * dialog (e.g. Ext.window.MessageBox.WARNING or 'custom-class') (defaults to '')
+ *
iconCls : String
The standard {@link Ext.window.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)
+ * @return {Ext.window.MessageBox} this
+ */
+ show: function(cfg) {
+ var me = this;
- next : function(){
- return items.pop();
+ me.reconfigure(cfg);
+ me.addCls(cfg.cls);
+ if (cfg.animateTarget) {
+ me.doAutoSize(false);
+ me.callParent();
+ } else {
+ me.callParent();
+ me.doAutoSize(true);
}
- };
-};
-/**
- * @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, {
+ return me;
+ },
+
+ afterShow: function(){
+ if (this.animateTarget) {
+ this.center();
+ }
+ this.callParent(arguments);
+ },
+
+ doAutoSize: function(center) {
+ var me = this,
+ icon = me.iconComponent,
+ iconHeight = me.iconHeight;
+
+ if (!Ext.isDefined(me.frameWidth)) {
+ me.frameWidth = me.el.getWidth() - me.body.getWidth();
+ }
+
+ // reset to the original dimensions
+ icon.setHeight(iconHeight);
+
+ // Allow per-invocation override of minWidth
+ me.minWidth = me.cfg.minWidth || Ext.getClass(this).prototype.minWidth;
+
+ // Set best possible size based upon allowing the text to wrap in the maximized Window, and
+ // then constraining it to within the max with. Then adding up constituent element heights.
+ me.topContainer.doLayout();
+ if (Ext.isIE6 || Ext.isIEQuirks) {
+ // In IE quirks, the initial full width of the prompt fields will prevent the container element
+ // from collapsing once sized down, so temporarily force them to a small width. They'll get
+ // layed out to their final width later when setting the final window size.
+ me.textField.setCalculatedSize(9);
+ me.textArea.setCalculatedSize(9);
+ }
+ var width = me.cfg.width || me.msg.getWidth() + icon.getWidth() + 25, /* topContainer's layout padding */
+ height = (me.header.rendered ? me.header.getHeight() : 0) +
+ Math.max(me.promptContainer.getHeight(), icon.getHeight()) +
+ me.progressBar.getHeight() +
+ (me.bottomTb.rendered ? me.bottomTb.getHeight() : 0) + 20 ;/* topContainer's layout padding */
+
+ // Update to the size of the content, this way the text won't wrap under the icon.
+ icon.setHeight(Math.max(iconHeight, me.msg.getHeight()));
+ me.setSize(width + me.frameWidth, height + me.frameWidth);
+ if (center) {
+ me.center();
+ }
+ return me;
+ },
+
+ updateText: function(text) {
+ this.msg.update(text);
+ return this.doAutoSize(true);
+ },
+
/**
- * Read-only. True if this button is hidden
- * @type Boolean
- */
- hidden : false,
+ * 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:
+ *
+ * @param {String} icon A CSS classname specifying the icon's background image url, or empty string to clear the icon
+ * @return {Ext.window.MessageBox} this
+ */
+ setIcon : function(icon) {
+ var me = this;
+ me.iconComponent.removeCls(me.iconCls);
+ if (icon) {
+ me.iconComponent.show();
+ me.iconComponent.addCls(Ext.baseCSSPrefix + 'dlg-icon');
+ me.iconComponent.addCls(me.iconCls = icon);
+ } else {
+ me.iconComponent.removeCls(Ext.baseCSSPrefix + 'dlg-icon');
+ me.iconComponent.hide();
+ }
+ return me;
+ },
+
/**
- * Read-only. True if this button is disabled
- * @type Boolean
+ * Updates a progress-style message box's text and progress bar. Only relevant on message boxes
+ * initiated via {@link Ext.window.MessageBox#progress} or {@link Ext.window.MessageBox#wait},
+ * or by calling {@link Ext.window.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.window.MessageBox} this
*/
- disabled : false,
+ updateProgress : function(value, progressText, msg){
+ this.progressBar.updateProgress(value, progressText);
+ if (msg){
+ this.updateText(msg);
+ }
+ return this;
+ },
+
+ onEsc: function() {
+ if (this.closable !== false) {
+ this.callParent(arguments);
+ }
+ },
+
/**
- * Read-only. True if this button is pressed (only if enableToggle = true)
- * @type Boolean
+ * 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.window.MessageBox} this
*/
- pressed : false,
+ confirm: function(cfg, msg, fn, scope) {
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title: cfg,
+ icon: 'ext-mb-question',
+ msg: msg,
+ buttons: this.YESNO,
+ callback: fn,
+ scope: scope
+ };
+ }
+ return this.show(cfg);
+ },
/**
- * @cfg {Number} tabIndex Set a DOM tabIndex for this button (defaults to undefined)
+ * 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.window.MessageBox} this
*/
+ prompt : function(cfg, msg, fn, scope, multiline, value){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ prompt: true,
+ title: cfg,
+ minWidth: this.minPromptWidth,
+ msg: msg,
+ buttons: this.OKCANCEL,
+ callback: fn,
+ scope: scope,
+ multiline: multiline,
+ value: value
+ };
+ }
+ return this.show(cfg);
+ },
/**
- * @cfg {Boolean} allowDepress
- * False to not allow a pressed Button to be depressed (defaults to undefined). Only valid when {@link #enableToggle} is true.
+ * 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.window.MessageBox} this
*/
+ wait : function(cfg, title, config){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title : title,
+ msg : cfg,
+ closable: false,
+ wait: true,
+ modal: true,
+ minWidth: this.minProgressWidth,
+ waitConfig: config
+ };
+ }
+ return this.show(cfg);
+ },
/**
- * @cfg {Boolean} enableToggle
- * True to enable pressed/not pressed toggling (defaults to false)
+ * 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.window.MessageBox} this
*/
- enableToggle : false,
+ alert: function(cfg, msg, fn, scope) {
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title : cfg,
+ msg : msg,
+ buttons: this.OK,
+ fn: fn,
+ scope : scope,
+ minWidth: this.minWidth
+ };
+ }
+ return this.show(cfg);
+ },
+
/**
- * @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.
- *
+ * 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.window.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.window.MessageBox} this
*/
+ progress : function(cfg, msg, progressText){
+ if (Ext.isString(cfg)) {
+ cfg = {
+ title: cfg,
+ msg: msg,
+ progressText: progressText
+ };
+ }
+ return this.show(cfg);
+ }
+}, function() {
+ Ext.MessageBox = Ext.Msg = new this();
+});
+/**
+ * @class Ext.form.Basic
+ * @extends Ext.util.Observable
+ *
+ * Provides input field management, validation, submission, and form loading services for the collection
+ * of {@link Ext.form.field.Field Field} instances within a {@link Ext.container.Container}. It is recommended
+ * that you use a {@link Ext.form.Panel} as the form container, as that has logic to automatically
+ * hook up an instance of {@link Ext.form.Basic} (plus other conveniences related to field configuration.)
+ *
+ * ## Form Actions
+ *
+ * The Basic class delegates the handling of form loads and submits to instances of {@link Ext.form.action.Action}.
+ * See the various Action implementations for specific details of each one's functionality, as well as the
+ * documentation for {@link #doAction} which details the configuration options that can be specified in
+ * each action call.
+ *
+ * The default submit Action is {@link Ext.form.action.Submit}, which uses an Ajax request to submit the
+ * form's values to a configured URL. To enable normal browser submission of an Ext form, use the
+ * {@link #standardSubmit} config option.
+ *
+ * Note: File uploads are not performed using normal 'Ajax' techniques; see the description for
+ * {@link #hasUpload} for details.
+ *
+ * ## Example usage:
+ *
+ * Ext.create('Ext.form.Panel', {
+ * title: 'Basic Form',
+ * renderTo: Ext.getBody(),
+ * bodyPadding: 5,
+ * width: 350,
+ *
+ * // Any configuration items here will be automatically passed along to
+ * // the Ext.form.Basic instance when it gets created.
+ *
+ * // The form will submit an AJAX request to this URL when submitted
+ * url: 'save-form.php',
+ *
+ * items: [{
+ * fieldLabel: 'Field',
+ * name: 'theField'
+ * }],
+ *
+ * buttons: [{
+ * text: 'Submit',
+ * handler: function() {
+ * // The getForm() method returns the Ext.form.Basic instance:
+ * var form = this.up('form').getForm();
+ * if (form.isValid()) {
+ * // Submit the Ajax request and handle the response
+ * form.submit({
+ * success: function(form, action) {
+ * Ext.Msg.alert('Success', action.result.msg);
+ * },
+ * failure: function(form, action) {
+ * Ext.Msg.alert('Failed', action.result.msg);
+ * }
+ * });
+ * }
+ * }
+ * }]
+ * });
+ *
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.Basic', {
+ extend: 'Ext.util.Observable',
+ alternateClassName: 'Ext.form.BasicForm',
+ requires: ['Ext.util.MixedCollection', 'Ext.form.action.Load', 'Ext.form.action.Submit',
+ 'Ext.window.MessageBox', 'Ext.data.Errors', 'Ext.util.DelayedTask'],
+
/**
- * @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).
+ * Creates new form.
+ * @param {Ext.container.Container} owner The component that is the container for the form, usually a {@link Ext.form.Panel}
+ * @param {Object} config Configuration options. These are normally specified in the config to the
+ * {@link Ext.form.Panel} constructor, which passes them along to the BasicForm automatically.
*/
+ constructor: function(owner, config) {
+ var me = this,
+ onItemAddOrRemove = me.onItemAddOrRemove;
+
+ /**
+ * @property owner
+ * @type Ext.container.Container
+ * The container component to which this BasicForm is attached.
+ */
+ me.owner = owner;
+
+ // Listen for addition/removal of fields in the owner container
+ me.mon(owner, {
+ add: onItemAddOrRemove,
+ remove: onItemAddOrRemove,
+ scope: me
+ });
+
+ Ext.apply(me, config);
+
+ // Normalize the paramOrder to an Array
+ if (Ext.isString(me.paramOrder)) {
+ me.paramOrder = me.paramOrder.split(/[\s,|]/);
+ }
+
+ me.checkValidityTask = Ext.create('Ext.util.DelayedTask', me.checkValidity, me);
+
+ me.addEvents(
+ /**
+ * @event beforeaction
+ * Fires before any action is performed. Return false to cancel the action.
+ * @param {Ext.form.Basic} this
+ * @param {Ext.form.action.Action} action The {@link Ext.form.action.Action} to be performed
+ */
+ 'beforeaction',
+ /**
+ * @event actionfailed
+ * Fires when an action fails.
+ * @param {Ext.form.Basic} this
+ * @param {Ext.form.action.Action} action The {@link Ext.form.action.Action} that failed
+ */
+ 'actionfailed',
+ /**
+ * @event actioncomplete
+ * Fires when an action is completed.
+ * @param {Ext.form.Basic} this
+ * @param {Ext.form.action.Action} action The {@link Ext.form.action.Action} that completed
+ */
+ 'actioncomplete',
+ /**
+ * @event validitychange
+ * Fires when the validity of the entire form changes.
+ * @param {Ext.form.Basic} this
+ * @param {Boolean} valid true if the form is now valid, false if it is now invalid.
+ */
+ 'validitychange',
+ /**
+ * @event dirtychange
+ * Fires when the dirty state of the entire form changes.
+ * @param {Ext.form.Basic} this
+ * @param {Boolean} dirty true if the form is now dirty, false if it is no longer dirty.
+ */
+ 'dirtychange'
+ );
+ me.callParent();
+ },
+
/**
- * @cfg {String} menuAlign
- * The position to align the menu to (see {@link Ext.Element#alignTo} for more details, defaults to 'tl-bl?').
+ * Do any post constructor initialization
+ * @private
*/
- menuAlign : 'tl-bl?',
+ initialize: function(){
+ this.initialized = true;
+ this.onValidityChange(!this.hasInvalidField());
+ },
/**
- * @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} method
+ * The request method to use (GET or POST) for form actions if one isn't supplied in the action options.
*/
/**
- * @cfg {String} iconCls
- * A css class which sets a background image to be used as the icon for this button
+ * @cfg {Ext.data.reader.Reader} reader
+ * An Ext.data.DataReader (e.g. {@link Ext.data.reader.Xml}) to be used to read
+ * data when executing 'load' actions. This is optional as there is built-in
+ * support for processing JSON responses.
*/
/**
- * @cfg {String} type
- * submit, reset or button - defaults to 'button'
+ * @cfg {Ext.data.reader.Reader} errorReader
+ *
An Ext.data.DataReader (e.g. {@link Ext.data.reader.Xml}) to be used to
+ * read field error messages returned from 'submit' actions. This is optional
+ * as there is built-in support for processing JSON responses.
+ *
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
+ * Reader. It simply needs to implement a read(xhr) function
+ * which returns an Array of Records in an object with the following
+ * structure:
+{
+ records: recordArray
+}
+
*/
- 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'.
+ * @cfg {String} url
+ * The URL to use for form actions if one isn't supplied in the
+ * {@link #doAction doAction} options.
*/
- clickEvent : 'click',
/**
- * @cfg {Boolean} handleMouseEvents
- * False to disable visual cues on mouseover, mouseout and mousedown (defaults to true)
+ * @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 Ext.Object.toQueryString}.
*/
- handleMouseEvents : true,
/**
- * @cfg {String} tooltipType
- * The type of tooltip to use. Either 'qtip' (default) for QuickTips or 'title' for title attribute.
+ * @cfg {Number} timeout Timeout for form actions in seconds (default is 30 seconds).
*/
- tooltipType : 'qtip',
+ timeout: 30,
/**
- * @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'.
+ * @cfg {Object} api (Optional) If specified, load and submit actions will be handled
+ * with {@link Ext.form.action.DirectLoad} and {@link Ext.form.action.DirectLoad}.
+ * Methods which have been imported by {@link Ext.direct.Manager} can be specified here to load and submit
+ * forms.
+ * Such as the following:
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 {@link Ext.direct.Manager}.
(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'.
+ * @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:
*/
- scale : 'small',
/**
- * @cfg {Object} scope The scope (this reference) in which the
- * {@link #handler} and {@link #toggleHandler} is
- * executed. Defaults to this Button.
+ * @cfg {Boolean} paramsAsHash Only used for the {@link #api}
+ * load configuration. If true, parameters will be sent as a
+ * single hash collection of named arguments (defaults to false). Providing a
+ * {@link #paramOrder} nullifies this configuration.
*/
+ paramsAsHash: false,
/**
- * @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'.
+ * @cfg {String} waitTitle
+ * The default title to show for the waiting message box (defaults to 'Please Wait...')
*/
- iconAlign : 'left',
+ waitTitle: 'Please Wait...',
/**
- * @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'.
+ * @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.
*/
- arrowAlign : 'right',
+ trackResetOnLoad: false,
/**
- * @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 {Boolean} standardSubmit
+ *
If set to true, a standard HTML form submit is used instead
+ * of a XHR (Ajax) style form submission. Defaults to false. All of
+ * the field values, plus any additional params configured via {@link #baseParams}
+ * and/or the options to {@link #submit}, will be included in the
+ * values submitted in the form.
*/
+
/**
- * @cfg {String} cls
- * A CSS class string to apply to the button's main element.
+ * @cfg {Mixed} waitMsgTarget
+ * 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. Defaults to undefined.
*/
+
+
+ // Private
+ wasDirty: false,
+
+
/**
- * @property menu
- * @type Menu
- * The {@link Ext.menu.Menu Menu} object associated with this Button when configured with the {@link #menu} config option.
+ * Destroys this object.
*/
+ destroy: function() {
+ this.clearListeners();
+ this.checkValidityTask.cancel();
+ },
+
/**
- * @cfg {Boolean} autoWidth
- * By default, if a width is not specified the button will attempt to stretch horizontally to fit its content.
- * If the button is being managed by a width sizing layout (hbox, fit, anchor), set this to false to prevent
- * the button from doing this automatic sizing.
- * Defaults to undefined.
+ * @private
+ * Handle addition or removal of descendant items. Invalidates the cached list of fields
+ * so that {@link #getFields} will do a fresh query next time it is called. Also adds listeners
+ * for state change events on added fields, and tracks components with formBind=true.
*/
-
- initComponent : function(){
- if(this.menu){
- this.menu = Ext.menu.MenuMgr.get(this.menu);
- this.menu.ownerCt = this;
+ onItemAddOrRemove: function(parent, child) {
+ var me = this,
+ isAdding = !!child.ownerCt,
+ isContainer = child.isContainer;
+
+ function handleField(field) {
+ // Listen for state change events on fields
+ me[isAdding ? 'mon' : 'mun'](field, {
+ validitychange: me.checkValidity,
+ dirtychange: me.checkDirty,
+ scope: me,
+ buffer: 100 //batch up sequential calls to avoid excessive full-form validation
+ });
+ // Flush the cached list of fields
+ delete me._fields;
}
-
- 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.ownerCt = undefined;
+ if (child.isFormField) {
+ handleField(child);
}
- if(Ext.isString(this.toggleGroup)){
- this.enableToggle = true;
+ else if (isContainer) {
+ // Walk down
+ Ext.Array.forEach(child.query('[isFormField]'), handleField);
}
- },
-/**
- *
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];
- },
+ // Flush the cached list of formBind components
+ delete this._boundItems;
- // 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]);
+ // Check form bind, but only after initial add. Batch it to prevent excessive validation
+ // calls when many fields are being added at once.
+ if (me.initialized) {
+ me.checkValidityTask.delay(10);
}
},
- // protected
- getMenuClass : function(){
- return this.menu ? (this.arrowAlign != 'bottom' ? 'x-btn-arrow' : 'x-btn-arrow-bottom') : '';
+ /**
+ * Return all the {@link Ext.form.field.Field} components in the owner container.
+ * @return {Ext.util.MixedCollection} Collection of the Field objects
+ */
+ getFields: function() {
+ var fields = this._fields;
+ if (!fields) {
+ fields = this._fields = Ext.create('Ext.util.MixedCollection');
+ fields.addAll(this.owner.query('[isFormField]'));
+ }
+ return fields;
},
- // 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;
+ getBoundItems: function() {
+ var boundItems = this._boundItems;
+ if (!boundItems) {
+ boundItems = this._boundItems = Ext.create('Ext.util.MixedCollection');
+ boundItems.addAll(this.owner.query('[formBind]'));
}
+ return boundItems;
+ },
- 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
+ /**
+ * Returns true if the form contains any invalid fields. No fields will be marked as invalid
+ * as a result of calling this; to trigger marking of fields use {@link #isValid} instead.
+ */
+ hasInvalidField: function() {
+ return !!this.getFields().findBy(function(field) {
+ var preventMark = field.preventMark,
+ isValid;
+ field.preventMark = true;
+ isValid = field.isValid();
+ field.preventMark = preventMark;
+ return !isValid;
});
-
- 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
+ /**
+ * Returns true if client-side validation on the form is successful. Any invalid fields will be
+ * marked as invalid. If you only want to determine overall form validity without marking anything,
+ * use {@link #hasInvalidField} instead.
+ * @return Boolean
+ */
+ isValid: function() {
+ var me = this,
+ invalid;
+ me.batchLayouts(function() {
+ invalid = me.getFields().filterBy(function(field) {
+ return !field.validate();
});
+ });
+ return invalid.length < 1;
+ },
- // new functionality for monitoring on the document level
- //this.mon(btn, 'mouseout', this.onMouseOut, this);
+ /**
+ * Check whether the validity of the entire form has changed since it was last checked, and
+ * if so fire the {@link #validitychange validitychange} event. This is automatically invoked
+ * when an individual field's validity changes.
+ */
+ checkValidity: function() {
+ var me = this,
+ valid = !me.hasInvalidField();
+ if (valid !== me.wasValid) {
+ me.onValidityChange(valid);
+ me.fireEvent('validitychange', me, valid);
+ me.wasValid = valid;
}
+ },
- if(this.menu){
- this.mon(this.menu, {
- scope: this,
- show: this.onMenuShow,
- hide: this.onMenuHide
+ /**
+ * @private
+ * Handle changes in the form's validity. If there are any sub components with
+ * formBind=true then they are enabled/disabled based on the new validity.
+ * @param {Boolean} valid
+ */
+ onValidityChange: function(valid) {
+ var boundItems = this.getBoundItems();
+ if (boundItems) {
+ boundItems.each(function(cmp) {
+ if (cmp.disabled === valid) {
+ cmp.setDisabled(!valid);
+ }
});
}
-
- if(this.repeat){
- var repeater = new Ext.util.ClickRepeater(btn, Ext.isObject(this.repeat) ? this.repeat : {});
- this.mon(repeater, 'click', this.onRepeatClick, this);
- }else{
- 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
+ *
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}.
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;
+ * Check whether the dirty state of the entire form has changed since it was last checked, and
+ * if so fire the {@link #dirtychange dirtychange} event. This is automatically invoked
+ * when an individual field's dirty state changes.
+ */
+ checkDirty: function() {
+ var dirty = this.isDirty();
+ if (dirty !== this.wasDirty) {
+ this.fireEvent('dirtychange', this, dirty);
+ this.wasDirty = dirty;
}
- return this;
},
- // private
- clearTip : function(){
- if(Ext.isObject(this.tooltip)){
- Ext.QuickTips.unregister(this.btnEl);
- }
+ /**
+ *
Returns true if the form contains a file upload field. This is used to determine the
+ * method for submitting the form: File uploads are not performed using normal 'Ajax' techniques,
+ * that is they are not performed using XMLHttpRequests. Instead a hidden <form>
+ * element containing all the fields is created temporarily and submitted with 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.
+ * @return Boolean
+ */
+ hasUpload: function() {
+ return !!this.getFields().findBy(function(f) {
+ return f.isFileUpload();
+ });
},
- // private
- beforeDestroy : function(){
- if(this.rendered){
- this.clearTip();
+ /**
+ * Performs a predefined action (an implementation of {@link Ext.form.action.Action})
+ * to perform application-specific processing.
+ * @param {String/Ext.form.action.Action} action The name of the predefined action type,
+ * or instance of {@link Ext.form.action.Action} to perform.
+ * @param {Object} options (optional) The options to pass to the {@link Ext.form.action.Action}
+ * that will get created, if the action argument is a String.
+ *
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 : String
The url for the action (defaults
+ * to the form's {@link #url}.)
+ *
+ *
method : String
The form method to use (defaults
+ * to the form's method, or POST if not defined)
+ *
+ *
params : String/Object
The 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 Ext.Object.toQueryString}.
+ *
+ *
headers : Object
Request headers to set for the action.
+ *
+ *
success : Function
The 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 : The {@link Ext.form.Basic} that requested the action.
+ *
action : The {@link Ext.form.action.Action Action} object which performed the operation.
+ *
The action object contains these properties of interest:
+ *
{@link Ext.form.action.Action#response response}
+ *
{@link Ext.form.action.Action#result result} : interrogate for custom postprocessing
+ *
{@link Ext.form.action.Action#type type}
+ *
+ *
+ *
failure : Function
The callback that will be invoked after a
+ * failed transaction attempt. The function is passed the following parameters:
+ *
form : The {@link Ext.form.Basic} that requested the action.
+ *
action : The {@link Ext.form.action.Action Action} object which performed the operation.
+ *
The action object contains these properties of interest:
{@link Ext.form.action.Action#result result} : interrogate for custom postprocessing
+ *
{@link Ext.form.action.Action#type type}
+ *
+ *
+ *
scope : Object
The scope in which to call the
+ * callback functions (The this reference for the callback functions).
+ *
+ *
clientValidation : Boolean
Submit Action only.
+ * Determines whether a Form's fields are validated in a final call to
+ * {@link Ext.form.Basic#isValid isValid} prior to submission. Set to false
+ * to prevent this. If undefined, pre-submission field validation is performed.
+ *
+ * @return {Ext.form.Basic} this
+ */
+ doAction: function(action, options) {
+ if (Ext.isString(action)) {
+ action = Ext.ClassManager.instantiateByAlias('formaction.' + action, Ext.apply({}, options, {form: this}));
}
- if(this.menu && this.destroyMenu !== false) {
- Ext.destroy(this.btnEl, this.menu);
+ if (this.fireEvent('beforeaction', this, action) !== false) {
+ this.beforeAction(action);
+ Ext.defer(action.run, 100, action);
}
- Ext.destroy(this.repeater);
+ return this;
},
- // 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);
+ /**
+ * Shortcut to {@link #doAction do} a {@link Ext.form.action.Submit submit action}. This will use the
+ * {@link Ext.form.action.Submit AJAX submit action} by default. If the {@link #standardsubmit} config is
+ * enabled it will use a standard form element to submit, or if the {@link #api} config is present it will
+ * use the {@link Ext.form.action.DirectLoad Ext.direct.Direct submit action}.
+ * @param {Object} options The options to pass to the action (see {@link #doAction} for details).
+ *
+ * @return {Ext.form.Basic} this
+ */
+ setValues: function(values) {
+ var me = this;
- // 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;
+ function setVal(fieldId, val) {
+ var field = me.findField(fieldId);
+ if (field) {
+ field.setValue(val);
+ if (me.trackResetOnLoad) {
+ field.resetOriginalValue();
}
- 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);
+ if (Ext.isArray(values)) {
+ // array of objects
+ Ext.each(values, function(val) {
+ setVal(val.id, val.value);
+ });
+ } else {
+ // object hash
+ Ext.iterate(values, setVal);
}
+ return this;
},
- 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');
- },
+ /**
+ * Retrieves the fields in the form as a set of key/value pairs, using their
+ * {@link Ext.form.field.Field#getSubmitData getSubmitData()} method to collect the values.
+ * If multiple fields return values under the same name those values will be combined into an Array.
+ * This is similar to {@link #getFieldValues} except that this method collects only String values for
+ * submission, while getFieldValues collects type-specific data values (e.g. Date objects for date fields.)
+ * @param {Boolean} asString (optional) If true, will return the key/value collection as a single
+ * URL-encoded param string. Defaults to false.
+ * @param {Boolean} dirtyOnly (optional) If true, only fields that are dirty will be included in the result.
+ * Defaults to false.
+ * @param {Boolean} includeEmptyText (optional) If true, the configured emptyText of empty fields will be used.
+ * Defaults to false.
+ * @return {String/Object}
+ */
+ getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+ var values = {};
- // private
- getClickEl : function(e, isUp){
- return this.el;
- },
+ this.getFields().each(function(field) {
+ if (!dirtyOnly || field.isDirty()) {
+ var data = field[useDataValues ? 'getModelData' : 'getSubmitData'](includeEmptyText);
+ if (Ext.isObject(data)) {
+ Ext.iterate(data, function(name, val) {
+ if (includeEmptyText && val === '') {
+ val = field.emptyText || '';
+ }
+ if (name in values) {
+ var bucket = values[name],
+ isArray = Ext.isArray;
+ if (!isArray(bucket)) {
+ bucket = values[name] = [bucket];
+ }
+ if (isArray(val)) {
+ values[name] = bucket.concat(val);
+ } else {
+ bucket.push(val);
+ }
+ } else {
+ values[name] = val;
+ }
+ });
+ }
+ }
+ });
- // 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;
+ if (asString) {
+ values = Ext.Object.toQueryString(values);
}
+ return values;
},
- // private
- restoreClick : function(){
- this.ignoreNextClick = 0;
- }
-
/**
- * @cfg {String} autoEl @hide
+ * Retrieves the fields in the form as a set of key/value pairs, using their
+ * {@link Ext.form.field.Field#getModelData getModelData()} method to collect the values.
+ * If multiple fields return values under the same name those values will be combined into an Array.
+ * This is similar to {@link #getValues} except that this method collects type-specific data values
+ * (e.g. Date objects for date fields) while getValues returns only String values for submission.
+ * @param {Boolean} dirtyOnly (optional) If true, only fields that are dirty will be included in the result.
+ * Defaults to false.
+ * @return {Object}
*/
+ getFieldValues: function(dirtyOnly) {
+ return this.getValues(false, dirtyOnly, false, true);
+ },
+
/**
- * @cfg {String/Object} html @hide
+ * Clears all invalid field messages in this form.
+ * @return {Ext.form.Basic} this
*/
+ clearInvalid: function() {
+ var me = this;
+ me.batchLayouts(function() {
+ me.getFields().each(function(f) {
+ f.clearInvalid();
+ });
+ });
+ return me;
+ },
+
/**
- * @cfg {String} contentEl @hide
+ * Resets all fields in this form.
+ * @return {Ext.form.Basic} this
*/
+ reset: function() {
+ var me = this;
+ me.batchLayouts(function() {
+ me.getFields().each(function(f) {
+ f.reset();
+ });
+ });
+ return me;
+ },
+
/**
- * @cfg {Mixed} data @hide
+ * Calls {@link Ext#apply Ext.apply} for all fields in this form with the passed object.
+ * @param {Object} obj The object to be applied
+ * @return {Ext.form.Basic} this
*/
+ applyToFields: function(obj) {
+ this.getFields().each(function(f) {
+ Ext.apply(f, obj);
+ });
+ return this;
+ },
+
/**
- * @cfg {Mixed} tpl @hide
+ * Calls {@link Ext#applyIf Ext.applyIf} for all field in this form with the passed object.
+ * @param {Object} obj The object to be applied
+ * @return {Ext.form.Basic} this
*/
+ applyIfToFields: function(obj) {
+ this.getFields().each(function(f) {
+ Ext.applyIf(f, obj);
+ });
+ return this;
+ },
+
/**
- * @cfg {String} tplWriteMode @hide
+ * @private
+ * Utility wrapper that suspends layouts of all field parent containers for the duration of a given
+ * function. Used during full-form validation and resets to prevent huge numbers of layouts.
+ * @param {Function} fn
*/
-});
-Ext.reg('button', Ext.Button);
+ batchLayouts: function(fn) {
+ var me = this,
+ suspended = new Ext.util.HashMap();
-// Private utility class used by Button
-Ext.ButtonToggleMgr = function(){
- var groups = {};
+ // Temporarily suspend layout on each field's immediate owner so we don't get a huge layout cascade
+ me.getFields().each(function(field) {
+ var ownerCt = field.ownerCt;
+ if (!suspended.contains(ownerCt)) {
+ suspended.add(ownerCt);
+ ownerCt.oldSuspendLayout = ownerCt.suspendLayout;
+ ownerCt.suspendLayout = true;
+ }
+ });
- 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);
- }
- }
- }
- }
+ // Invoke the function
+ fn();
- 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);
- },
+ // Un-suspend the container layouts
+ suspended.each(function(id, ct) {
+ ct.suspendLayout = ct.oldSuspendLayout;
+ delete ct.oldSuspendLayout;
+ });
- unregister : function(btn){
- if(!btn.toggleGroup){
- return;
- }
- var g = groups[btn.toggleGroup];
- if(g){
- g.remove(btn);
- btn.un('toggle', toggleGroup);
- }
- },
+ // Trigger a single layout
+ me.owner.doComponentLayout();
+ }
+});
- /**
- * 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}
- ]
- })
-});
+ * @class Ext.form.FieldAncestor
-// 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,
+A mixin for {@link Ext.container.Container} components that are likely to have form fields in their
+items subtree. Adds the following capabilities:
- // 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");
- },
+- Methods for handling the addition and removal of {@link Ext.form.Labelable} and {@link Ext.form.field.Field}
+ instances at any depth within the container.
+- Events ({@link #fieldvaliditychange} and {@link #fielderrorchange}) for handling changes to the state
+ of individual fields at the container level.
+- Automatic application of {@link #fieldDefaults} config properties to each field added within the
+ container, to facilitate uniform configuration of all fields.
- // private
- onRender : function(){
- Ext.SplitButton.superclass.onRender.apply(this, arguments);
- if(this.arrowTooltip){
- this.el.child(this.arrowSelector).dom[this.tooltipType] = this.arrowTooltip;
- }
+This mixin is primarily for internal use by {@link Ext.form.Panel} and {@link Ext.form.FieldContainer},
+and should not normally need to be used directly.
+
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.FieldAncestor', {
+
+ /**
+ * @cfg {Object} fieldDefaults
+ *
If specified, the properties in this object are used as default config values for each
+ * {@link Ext.form.Labelable} instance (e.g. {@link Ext.form.field.Base} or {@link Ext.form.FieldContainer})
+ * that is added as a descendant of this container. Corresponding values specified in an individual field's
+ * own configuration, or from the {@link Ext.container.Container#defaults defaults config} of its parent container,
+ * will take precedence. See the documentation for {@link Ext.form.Labelable} to see what config
+ * options may be specified in the fieldDefaults.
In this example, field1 and field2 will get labelAlign:'top' (from the fieldset's defaults)
+ * and labelWidth:100 (from fieldDefaults), field3 and field4 will both get labelAlign:'left' (from
+ * fieldDefaults and field3 will use the labelWidth:150 from its own config.
+ */
+
/**
- * 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
+ * @protected Initializes the FieldAncestor's state; this must be called from the initComponent method
+ * of any components importing this mixin.
*/
- setArrowHandler : function(handler, scope){
- this.arrowHandler = handler;
- this.scope = scope;
- },
+ initFieldAncestor: function() {
+ var me = this,
+ onSubtreeChange = me.onFieldAncestorSubtreeChange;
+
+ me.addEvents(
+ /**
+ * @event fielderrorchange
+ * Fires when the validity state of any one of the {@link Ext.form.field.Field} instances within this
+ * container changes.
+ * @param {Ext.form.FieldAncestor} this
+ * @param {Ext.form.Labelable} The Field instance whose validity changed
+ * @param {String} isValid The field's new validity state
+ */
+ 'fieldvaliditychange',
+
+ /**
+ * @event fielderrorchange
+ * Fires when the active error message is changed for any one of the {@link Ext.form.Labelable}
+ * instances within this container.
+ * @param {Ext.form.FieldAncestor} this
+ * @param {Ext.form.Labelable} The Labelable instance whose active error was changed
+ * @param {String} error The active error message
+ */
+ 'fielderrorchange'
+ );
+
+ // Catch addition and removal of descendant fields
+ me.on('add', onSubtreeChange, me);
+ me.on('remove', onSubtreeChange, me);
- getMenuClass : function(){
- return 'x-btn-split' + (this.arrowAlign == 'bottom' ? '-bottom' : '');
+ me.initFieldDefaults();
},
- 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 Initialize the {@link #fieldDefaults} object
+ */
+ initFieldDefaults: function() {
+ if (!this.fieldDefaults) {
+ this.fieldDefaults = {};
+ }
},
- // 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);
+ /**
+ * @private
+ * Handle the addition and removal of components in the FieldAncestor component's child tree.
+ */
+ onFieldAncestorSubtreeChange: function(parent, child) {
+ var me = this,
+ isAdding = !!child.ownerCt;
+
+ function handleCmp(cmp) {
+ var isLabelable = cmp.isFieldLabelable,
+ isField = cmp.isFormField;
+ if (isLabelable || isField) {
+ if (isLabelable) {
+ me['onLabelable' + (isAdding ? 'Added' : 'Removed')](cmp);
}
- }else{
- this.doToggle();
- this.fireEvent("click", this, e);
- if(this.handler){
- this.handler.call(this.scope || this, this, e);
+ if (isField) {
+ me['onField' + (isAdding ? 'Added' : 'Removed')](cmp);
}
}
+ else if (cmp.isContainer) {
+ Ext.Array.forEach(cmp.getRefItems(), handleCmp);
+ }
}
+ handleCmp(child);
},
- // private
- isMenuTriggerOver : function(e){
- return this.menu && e.target.tagName == this.arrowSelector;
- },
+ /**
+ * @protected Called when a {@link Ext.form.Labelable} instance is added to the container's subtree.
+ * @param {Ext.form.Labelable} labelable The instance that was added
+ */
+ onLabelableAdded: function(labelable) {
+ var me = this;
- // private
- isMenuTriggerOut : function(e, internal){
- return this.menu && e.target.tagName != this.arrowSelector;
- }
-});
+ // buffer slightly to avoid excessive firing while sub-fields are changing en masse
+ me.mon(labelable, 'errorchange', me.handleFieldErrorChange, me, {buffer: 10});
+
+ labelable.setFieldDefaults(me.fieldDefaults);
+ },
-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:
- *
- * @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'})
+ * @protected Called when a {@link Ext.form.field.Field} instance is added to the container's subtree.
+ * @param {Ext.form.field.Field} field The field which was added
*/
+ onFieldAdded: function(field) {
+ var me = this;
+ me.mon(field, 'validitychange', me.handleFieldValidityChange, me);
+ },
+
/**
- * @cfg {Boolean} showText True to display the active item's text as the button text (defaults to false)
+ * @protected Called when a {@link Ext.form.Labelable} instance is removed from the container's subtree.
+ * @param {Ext.form.Labelable} labelable The instance that was removed
*/
+ onLabelableRemoved: function(labelable) {
+ var me = this;
+ me.mun(labelable, 'errorchange', me.handleFieldErrorChange, me);
+ },
+
/**
- * @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 '')
+ * @protected Called when a {@link Ext.form.field.Field} instance is removed from the container's subtree.
+ * @param {Ext.form.field.Field} field The field which was removed
*/
+ onFieldRemoved: function(field) {
+ var me = this;
+ me.mun(field, 'validitychange', me.handleFieldValidityChange, me);
+ },
+
/**
- * @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)
+ * @private Handle validitychange events on sub-fields; invoke the aggregated event and method
*/
+ handleFieldValidityChange: function(field, isValid) {
+ var me = this;
+ me.fireEvent('fieldvaliditychange', me, field, isValid);
+ me.onFieldValidityChange();
+ },
+
/**
- * @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.
+ * @private Handle errorchange events on sub-fields; invoke the aggregated event and method
*/
+ handleFieldErrorChange: function(labelable, activeError) {
+ var me = this;
+ me.fireEvent('fielderrorchange', me, labelable, activeError);
+ me.onFieldErrorChange();
+ },
+
/**
- * @property menu
- * @type Menu
- * The {@link Ext.menu.Menu Menu} object used to display the {@link Ext.menu.CheckItem CheckItems} representing the available choices.
+ * @protected Fired when the validity of any field within the container changes.
+ * @param {Ext.form.field.Field} The sub-field whose validity changed
+ * @param {String} The new validity state
*/
-
- // private
- getItemText : function(item){
- if(item && this.showText === true){
- var text = '';
- if(this.prependText){
- text += this.prependText;
- }
- text += item.text;
- return text;
- }
- return undefined;
- },
+ onFieldValidityChange: Ext.emptyFn,
/**
- * 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)
+ * @protected Fired when the error message of any field within the container changes.
+ * @param {Ext.form.Labelable} The sub-field whose active error changed
+ * @param {String} The new active error message
*/
- setActiveItem : function(item, suppressEvent){
- if(!Ext.isObject(item)){
- item = this.menu.getComponent(item);
+ onFieldErrorChange: Ext.emptyFn
+
+});
+/**
+ * @class Ext.layout.container.CheckboxGroup
+ * @extends Ext.layout.container.Container
+ *
This layout implements the column arrangement for {@link Ext.form.CheckboxGroup} and {@link Ext.form.RadioGroup}.
+ * It groups the component's sub-items into columns based on the component's
+ * {@link Ext.form.CheckboxGroup#columns columns} and {@link Ext.form.CheckboxGroup#vertical} config properties.
+ *
+ */
+Ext.define('Ext.layout.container.CheckboxGroup', {
+ extend: 'Ext.layout.container.Container',
+ alias: ['layout.checkboxgroup'],
+
+
+ onLayout: function() {
+ var numCols = this.getColCount(),
+ shadowCt = this.getShadowCt(),
+ owner = this.owner,
+ items = owner.items,
+ shadowItems = shadowCt.items,
+ numItems = items.length,
+ colIndex = 0,
+ i, numRows;
+
+ // Distribute the items into the appropriate column containers. We add directly to the
+ // containers' items collection rather than calling container.add(), because we need the
+ // checkboxes to maintain their original ownerCt. The distribution is done on each layout
+ // in case items have been added, removed, or reordered.
+
+ shadowItems.each(function(col) {
+ col.items.clear();
+ });
+
+ // If columns="auto", then the number of required columns may change as checkboxes are added/removed
+ // from the CheckboxGroup; adjust to match.
+ while (shadowItems.length > numCols) {
+ shadowCt.remove(shadowItems.last());
}
- 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);
+ while (shadowItems.length < numCols) {
+ shadowCt.add({
+ xtype: 'container',
+ cls: owner.groupCls,
+ flex: 1
+ });
+ }
+
+ if (owner.vertical) {
+ numRows = Math.ceil(numItems / numCols);
+ for (i = 0; i < numItems; i++) {
+ if (i > 0 && i % numRows === 0) {
+ colIndex++;
}
- this.setIconClass(item.iconCls);
+ shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
- this.activeItem = item;
- if(!item.checked){
- item.setChecked(true, false);
- }
- if(this.forceIcon){
- this.setIconClass(this.forceIcon);
- }
- if(!suppressEvent){
- this.fireEvent('change', this, item);
+ } else {
+ for (i = 0; i < numItems; i++) {
+ colIndex = i % numCols;
+ shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
}
- },
- /**
- * Gets the currently active menu item.
- * @return {Ext.menu.CheckItem} The active item
- */
- getActiveItem : function(){
- return this.activeItem;
+ if (!shadowCt.rendered) {
+ shadowCt.render(this.getRenderTarget());
+ } else {
+ // Ensure all items are rendered in the correct place in the correct column - this won't
+ // get done by the column containers themselves if their dimensions are not changing.
+ shadowItems.each(function(col) {
+ var layout = col.getLayout();
+ layout.renderItems(layout.getLayoutItems(), layout.getRenderTarget());
+ });
+ }
+
+ shadowCt.doComponentLayout();
},
- // 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;
- }
+ // We don't want to render any items to the owner directly, that gets handled by each column's own layout
+ renderItems: Ext.emptyFn,
- 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;
+ /**
+ * @private
+ * Creates and returns the shadow hbox container that will be used to arrange the owner's items
+ * into columns.
+ */
+ getShadowCt: function() {
+ var me = this,
+ shadowCt = me.shadowCt,
+ owner, items, item, columns, columnsIsArray, numCols, i;
+
+ if (!shadowCt) {
+ // Create the column containers based on the owner's 'columns' config
+ owner = me.owner;
+ columns = owner.columns;
+ columnsIsArray = Ext.isArray(columns);
+ numCols = me.getColCount();
+ items = [];
+ for(i = 0; i < numCols; i++) {
+ item = {
+ xtype: 'container',
+ cls: owner.groupCls
+ };
+ if (columnsIsArray) {
+ // Array can contain mixture of whole numbers, used as fixed pixel widths, and fractional
+ // numbers, used as relative flex values.
+ if (columns[i] < 1) {
+ item.flex = columns[i];
+ } else {
+ item.width = columns[i];
+ }
+ }
+ else {
+ // All columns the same width
+ item.flex = 1;
+ }
+ items.push(item);
}
- }, 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);
+ // Create the shadow container; delay rendering until after items are added to the columns
+ shadowCt = me.shadowCt = Ext.createWidget('container', {
+ layout: 'hbox',
+ items: items,
+ ownerCt: owner
+ });
}
+
+ return shadowCt;
},
+
/**
- * 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.
+ * @private Get the number of columns in the checkbox group
*/
- 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;
- }
- }
+ getColCount: function() {
+ var owner = this.owner,
+ colsCfg = owner.columns;
+ return Ext.isArray(colsCfg) ? colsCfg.length : (Ext.isNumber(colsCfg) ? colsCfg : owner.items.length);
}
-});
-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:
- *
-ShortcutxtypeClassDescription
-'->' '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
+/**
+ * @class Ext.form.FieldContainer
+ * @extends Ext.container.Container
+
+FieldContainer is a derivation of {@link Ext.container.Container Container} that implements the
+{@link Ext.form.Labelable Labelable} mixin. This allows it to be configured so that it is rendered with
+a {@link #fieldLabel field label} and optional {@link #msgTarget error message} around its sub-items.
+This is useful for arranging a group of fields or other components within a single item in a form, so
+that it lines up nicely with other fields. A common use is for grouping a set of related fields under
+a single label in a form.
+
+The container's configured {@link #items} will be layed out within the field body area according to the
+configured {@link #layout} type. The default layout is `'autocontainer'`.
+
+Like regular fields, FieldContainer can inherit its decoration configuration from the
+{@link Ext.form.Panel#fieldDefaults fieldDefaults} of an enclosing FormPanel. In addition,
+FieldContainer itself can pass {@link #fieldDefaults} to any {@link Ext.form.Labelable fields}
+it may itself contain.
+
+If you are grouping a set of {@link Ext.form.field.Checkbox Checkbox} or {@link Ext.form.field.Radio Radio}
+fields in a single labeled container, consider using a {@link Ext.form.CheckboxGroup}
+or {@link Ext.form.RadioGroup} instead as they are specialized for handling those types.
+{@img Ext.form.FieldContainer/Ext.form.FieldContainer1.png Ext.form.FieldContainer component}
+__Example usage:__
+
+ Ext.create('Ext.form.Panel', {
+ title: 'FieldContainer Example',
+ width: 550,
+ bodyPadding: 10,
+
+ items: [{
+ xtype: 'fieldcontainer',
+ fieldLabel: 'Last Three Jobs',
+ labelWidth: 100,
+
+ // The body area will contain three text fields, arranged
+ // horizontally, separated by draggable splitters.
+ layout: 'hbox',
+ items: [{
+ xtype: 'textfield',
+ flex: 1
+ }, {
+ xtype: 'splitter'
+ }, {
+ xtype: 'textfield',
+ flex: 1
+ }, {
+ xtype: 'splitter'
+ }, {
+ xtype: 'textfield',
+ flex: 1
+ }]
+ }],
+ renderTo: Ext.getBody()
});
-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(){
+__Usage of {@link #fieldDefaults}:__
+{@img Ext.form.FieldContainer/Ext.form.FieldContainer2.png Ext.form.FieldContainer component}
-var T = Ext.Toolbar;
+ Ext.create('Ext.form.Panel', {
+ title: 'FieldContainer Example',
+ width: 350,
+ bodyPadding: 10,
+
+ items: [{
+ xtype: 'fieldcontainer',
+ fieldLabel: 'Your Name',
+ labelWidth: 75,
+ defaultType: 'textfield',
+
+ // Arrange fields vertically, stretched to full width
+ layout: 'anchor',
+ defaults: {
+ layout: '100%'
+ },
+
+ // These config values will be applied to both sub-fields, except
+ // for Last Name which will use its own msgTarget.
+ fieldDefaults: {
+ msgTarget: 'under',
+ labelAlign: 'top'
+ },
+
+ items: [{
+ fieldLabel: 'First Name',
+ name: 'firstName'
+ }, {
+ fieldLabel: 'Last Name',
+ name: 'lastName',
+ msgTarget: 'under'
+ }]
+ }],
+ renderTo: Ext.getBody()
+ });
-Ext.extend(T, Ext.Container, {
- defaultType: 'button',
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.FieldContainer', {
+ extend: 'Ext.container.Container',
+ mixins: {
+ labelable: 'Ext.form.Labelable',
+ fieldAncestor: 'Ext.form.FieldAncestor'
+ },
+ alias: 'widget.fieldcontainer',
+
+ componentLayout: 'field',
/**
- * @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.
+ * @cfg {Boolean} combineLabels
+ * If set to true, and there is no defined {@link #fieldLabel}, the field container will automatically
+ * generate its label by combining the labels of all the fields it contains. Defaults to false.
+ */
+ combineLabels: false,
+
+ /**
+ * @cfg {String} labelConnector
+ * The string to use when joining the labels of individual sub-fields, when {@link #combineLabels} is
+ * set to true. Defaults to ', '.
+ */
+ labelConnector: ', ',
+
+ /**
+ * @cfg {Boolean} combineErrors
+ * If set to true, the field container will automatically combine and display the validation errors from
+ * all the fields it contains as a single error on the container, according to the configured
+ * {@link #msgTarget}. Defaults to false.
*/
+ combineErrors: false,
+
+ maskOnDisable: false,
+
+ initComponent: function() {
+ var me = this,
+ onSubCmpAddOrRemove = me.onSubCmpAddOrRemove;
+
+ // Init mixins
+ me.initLabelable();
+ me.initFieldAncestor();
- enableOverflow : false,
+ me.callParent();
+ },
/**
- * @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.
+ * @protected Called when a {@link Ext.form.Labelable} instance is added to the container's subtree.
+ * @param {Ext.form.Labelable} labelable The instance that was added
*/
+ onLabelableAdded: function(labelable) {
+ var me = this;
+ me.mixins.fieldAncestor.onLabelableAdded.call(this, labelable);
+ me.updateLabel();
+ },
+
/**
- * @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.
+ * @protected Called when a {@link Ext.form.Labelable} instance is removed from the container's subtree.
+ * @param {Ext.form.Labelable} labelable The instance that was removed
*/
+ onLabelableRemoved: function(labelable) {
+ var me = this;
+ me.mixins.fieldAncestor.onLabelableRemoved.call(this, labelable);
+ me.updateLabel();
+ },
- trackMenus : true,
- internalDefaults: {removeMode: 'container', hideParent: true},
- toolbarCls: 'x-toolbar',
+ onRender: function() {
+ var me = this,
+ renderSelectors = me.renderSelectors,
+ applyIf = Ext.applyIf;
- initComponent : function(){
- T.superclass.initComponent.call(this);
+ applyIf(renderSelectors, me.getLabelableSelectors());
- /**
- * @event overflowchange
- * Fires after the overflow state has changed.
- * @param {Object} c The Container
- * @param {Boolean} lastOverflow overflow state
- */
- this.addEvents('overflowchange');
+ me.callParent(arguments);
},
- // 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);
+ initRenderTpl: function() {
+ var me = this;
+ if (!me.hasOwnProperty('renderTpl')) {
+ me.renderTpl = me.getTpl('labelableRenderTpl');
}
+ return me.callParent();
+ },
+
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
},
/**
- *
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
+ * Returns the combined field label if {@link #combineLabels} is set to true and if there is no
+ * set {@link #fieldLabel}. Otherwise returns the fieldLabel like normal. You can also override
+ * this method to provide a custom generated label.
*/
+ getFieldLabel: function() {
+ var label = this.fieldLabel || '';
+ if (!label && this.combineLabels) {
+ label = Ext.Array.map(this.query('[isFieldLabelable]'), function(field) {
+ return field.getFieldLabel();
+ }).join(this.labelConnector);
+ }
+ return label;
+ },
- // 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);
- }
+ /**
+ * @private Updates the content of the labelEl if it is rendered
+ */
+ updateLabel: function() {
+ var me = this,
+ label = me.labelEl;
+ if (label) {
+ label.update(me.getFieldLabel());
}
- return c;
},
- // 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);
+
+ /**
+ * @private Fired when the error message of any field within the container changes, and updates the
+ * combined error message to match.
+ */
+ onFieldErrorChange: function(field, activeError) {
+ if (this.combineErrors) {
+ var me = this,
+ oldError = me.getActiveError(),
+ invalidFields = Ext.Array.filter(me.query('[isFormField]'), function(field) {
+ return field.hasActiveError();
+ }),
+ newErrors = me.getCombinedErrors(invalidFields);
+
+ if (newErrors) {
+ me.setActiveErrors(newErrors);
+ } else {
+ me.unsetActiveError();
+ }
+
+ if (oldError !== me.getActiveError()) {
+ me.doComponentLayout();
}
}
- 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}
+ * Takes an Array of invalid {@link Ext.form.field.Field} objects and builds a combined list of error
+ * messages from them. Defaults to prepending each message by the field name and a colon. This
+ * can be overridden to provide custom combined error message handling, for instance changing
+ * the format of each message or sorting the array (it is sorted in order of appearance by default).
+ * @param {Array} invalidFields An Array of the sub-fields which are currently invalid.
+ * @return {Array} The combined list of error messages
*/
- addSeparator : function(){
- return this.add(new T.Separator());
+ getCombinedErrors: function(invalidFields) {
+ var forEach = Ext.Array.forEach,
+ errors = [];
+ forEach(invalidFields, function(field) {
+ forEach(field.getActiveErrors(), function(error) {
+ var label = field.getFieldLabel();
+ errors.push((label ? label + ': ' : '') + error);
+ });
+ });
+ return errors;
+ },
+
+ getTargetEl: function() {
+ return this.bodyEl || this.callParent();
+ }
+});
+
+/**
+ * A {@link Ext.form.FieldContainer field container} which has a specialized layout for arranging
+ * {@link Ext.form.field.Checkbox} controls into columns, and provides convenience {@link Ext.form.field.Field} methods
+ * for {@link #getValue getting}, {@link #setValue setting}, and {@link #validate validating} the group
+ * of checkboxes as a whole.
+ *
+ * # Validation
+ *
+ * Individual checkbox fields themselves have no default validation behavior, but
+ * sometimes you want to require a user to select at least one of a group of checkboxes. CheckboxGroup
+ * allows this by setting the config `{@link #allowBlank}:false`; when the user does not check at
+ * least one of the checkboxes, the entire group will be highlighted as invalid and the
+ * {@link #blankText error message} will be displayed according to the {@link #msgTarget} config.
+ *
+ * # Layout
+ *
+ * The default layout for CheckboxGroup makes it easy to arrange the checkboxes into
+ * columns; see the {@link #columns} and {@link #vertical} config documentation for details. You may also
+ * use a completely different layout by setting the {@link #layout} to one of the other supported layout
+ * types; for instance you may wish to use a custom arrangement of hbox and vbox containers. In that case
+ * the checkbox components at any depth will still be managed by the CheckboxGroup's validation.
+ *
+ * {@img Ext.form.CheckboxGroup/Ext.form.CheckboxGroup.png Ext.form.CheckboxGroup component}
+ *
+ * # Example usage
+ *
+ * Ext.create('Ext.form.Panel', {
+ * title: 'Checkbox Group',
+ * width: 300,
+ * height: 125,
+ * bodyPadding: 10,
+ * renderTo: Ext.getBody(),
+ * items:[{
+ * xtype: 'checkboxgroup',
+ * fieldLabel: 'Two Columns',
+ * // Arrange radio buttons into two columns, distributed vertically
+ * columns: 2,
+ * vertical: true,
+ * items: [
+ * {boxLabel: 'Item 1', name: 'rb', inputValue: '1'},
+ * {boxLabel: 'Item 2', name: 'rb', inputValue: '2', checked: true},
+ * {boxLabel: 'Item 3', name: 'rb', inputValue: '3'},
+ * {boxLabel: 'Item 4', name: 'rb', inputValue: '4'},
+ * {boxLabel: 'Item 5', name: 'rb', inputValue: '5'},
+ * {boxLabel: 'Item 6', name: 'rb', inputValue: '6'}
+ * ]
+ * }]
+ * });
+ *
+ */
+Ext.define('Ext.form.CheckboxGroup', {
+ extend:'Ext.form.FieldContainer',
+ mixins: {
+ field: 'Ext.form.field.Field'
},
+ alias: 'widget.checkboxgroup',
+ requires: ['Ext.layout.container.CheckboxGroup', 'Ext.form.field.Base'],
/**
- * Adds a spacer element
- *
Note: See the notes within {@link Ext.Container#add}.
- * @return {Ext.Toolbar.Spacer} The spacer item
+ * @cfg {String} name
+ * @hide
*/
- 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}.
+ * @cfg {Array} items An Array of {@link Ext.form.field.Checkbox Checkbox}es or Checkbox config objects
+ * to arrange in the group.
*/
- 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
+ * @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 :
You 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.
Note: See the notes within {@link Ext.Container#add}.
- * @param {Ext.Toolbar.Item} item
- * @return {Ext.Toolbar.Item} The item
+ * @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.
*/
- addItem : function(item){
- return this.add.apply(this, arguments);
- },
+ vertical : false,
/**
- * 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}
+ * @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.
*/
- 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));
- },
+ allowBlank : 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
+ * @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")
*/
- addText : function(text){
- return this.addItem(new T.TextItem(text));
- },
+ blankText : "You must select at least one item in this group",
+
+ // private
+ defaultType : 'checkboxfield',
+
+ // private
+ groupCls : Ext.baseCSSPrefix + 'form-check-group',
/**
- * 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
+ * @cfg {String} fieldBodyCls
+ * An extra CSS class to be applied to the body content element in addition to {@link #baseBodyCls}.
+ * Defaults to 'x-form-checkboxgroup-body'.
*/
- addDom : function(config){
- return this.add(new T.Item({autoEl: config}));
+ fieldBodyCls: Ext.baseCSSPrefix + 'form-checkboxgroup-body',
+
+ // private
+ layout: 'checkboxgroup',
+
+ initComponent: function() {
+ var me = this;
+ me.callParent();
+ me.initField();
},
/**
- * 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}
+ * @protected
+ * Initializes the field's value based on the initial config. If the {@link #value} config is specified
+ * then we use that to set the value; otherwise we initialize the originalValue by querying the values of
+ * all sub-checkboxes after they have been initialized.
*/
- addField : function(field){
- return this.add(field);
+ initValue: function() {
+ var me = this,
+ valueCfg = me.value;
+ me.originalValue = me.lastValue = valueCfg || me.getValue();
+ if (valueCfg) {
+ me.setValue(valueCfg);
+ }
},
/**
- * 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}
+ * @protected
+ * When a checkbox is added to the group, monitor it for changes
*/
- 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;
+ onFieldAdded: function(field) {
+ var me = this;
+ if (field.isCheckbox) {
+ me.mon(field, 'change', me.checkChange, me);
}
- return Ext.Toolbar.superclass.insert.call(this, index, item);
+ me.callParent(arguments);
},
- // 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);
+ onFieldRemoved: function(field) {
+ var me = this;
+ if (field.isCheckbox) {
+ me.mun(field, 'change', me.checkChange, me);
}
+ me.callParent(arguments);
},
- // private
- constructButton : function(item){
- var b = item.events ? item : this.createComponent(item, item.split ? 'splitbutton' : this.defaultType);
- return b;
+ // private override - the group value is a complex object, compare using object serialization
+ isEqual: function(value1, value2) {
+ var toQueryString = Ext.Object.toQueryString;
+ return toQueryString(value1) === toQueryString(value2);
},
- // private
- onAdd : function(c){
- Ext.Toolbar.superclass.onAdd.call(this);
- this.trackMenu(c);
- if(this.disabled){
- c.disable();
+ /**
+ * 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
+ */
+ getErrors: function() {
+ var errors = [];
+ if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
+ errors.push(this.blankText);
}
+ return errors;
},
- // private
- onRemove : function(c){
- Ext.Toolbar.superclass.onRemove.call(this);
- if (c == this.activeMenuBtn) {
- delete this.activeMenuBtn;
- }
- this.trackMenu(c, true);
+ /**
+ * @private Returns all checkbox components within the container
+ */
+ getBoxes: function() {
+ return this.query('[isCheckbox]');
},
- // private
- onDisable : function(){
- this.items.each(function(item){
- if(item.disable){
- item.disable();
- }
+ /**
+ * @private Convenience function which calls the given function for every checkbox in the group
+ * @param {Function} fn The function to call
+ * @param {Object} scope Optional scope object
+ */
+ eachBox: function(fn, scope) {
+ Ext.Array.forEach(this.getBoxes(), fn, scope || this);
+ },
+
+ /**
+ * Returns an Array of all checkboxes in the container which are currently checked
+ * @return {Array} Array of Ext.form.field.Checkbox components
+ */
+ getChecked: function() {
+ return Ext.Array.filter(this.getBoxes(), function(cb) {
+ return cb.getValue();
});
},
- // private
- onEnable : function(){
- this.items.each(function(item){
- if(item.enable){
- item.enable();
- }
+ // private override
+ isDirty: function(){
+ return Ext.Array.some(this.getBoxes(), function(cb) {
+ return cb.isDirty();
});
},
- // private
- onButtonTriggerOver : function(btn){
- if(this.activeMenuBtn && this.activeMenuBtn != btn){
- this.activeMenuBtn.hideMenu();
- btn.showMenu();
- this.activeMenuBtn = btn;
+ // private override
+ setReadOnly: function(readOnly) {
+ this.eachBox(function(cb) {
+ cb.setReadOnly(readOnly);
+ });
+ this.readOnly = readOnly;
+ },
+
+ /**
+ * Resets the checked state of all {@link Ext.form.field.Checkbox checkboxes} in the group to their
+ * originally loaded values and clears any validation messages.
+ * See {@link Ext.form.Basic}.{@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}
+ */
+ reset: function() {
+ var me = this,
+ hadError = me.hasActiveError(),
+ preventMark = me.preventMark;
+ me.preventMark = true;
+ me.batchChanges(function() {
+ me.eachBox(function(cb) {
+ cb.reset();
+ });
+ });
+ me.preventMark = preventMark;
+ me.unsetActiveError();
+ if (hadError) {
+ me.doComponentLayout();
}
},
- // private
- onButtonMenuShow : function(btn){
- this.activeMenuBtn = btn;
+ // private override
+ resetOriginalValue: function() {
+ // Defer resetting of originalValue until after all sub-checkboxes have been reset so we get
+ // the correct data from getValue()
+ Ext.defer(function() {
+ this.callParent();
+ }, 1, this);
},
- // 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
/**
- * @cfg {String} overflowText Text to be used for the menu if the item is overflowed.
- */
-});
-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:
- *
Sets the value(s) of all checkboxes in the group. The expected format is an Object of
+ * name-value pairs corresponding to the names of the checkboxes in the group. Each pair can
+ * have either a single or multiple values:
+ *
+ *
A single Boolean or String value will be passed to the setValue method of the
+ * checkbox with that name. See the rules in {@link Ext.form.field.Checkbox#setValue} for accepted values.
+ *
An Array of String values will be matched against the {@link Ext.form.field.Checkbox#inputValue inputValue}
+ * of checkboxes in the group with that name; those checkboxes whose inputValue exists in the array will be
+ * checked and others will be unchecked.
+ *
+ *
If a checkbox's name is not in the mapping at all, it will be unchecked.
+ *
An example:
+ *
var myCheckboxGroup = new Ext.form.CheckboxGroup({
+ columns: 3,
+ items: [{
+ name: 'cb1',
+ boxLabel: 'Single 1'
+ }, {
+ name: 'cb2',
+ boxLabel: 'Single 2'
+ }, {
+ name: 'cb3',
+ boxLabel: 'Single 3'
+ }, {
+ name: 'cbGroup',
+ boxLabel: 'Grouped 1'
+ inputValue: 'value1'
+ }, {
+ name: 'cbGroup',
+ boxLabel: 'Grouped 2'
+ inputValue: 'value2'
+ }, {
+ name: 'cbGroup',
+ boxLabel: 'Grouped 3'
+ inputValue: 'value3'
+ }]
});
-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'
- ]
-});
-
- * @constructor
- * Creates a new Spacer
- * @xtype tbspacer
- */
-T.Spacer = Ext.extend(T.Item, {
- /**
- * @cfg {Number} width
- * The width of the spacer in pixels (defaults to 2px via css style .x-toolbar .xtb-spacer).
+myCheckboxGroup.setValue({
+ cb1: true,
+ cb3: false,
+ cbGroup: ['value1', 'value3']
+});
+ *
The above code will cause the checkbox named 'cb1' to be checked, as well as the first and third
+ * checkboxes named 'cbGroup'. The other three checkboxes will be unchecked.
+ * @param {Object} value The mapping of checkbox names to values.
+ * @return {Ext.form.CheckboxGroup} this
*/
+ setValue: function(value) {
+ var me = this;
+ me.batchChanges(function() {
+ me.eachBox(function(cb) {
+ var name = cb.getName(),
+ cbValue = false;
+ if (value && name in value) {
+ if (Ext.isArray(value[name])) {
+ cbValue = Ext.Array.contains(value[name], cb.inputValue);
+ } else {
+ // single value, let the checkbox's own setValue handle conversion
+ cbValue = value[name];
+ }
+ }
+ cb.setValue(cbValue);
+ });
+ });
+ return me;
+ },
- 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.
- *
- * @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, {
/**
- * @cfg {String} text The text to be used as innerHTML (html tags are accepted)
+ *
Returns an object containing the values of all checked checkboxes within the group. Each key-value pair
+ * in the object corresponds to a checkbox {@link Ext.form.field.Checkbox#name name}. If there is only one checked
+ * checkbox with a particular name, the value of that pair will be the String
+ * {@link Ext.form.field.Checkbox#inputValue inputValue} of that checkbox. If there are multiple checked checkboxes
+ * with that name, the value of that pair will be an Array of the selected inputValues.
+ *
The object format returned from this method can also be passed directly to the {@link #setValue} method.
+ *
NOTE: In Ext 3, this method returned an array of Checkbox components; this was changed to make it more
+ * consistent with other field components and with the {@link #setValue} argument signature. If you need the old
+ * behavior in Ext 4+, use the {@link #getChecked} method instead.
*/
-
- constructor: function(config){
- T.TextItem.superclass.constructor.call(this, Ext.isString(config) ? {text: config} : config);
+ getValue: function() {
+ var values = {};
+ this.eachBox(function(cb) {
+ var name = cb.getName(),
+ inputValue = cb.inputValue,
+ bucket;
+ if (cb.getValue()) {
+ if (name in values) {
+ bucket = values[name];
+ if (!Ext.isArray(bucket)) {
+ bucket = values[name] = [bucket];
+ }
+ bucket.push(inputValue);
+ } else {
+ values[name] = inputValue;
+ }
+ }
+ });
+ return values;
},
- // private
- onRender : function(ct, position) {
- this.autoEl = {cls: 'xtb-text', html: this.text || ''};
- T.TextItem.superclass.onRender.call(this, ct, position);
+ /*
+ * Don't return any data for submit; the form will get the info from the individual checkboxes themselves.
+ */
+ getSubmitData: function() {
+ return null;
},
- /**
- * Updates this item's text, setting the text to be used as innerHTML.
- * @param {String} t The text to display (html accepted).
+ /*
+ * Don't return any data for the model; the form will get the info from the individual checkboxes themselves.
*/
- setText : function(t) {
- if(this.rendered){
- this.el.update(t);
- }else{
- this.text = t;
+ getModelData: function() {
+ return null;
+ },
+
+ validate: function() {
+ var me = this,
+ errors = me.getErrors(),
+ isValid = Ext.isEmpty(errors),
+ wasValid = !me.hasActiveError();
+
+ if (isValid) {
+ me.unsetActiveError();
+ } else {
+ me.setActiveError(errors);
+ }
+ if (isValid !== wasValid) {
+ me.fireEvent('validitychange', me, isValid);
+ me.doComponentLayout();
}
+
+ return isValid;
}
+
+}, function() {
+
+ this.borrow(Ext.form.field.Base, ['markInvalid', 'clearInvalid']);
+
});
-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:
- *
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
-
-var myStore = new Ext.data.Store({
- 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'
- ]
- })
-});
- *
+ * @class Ext.form.FieldSet
+ * @extends Ext.container.Container
+ *
+ * A container for grouping sets of fields, rendered as a HTML `fieldset` element. The {@link #title}
+ * config will be rendered as the fieldset's `legend`.
+ *
+ * While FieldSets commonly contain simple groups of fields, they are general {@link Ext.container.Container Containers}
+ * and may therefore contain any type of components in their {@link #items}, including other nested containers.
+ * The default {@link #layout} for the FieldSet's items is `'anchor'`, but it can be configured to use any other
+ * layout type.
+ *
+ * FieldSets may also be collapsed if configured to do so; this can be done in two ways:
+ *
+ * 1. Set the {@link #collapsible} config to true; this will result in a collapse button being rendered next to
+ * the {@link #title legend title}, or:
+ * 2. Set the {@link #checkboxToggle} config to true; this is similar to using {@link #collapsible} but renders
+ * a {@link Ext.form.field.Checkbox checkbox} in place of the toggle button. The fieldset will be expanded when the
+ * checkbox is checked and collapsed when it is unchecked. The checkbox will also be included in the
+ * {@link Ext.form.Basic#submit form submit parameters} using the {@link #checkboxName} as its parameter name.
*
- *
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'
- }
-});
- *
- * @constructor Create a new PagingToolbar
- * @param {Object} config The config object
- * @xtype paging
+ * @docauthor Jason Johnston
*/
-(function() {
+Ext.define('Ext.form.FieldSet', {
+ extend: 'Ext.container.Container',
+ alias: 'widget.fieldset',
+ uses: ['Ext.form.field.Checkbox', 'Ext.panel.Tool', 'Ext.layout.container.Anchor', 'Ext.layout.component.FieldSet'],
-var T = Ext.Toolbar;
+ /**
+ * @cfg {String} title
+ * A title to be displayed in the fieldset's legend. May contain HTML markup.
+ */
-Ext.PagingToolbar = Ext.extend(Ext.Toolbar, {
/**
- * @cfg {Ext.data.Store} store
- * The {@link Ext.data.Store} the paging toolbar should use as its data source (required).
+ * @cfg {Boolean} checkboxToggle
+ * Set to 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). This checkbox will be included in form submits using the {@link #checkboxName}.
*/
+
/**
- * @cfg {Boolean} displayInfo
- * true to display the displayMsg (defaults to false)
+ * @cfg {String} checkboxName
+ * The name to assign to the fieldset's checkbox if {@link #checkboxToggle} = true
+ * (defaults to '[fieldset id]-checkbox').
*/
+
/**
- * @cfg {Number} pageSize
- * The number of records to display per page (defaults to 20)
+ * @cfg {Boolean} collapsible
+ * Set to 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}.
+ * Use the {@link #collapsed} config to collapse the fieldset by default.
*/
- pageSize : 20,
+
/**
- * @cfg {Boolean} prependButtons
- * true to insert any configured itemsbefore the paging buttons.
- * Defaults to false.
+ * @cfg {Boolean} collapsed
+ * Set to true to render the fieldset as collapsed by default. If {@link #checkboxToggle} is specified,
+ * the checkbox will also be unchecked by default.
*/
+ collapsed: false,
+
/**
- * @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.
+ * @property legend
+ * @type Ext.Component
+ * The component for the fieldset's legend. Will only be defined if the configuration requires a legend
+ * to be created, by setting the {@link #title} or {@link #checkboxToggle} options.
*/
- displayMsg : 'Displaying {0} - {1} of {2}',
+
/**
- * @cfg {String} emptyMsg
- * The message to display when no records are found (defaults to 'No data to display')
+ * @cfg {String} baseCls The base CSS class applied to the fieldset (defaults to 'x-fieldset').
*/
- emptyMsg : 'No data to display',
+ baseCls: Ext.baseCSSPrefix + 'fieldset',
+
/**
- * @cfg {String} beforePageText
- * The text displayed before the input item (defaults to 'Page').
+ * @cfg {String} layout The {@link Ext.container.Container#layout} for the fieldset's immediate child items.
+ * Defaults to 'anchor'.
*/
- beforePageText : 'Page',
+ layout: 'anchor',
+
+ componentLayout: 'fieldset',
+
+ // No aria role necessary as fieldset has its own recognized semantics
+ ariaRole: '',
+
+ renderTpl: [''],
+
+ maskOnDisable: false,
+
+ getElConfig: function(){
+ return {tag: 'fieldset', id: this.id};
+ },
+
+ initComponent: function() {
+ var me = this,
+ baseCls = me.baseCls;
+
+ me.callParent();
+
+ // Create the Legend component if needed
+ me.initLegend();
+
+ // Add body el selector
+ Ext.applyIf(me.renderSelectors, {
+ body: '.' + baseCls + '-body'
+ });
+
+ if (me.collapsed) {
+ me.addCls(baseCls + '-collapsed');
+ me.collapse();
+ }
+ },
+
+ // private
+ onRender: function(container, position) {
+ this.callParent(arguments);
+ // Make sure the legend is created and rendered
+ this.initLegend();
+ },
+
/**
- * @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.
+ * @private
+ * Initialize and render the legend component if necessary
*/
- afterPageText : 'of {0}',
+ initLegend: function() {
+ var me = this,
+ legendItems,
+ legend = me.legend;
+
+ // Create the legend component if needed and it hasn't been already
+ if (!legend && (me.title || me.checkboxToggle || me.collapsible)) {
+ legendItems = [];
+
+ // Checkbox
+ if (me.checkboxToggle) {
+ legendItems.push(me.createCheckboxCmp());
+ }
+ // Toggle button
+ else if (me.collapsible) {
+ legendItems.push(me.createToggleCmp());
+ }
+
+ // Title
+ legendItems.push(me.createTitleCmp());
+
+ legend = me.legend = Ext.create('Ext.container.Container', {
+ baseCls: me.baseCls + '-header',
+ ariaRole: '',
+ getElConfig: function(){
+ return {tag: 'legend', cls: this.baseCls};
+ },
+ items: legendItems
+ });
+ }
+
+ // Make sure legend is rendered if the fieldset is rendered
+ if (legend && !legend.rendered && me.rendered) {
+ me.legend.render(me.el, me.body); //insert before body element
+ }
+ },
+
/**
- * @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.
+ * @protected
+ * Creates the legend title component. This is only called internally, but could be overridden in subclasses
+ * to customize the title component.
+ * @return Ext.Component
*/
- firstText : 'First Page',
+ createTitleCmp: function() {
+ var me = this;
+ me.titleCmp = Ext.create('Ext.Component', {
+ html: me.title,
+ cls: me.baseCls + '-header-text'
+ });
+ return me.titleCmp;
+
+ },
+
/**
- * @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.
+ * @property checkboxCmp
+ * @type Ext.form.field.Checkbox
+ * Refers to the {@link Ext.form.field.Checkbox} component that is added next to the title in the legend. Only
+ * populated if the fieldset is configured with {@link #checkboxToggle}:true.
+ */
+
+ /**
+ * @protected
+ * Creates the checkbox component. This is only called internally, but could be overridden in subclasses
+ * to customize the checkbox's configuration or even return an entirely different component type.
+ * @return Ext.Component
+ */
+ createCheckboxCmp: function() {
+ var me = this,
+ suffix = '-checkbox';
+
+ me.checkboxCmp = Ext.create('Ext.form.field.Checkbox', {
+ name: me.checkboxName || me.id + suffix,
+ cls: me.baseCls + '-header' + suffix,
+ checked: !me.collapsed,
+ listeners: {
+ change: me.onCheckChange,
+ scope: me
+ }
+ });
+ return me.checkboxCmp;
+ },
+
+ /**
+ * @property toggleCmp
+ * @type Ext.panel.Tool
+ * Refers to the {@link Ext.panel.Tool} component that is added as the collapse/expand button next
+ * to the title in the legend. Only populated if the fieldset is configured with {@link #collapsible}:true.
*/
- prevText : 'Previous Page',
+
/**
- * @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.
+ * @protected
+ * Creates the toggle button component. This is only called internally, but could be overridden in
+ * subclasses to customize the toggle component.
+ * @return Ext.Component
*/
- nextText : 'Next Page',
+ createToggleCmp: function() {
+ var me = this;
+ me.toggleCmp = Ext.create('Ext.panel.Tool', {
+ type: 'toggle',
+ handler: me.toggle,
+ scope: me
+ });
+ return me.toggleCmp;
+ },
+
/**
- * @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.
+ * Sets the title of this fieldset
+ * @param {String} title The new title
+ * @return {Ext.form.FieldSet} this
*/
- lastText : 'Last Page',
+ setTitle: function(title) {
+ var me = this;
+ me.title = title;
+ me.initLegend();
+ me.titleCmp.update(title);
+ return me;
+ },
+
+ getTargetEl : function() {
+ return this.body || this.frameBody || this.el;
+ },
+
+ getContentTarget: function() {
+ return this.body;
+ },
+
/**
- * @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.
+ * @private
+ * Include the legend component in the items for ComponentQuery
*/
- refreshText : 'Refresh',
+ getRefItems: function(deep) {
+ var refItems = this.callParent(arguments),
+ legend = this.legend;
+
+ // Prepend legend items to ensure correct order
+ if (legend) {
+ refItems.unshift(legend);
+ if (deep) {
+ refItems.unshift.apply(refItems, legend.getRefItems(true));
+ }
+ }
+ return refItems;
+ },
/**
- *
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
+ * Expands the fieldset.
+ * @return {Ext.form.FieldSet} this
*/
-
+ expand : function(){
+ return this.setExpanded(true);
+ },
+
/**
- * The number of records to display per page. See also {@link #cursor}.
- * @type Number
- * @property pageSize
+ * Collapses the fieldset.
+ * @return {Ext.form.FieldSet} this
*/
+ collapse : function() {
+ return this.setExpanded(false);
+ },
/**
- * 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
+ * @private Collapse or expand the fieldset
*/
+ setExpanded: function(expanded) {
+ var me = this,
+ checkboxCmp = me.checkboxCmp;
- 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);
+ expanded = !!expanded;
+
+ if (checkboxCmp) {
+ checkboxCmp.setValue(expanded);
}
- delete this.buttons;
- if(this.displayInfo){
- this.items.push('->');
- this.items.push(this.displayItem = new T.TextItem({}));
+
+ if (expanded) {
+ me.removeCls(me.baseCls + '-collapsed');
+ } else {
+ me.addCls(me.baseCls + '-collapsed');
}
- 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})
- *
- */
- 'change',
- /**
- * @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.
- */
- 'beforechange'
- );
- this.on('afterlayout', this.onFirstLayout, this, {single: true});
- this.cursor = 0;
- this.bindStore(this.store, true);
+ me.collapsed = !expanded;
+ if (expanded) {
+ // ensure subitems will get rendered and layed out when expanding
+ me.getComponentLayout().childrenChanged = true;
+ }
+ me.doComponentLayout();
+ return me;
},
- // private
- onFirstLayout : function(){
- if(this.dsLoaded){
- this.onLoad.apply(this, this.dsLoaded);
- }
+ /**
+ * Toggle the fieldset's collapsed state to the opposite of what it is currently
+ */
+ toggle: function() {
+ this.setExpanded(!!this.collapsed);
},
- // 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);
- }
+ /**
+ * @private Handle changes in the checkbox checked state
+ */
+ onCheckChange: function(cmp, checked) {
+ this.setExpanded(checked);
},
- // private
- onLoad : function(store, r, o){
- if(!this.rendered){
- this.dsLoaded = [store, r, o];
- return;
+ beforeDestroy : function() {
+ var legend = this.legend;
+ if (legend) {
+ legend.destroy();
}
- 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.callParent();
+ }
+});
- 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);
- },
+/**
+ * @class Ext.form.Label
+ * @extends Ext.Component
- // private
- getPageData : function(){
- var total = this.store.getTotalCount();
+Produces a standalone `` element which can be inserted into a form and be associated with a field
+in that form using the {@link #forId} property.
+
+**NOTE:** in most cases it will be more appropriate to use the {@link Ext.form.Labelable#fieldLabel fieldLabel}
+and associated config properties ({@link Ext.form.Labelable#labelAlign}, {@link Ext.form.Labelable#labelWidth},
+etc.) in field components themselves, as that allows labels to be uniformly sized throughout the form.
+Ext.form.Label should only be used when your layout can not be achieved with the standard
+{@link Ext.form.Labelable field layout}.
+
+You will likely be associating the label with a field component that extends {@link Ext.form.field.Base}, so
+you should make sure the {@link #forId} is set to the same value as the {@link Ext.form.field.Base#inputId inputId}
+of that field.
+
+The label's text can be set using either the {@link #text} or {@link #html} configuration properties; the
+difference between the two is that the former will automatically escape HTML characters when rendering, while
+the latter will not.
+{@img Ext.form.Label/Ext.form.Label.png Ext.form.Label component}
+#Example usage:#
+
+This example creates a Label after its associated Text field, an arrangement that cannot currently
+be achieved using the standard Field layout's labelAlign.
+
+ Ext.create('Ext.form.Panel', {
+ title: 'Field with Label',
+ width: 400,
+ bodyPadding: 10,
+ renderTo: Ext.getBody(),
+ layout: {
+ type: 'hbox',
+ align: 'middle'
+ },
+ items: [{
+ xtype: 'textfield',
+ hideLabel: true,
+ flex: 1
+ }, {
+ xtype: 'label',
+ forId: 'myFieldId',
+ text: 'My Awesome Field',
+ margins: '0 0 0 10'
+ }]
+ });
+
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.Label', {
+ extend:'Ext.Component',
+ alias: 'widget.label',
+ requires: ['Ext.util.Format'],
+
+ /**
+ * @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. In most cases you will be
+ * associating the label with a {@link Ext.form.field.Base} component, so you should make sure this matches
+ * the {@link Ext.form.field.Base#inputId inputId} of that field.
+ */
+ /**
+ * @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.
+ */
+
+ maskOnDisable: false,
+ getElConfig: function(){
+ var me = this;
return {
- total : total,
- activePage : Math.ceil((this.cursor+this.pageSize)/this.pageSize),
- pages : total < this.pageSize ? 1 : Math.ceil(total/this.pageSize)
+ tag: 'label',
+ id: me.id,
+ htmlFor: me.forId || '',
+ html: me.text ? Ext.util.Format.htmlEncode(me.text) : (me.html || '')
};
},
/**
- * Change the active page
- * @param {Integer} page The page to display
+ * 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
*/
- changePage : function(page){
- this.doLoad(((page-1) * this.pageSize).constrain(0, this.store.getTotalCount()));
- },
-
- // private
- onLoadError : function(){
- if(!this.rendered){
- return;
+ setText : function(text, encode){
+ var me = this;
+
+ encode = encode !== false;
+ if(encode) {
+ me.text = text;
+ delete me.html;
+ } else {
+ me.html = text;
+ delete me.text;
}
- 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(me.rendered){
+ me.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(text) : text;
}
- return pageNum;
- },
+ return this;
+ }
+});
- onPagingFocus : function(){
- this.inputItem.select();
- },
- //private
- onPagingBlur : function(e){
- this.inputItem.setValue(this.getPageData().activePage);
- },
+/**
+ * @class Ext.form.Panel
+ * @extends Ext.panel.Panel
- // 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);
+FormPanel provides a standard container for forms. It is essentially a standard {@link Ext.panel.Panel} which
+automatically creates a {@link Ext.form.Basic BasicForm} for managing any {@link Ext.form.field.Field}
+objects that are added as descendants of the panel. It also includes conveniences for configuring and
+working with the BasicForm and the collection of Fields.
+
+__Layout__
+
+By default, FormPanel is configured with `{@link Ext.layout.container.Anchor layout:'anchor'}` for
+the layout of its immediate child items. This can be changed to any of the supported container layouts.
+The layout of sub-containers is configured in {@link Ext.container.Container#layout the standard way}.
+
+__BasicForm__
+
+Although **not listed** as configuration options of FormPanel, the FormPanel class accepts all
+of the config options supported by the {@link Ext.form.Basic} class, and will pass them along to
+the internal BasicForm when it is created.
+
+**Note**: If subclassing FormPanel, any configuration options for the BasicForm must be applied to
+the `initialConfig` property of the FormPanel. Applying {@link Ext.form.Basic BasicForm}
+configuration settings to `this` will *not* affect the BasicForm's configuration.
+
+The following events fired by the BasicForm will be re-fired by the FormPanel and can therefore be
+listened for on the FormPanel itself:
+
+- {@link Ext.form.Basic#beforeaction beforeaction}
+- {@link Ext.form.Basic#actionfailed actionfailed}
+- {@link Ext.form.Basic#actioncomplete actioncomplete}
+- {@link Ext.form.Basic#validitychange validitychange}
+- {@link Ext.form.Basic#dirtychange dirtychange}
+
+__Field Defaults__
+
+The {@link #fieldDefaults} config option conveniently allows centralized configuration of default values
+for all fields added as descendants of the FormPanel. Any config option recognized by implementations
+of {@link Ext.form.Labelable} may be included in this object. See the {@link #fieldDefaults} documentation
+for details of how the defaults are applied.
+
+__Form Validation__
+
+With the default configuration, form fields are validated on-the-fly while the user edits their values.
+This can be controlled on a per-field basis (or via the {@link #fieldDefaults} config) with the field
+config properties {@link Ext.form.field.Field#validateOnChange} and {@link Ext.form.field.Base#checkChangeEvents},
+and the FormPanel's config properties {@link #pollForChanges} and {@link #pollInterval}.
+
+Any component within the FormPanel can be configured with `formBind: true`. This will cause that
+component to be automatically disabled when the form is invalid, and enabled when it is valid. This is most
+commonly used for Button components to prevent submitting the form in an invalid state, but can be used on
+any component type.
+
+For more information on form validation see the following:
+
+- {@link Ext.form.field.Field#validateOnChange}
+- {@link #pollForChanges} and {@link #pollInterval}
+- {@link Ext.form.field.VTypes}
+- {@link Ext.form.Basic#doAction BasicForm.doAction clientValidation notes}
+
+__Form Submission__
+
+By default, Ext Forms are submitted through Ajax, using {@link Ext.form.action.Action}. See the documentation for
+{@link Ext.form.Basic} for details.
+{@img Ext.form.FormPanel/Ext.form.FormPanel.png Ext.form.FormPanel FormPanel component}
+__Example usage:__
+
+ Ext.create('Ext.form.Panel', {
+ title: 'Simple Form',
+ bodyPadding: 5,
+ width: 350,
+
+ // The form will submit an AJAX request to this URL when submitted
+ url: 'save-form.php',
+
+ // Fields will be arranged vertically, stretched to full width
+ layout: 'anchor',
+ defaults: {
+ anchor: '100%'
+ },
+
+ // The fields
+ defaultType: 'textfield',
+ items: [{
+ fieldLabel: 'First Name',
+ name: 'first',
+ allowBlank: false
+ },{
+ fieldLabel: 'Last Name',
+ name: 'last',
+ allowBlank: false
+ }],
+
+ // Reset and Submit buttons
+ buttons: [{
+ text: 'Reset',
+ handler: function() {
+ this.up('form').getForm().reset();
}
- }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);
+ }, {
+ text: 'Submit',
+ formBind: true, //only enabled once the form is valid
+ disabled: true,
+ handler: function() {
+ var form = this.up('form').getForm();
+ if (form.isValid()) {
+ form.submit({
+ success: function(form, action) {
+ Ext.Msg.alert('Success', action.result.msg);
+ },
+ failure: function(form, action) {
+ Ext.Msg.alert('Failed', action.result.msg);
+ }
+ });
}
}
- }
- },
+ }],
+ renderTo: Ext.getBody()
+ });
- // private
- getParams : function(){
- //retain backwards compat, allow params on the toolbar itself, if they exist.
- return this.paramNames || this.store.paramNames;
+ *
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.Panel', {
+ extend:'Ext.panel.Panel',
+ mixins: {
+ fieldAncestor: 'Ext.form.FieldAncestor'
},
+ alias: 'widget.form',
+ alternateClassName: ['Ext.FormPanel', 'Ext.form.FormPanel'],
+ requires: ['Ext.form.Basic', 'Ext.util.TaskRunner'],
- // private
- beforeLoad : function(){
- if(this.rendered && this.refresh){
- this.refresh.disable();
+ /**
+ * @cfg {Boolean} pollForChanges
+ * If set to true, sets up an interval task (using the {@link #pollInterval}) in which the
+ * panel's fields are repeatedly checked for changes in their values. This is in addition to the normal detection
+ * each field does on its own input element, and is not needed in most cases. It does, however, provide a
+ * means to absolutely guarantee detection of all changes including some edge cases in some browsers which
+ * do not fire native events. Defaults to false.
+ */
+
+ /**
+ * @cfg {Number} pollInterval
+ * Interval in milliseconds at which the form's fields are checked for value changes. Only used if
+ * the {@link #pollForChanges} option is set to true. Defaults to 500 milliseconds.
+ */
+
+ /**
+ * @cfg {String} layout The {@link Ext.container.Container#layout} for the form panel's immediate child items.
+ * Defaults to 'anchor'.
+ */
+ layout: 'anchor',
+
+ ariaRole: 'form',
+
+ initComponent: function() {
+ var me = this;
+
+ if (me.frame) {
+ me.border = false;
}
- },
+
+ me.initFieldAncestor();
+ me.callParent();
- // 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});
+ me.relayEvents(me.form, [
+ 'beforeaction',
+ 'actionfailed',
+ 'actioncomplete',
+ 'validitychange',
+ 'dirtychange'
+ ]);
+
+ // Start polling if configured
+ if (me.pollForChanges) {
+ me.startPolling(me.pollInterval || 500);
}
},
+ initItems: function() {
+ // Create the BasicForm
+ var me = this;
+
+ me.form = me.createForm();
+ me.callParent();
+ me.form.initialize();
+ },
+
/**
- * Move to the first page, has the same effect as clicking the 'first' button.
+ * @private
*/
- moveFirst : function(){
- this.doLoad(0);
+ createForm: function() {
+ return Ext.create('Ext.form.Basic', this, Ext.applyIf({listeners: {}}, this.initialConfig));
},
/**
- * Move to the previous page, has the same effect as clicking the 'previous' button.
+ * Provides access to the {@link Ext.form.Basic Form} which this Panel contains.
+ * @return {Ext.form.Basic} The {@link Ext.form.Basic Form} which this Panel contains.
*/
- movePrevious : function(){
- this.doLoad(Math.max(0, this.cursor-this.pageSize));
+ getForm: function() {
+ return this.form;
},
-
+
/**
- * Move to the next page, has the same effect as clicking the 'next' button.
+ * Loads an {@link Ext.data.Model} into this form (internally just calls {@link Ext.form.Basic#loadRecord})
+ * See also {@link #trackResetOnLoad}.
+ * @param {Ext.data.Model} record The record to load
+ * @return {Ext.form.Basic} The Ext.form.Basic attached to this FormPanel
*/
- moveNext : function(){
- this.doLoad(this.cursor+this.pageSize);
+ loadRecord: function(record) {
+ return this.getForm().loadRecord(record);
},
-
+
/**
- * Move to the last page, has the same effect as clicking the 'last' button.
+ * Returns the currently loaded Ext.data.Model instance if one was loaded via {@link #loadRecord}.
+ * @return {Ext.data.Model} The loaded instance
*/
- moveLast : function(){
- var total = this.store.getTotalCount(),
- extra = total % this.pageSize;
+ getRecord: function() {
+ return this.getForm().getRecord();
+ },
+
+ /**
+ * Convenience function for fetching the current value of each field in the form. This is the same as calling
+ * {@link Ext.form.Basic#getValues this.getForm().getValues()}
+ * @return {Object} The current form field values, keyed by field name
+ */
+ getValues: function() {
+ return this.getForm().getValues();
+ },
- this.doLoad(extra ? (total - extra) : total - this.pageSize);
+ beforeDestroy: function() {
+ this.stopPolling();
+ this.form.destroy();
+ this.callParent();
},
/**
- * Refresh the current page, has the same effect as clicking the 'refresh' button.
+ * This is a proxy for the underlying BasicForm's {@link Ext.form.Basic#load} call.
+ * @param {Object} options The options to pass to the action (see {@link Ext.form.Basic#load} and
+ * {@link Ext.form.Basic#doAction} for details)
*/
- doRefresh : function(){
- this.doLoad(this.cursor);
+ load: function(options) {
+ this.form.load(options);
},
/**
- * 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
+ * This is a proxy for the underlying BasicForm's {@link Ext.form.Basic#submit} call.
+ * @param {Object} options The options to pass to the action (see {@link Ext.form.Basic#submit} and
+ * {@link Ext.form.Basic#doAction} for details)
*/
- 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(store){
- store = Ext.StoreMgr.lookup(store);
- store.on({
- scope: this,
- beforeload: this.beforeLoad,
- load: this.onLoad,
- exception: this.onLoadError
- });
- doLoad = true;
- }
- this.store = store;
- if(doLoad){
- this.onLoad(store, null, {});
- }
+ submit: function(options) {
+ this.form.submit(options);
+ },
+
+ /*
+ * Inherit docs, not using onDisable because it only gets fired
+ * when the component is rendered.
+ */
+ disable: function(silent) {
+ this.callParent(arguments);
+ this.form.getFields().each(function(field) {
+ field.disable();
+ });
+ },
+
+ /*
+ * Inherit docs, not using onEnable because it only gets fired
+ * when the component is rendered.
+ */
+ enable: function(silent) {
+ this.callParent(arguments);
+ this.form.getFields().each(function(field) {
+ field.enable();
+ });
},
/**
- * Unbinds the paging toolbar from the specified {@link Ext.data.Store} (deprecated)
- * @param {Ext.data.Store} store The data store to unbind
+ * Start an interval task to continuously poll all the fields in the form for changes in their
+ * values. This is normally started automatically by setting the {@link #pollForChanges} config.
+ * @param {Number} interval The interval in milliseconds at which the check should run.
*/
- unbind : function(store){
- this.bindStore(null);
+ startPolling: function(interval) {
+ this.stopPolling();
+ var task = Ext.create('Ext.util.TaskRunner', interval);
+ task.start({
+ interval: 0,
+ run: this.checkChange,
+ scope: this
+ });
+ this.pollTask = task;
},
/**
- * Binds the paging toolbar to the specified {@link Ext.data.Store} (deprecated)
- * @param {Ext.data.Store} store The data store to bind
+ * Stop a running interval task that was started by {@link #startPolling}.
*/
- bind : function(store){
- this.bindStore(store);
+ stopPolling: function() {
+ var task = this.pollTask;
+ if (task) {
+ task.stopAll();
+ delete this.pollTask;
+ }
},
+ /**
+ * Forces each field within the form panel to
+ * {@link Ext.form.field.Field#checkChange check if its value has changed}.
+ */
+ checkChange: function() {
+ this.form.getFields().each(function(field) {
+ field.checkChange();
+ });
+ }
+});
+
+/**
+ * A {@link Ext.form.FieldContainer field container} which has a specialized layout for arranging
+ * {@link Ext.form.field.Radio} controls into columns, and provides convenience {@link Ext.form.field.Field}
+ * methods for {@link #getValue getting}, {@link #setValue setting}, and {@link #validate validating} the
+ * group of radio buttons as a whole.
+ *
+ * # Validation
+ *
+ * Individual radio buttons themselves have no default validation behavior, but
+ * sometimes you want to require a user to select one of a group of radios. RadioGroup
+ * allows this by setting the config `{@link #allowBlank}:false`; when the user does not check at
+ * one of the radio buttons, the entire group will be highlighted as invalid and the
+ * {@link #blankText error message} will be displayed according to the {@link #msgTarget} config.
+ *
+ * # Layout
+ *
+ * The default layout for RadioGroup makes it easy to arrange the radio buttons into
+ * columns; see the {@link #columns} and {@link #vertical} config documentation for details. You may also
+ * use a completely different layout by setting the {@link #layout} to one of the other supported layout
+ * types; for instance you may wish to use a custom arrangement of hbox and vbox containers. In that case
+ * the Radio components at any depth will still be managed by the RadioGroup's validation.
+ *
+ * {@img Ext.form.RadioGroup/Ext.form.RadioGroup.png Ext.form.RadioGroup component}
+ *
+ * # Example usage
+ *
+ * Ext.create('Ext.form.Panel', {
+ * title: 'RadioGroup Example',
+ * width: 300,
+ * height: 125,
+ * bodyPadding: 10,
+ * renderTo: Ext.getBody(),
+ * items:[{
+ * xtype: 'radiogroup',
+ * fieldLabel: 'Two Columns',
+ * // Arrange radio buttons into two columns, distributed vertically
+ * columns: 2,
+ * vertical: true,
+ * items: [
+ * {boxLabel: 'Item 1', name: 'rb', inputValue: '1'},
+ * {boxLabel: 'Item 2', name: 'rb', inputValue: '2', checked: true},
+ * {boxLabel: 'Item 3', name: 'rb', inputValue: '3'},
+ * {boxLabel: 'Item 4', name: 'rb', inputValue: '4'},
+ * {boxLabel: 'Item 5', name: 'rb', inputValue: '5'},
+ * {boxLabel: 'Item 6', name: 'rb', inputValue: '6'}
+ * ]
+ * }]
+ * });
+ *
+ */
+Ext.define('Ext.form.RadioGroup', {
+ extend: 'Ext.form.CheckboxGroup',
+ alias: 'widget.radiogroup',
+
+ /**
+ * @cfg {Array} items An Array of {@link Ext.form.field.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
- onDestroy : function(){
- this.bindStore(null);
- Ext.PagingToolbar.superclass.onDestroy.call(this);
+ defaultType : 'radiofield',
+
+ // private
+ groupCls : Ext.baseCSSPrefix + 'form-radio-group',
+
+ getBoxes: function() {
+ return this.query('[isRadio]');
}
+
});
-})();
-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
+/**
+ * @private
+ * Private utility class for managing all {@link Ext.form.field.Radio} fields grouped by name.
*/
-Ext.History = (function () {
- var iframe, hiddenField;
- var ready = false;
- var currentToken;
+Ext.define('Ext.form.RadioManager', {
+ extend: 'Ext.util.MixedCollection',
+ singleton: true,
- function getHash() {
- var href = location.href, i = href.indexOf("#");
- return i >= 0 ? href.substr(i + 1) : null;
+ getByName: function(name) {
+ return this.filterBy(function(item) {
+ return item.name == name;
+ });
+ },
+
+ getWithValue: function(name, value) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.inputValue == value;
+ });
+ },
+
+ getChecked: function(name) {
+ return this.findBy(function(item) {
+ return item.name == name && item.checked;
+ });
}
+});
+
+/**
+ * @class Ext.form.action.DirectLoad
+ * @extends Ext.form.action.Load
+ *
Provides {@link Ext.direct.Manager} support for loading form data.
+ *
This example illustrates usage of Ext.direct.Direct to load a form through Ext.Direct.
+ *
+var myFormPanel = new Ext.form.Panel({
+ // 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
+ },
+ // specify the order for the passed params
+ paramOrder: ['uid', 'foo']
+});
- function doSave() {
- hiddenField.value = currentToken;
+// 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:
+ *
+ */
+Ext.define('Ext.form.action.DirectLoad', {
+ extend:'Ext.form.action.Load',
+ requires: ['Ext.direct.Manager'],
+ alternateClassName: 'Ext.form.Action.DirectLoad',
+ alias: 'formaction.directload',
+
+ type: 'directload',
+
+ run: function() {
+ this.form.api.load.apply(window, this.getArgs());
+ },
+
+ /**
+ * @private
+ * Build the arguments to be sent to the Direct call.
+ * @return Array
+ */
+ getArgs: function() {
+ var me = this,
+ args = [],
+ form = me.form,
+ paramOrder = form.paramOrder,
+ params = me.getParams(),
+ i, len;
+
+ // If a paramOrder was specified, add the params into the argument list in that order.
+ if (paramOrder) {
+ for (i = 0, len = paramOrder.length; i < len; i++) {
+ args.push(params[paramOrder[i]]);
+ }
+ }
+ // If paramsAsHash was specified, add all the params as a single object argument.
+ else if (form.paramsAsHash) {
+ args.push(params);
+ }
+
+ // Add the callback and scope to the end of the arguments list
+ args.push(me.onSuccess, me);
+
+ return args;
+ },
+
+ // 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) {
+ return (this.result = result);
+ },
- function handleStateChange(token) {
- currentToken = token;
- Ext.History.fireEvent('change', token);
+ onSuccess: function(result, trans) {
+ if (trans.type == Ext.direct.Manager.self.exceptions.SERVER) {
+ result = {};
+ }
+ this.callParent([result]);
}
+});
- function updateIFrame (token) {
- var html = ['
+ * Also see the discussion in {@link Ext.form.action.DirectLoad}.
+ */
+Ext.define('Ext.form.action.DirectSubmit', {
+ extend:'Ext.form.action.Submit',
+ requires: ['Ext.direct.Manager'],
+ alternateClassName: 'Ext.form.Action.DirectSubmit',
+ alias: 'formaction.directsubmit',
- var doc = iframe.contentWindow.document;
- var elem = doc.getElementById("state");
- var token = elem ? elem.innerText : null;
+ type: 'directsubmit',
- var hash = getHash();
+ doSubmit: function() {
+ var me = this,
+ callback = Ext.Function.bind(me.onSuccess, me),
+ formEl = me.buildForm();
+ me.form.api.submit(formEl, callback, me);
+ Ext.removeNode(formEl);
+ },
- setInterval(function () {
+ // 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) {
+ return (this.result = result);
+ },
- doc = iframe.contentWindow.document;
- elem = doc.getElementById("state");
+ onSuccess: function(response, trans) {
+ if (trans.type === Ext.direct.Manager.self.exceptions.SERVER) {
+ response = {};
+ }
+ this.callParent([response]);
+ }
+});
- var newtoken = elem ? elem.innerText : null;
+/**
+ * @class Ext.form.action.StandardSubmit
+ * @extends Ext.form.action.Submit
+ *
A class which handles submission of data from {@link Ext.form.Basic Form}s using a standard
+ * <form> element submit. It does not handle the response from the submit.
+ *
If validation of the form fields fails, the Form's {@link Ext.form.Basic#afterAction} method
+ * will be called. Otherwise, afterAction will not be called.
+ *
Instances of this class are only created by a {@link Ext.form.Basic Form} when
+ * {@link Ext.form.Basic#submit submit}ting, when the form's {@link Ext.form.Basic#standardSubmit}
+ * config option is true.
+ */
+Ext.define('Ext.form.action.StandardSubmit', {
+ extend:'Ext.form.action.Submit',
+ alias: 'formaction.standardsubmit',
- var newHash = getHash();
+ /**
+ * @cfg {String} target
+ * Optional target attribute to be used for the form when submitting. If not specified,
+ * the target will be the current window/frame.
+ */
- if (newtoken !== token) {
- token = newtoken;
- handleStateChange(token);
- top.location.hash = token;
- hash = token;
- doSave();
- } else if (newHash !== hash) {
- hash = newHash;
- updateIFrame(newHash);
- }
+ /**
+ * @private
+ * Perform the form submit. Creates and submits a temporary form element containing an input element for each
+ * field value returned by {@link Ext.form.Basic#getValues}, plus any configured {@link #params params} or
+ * {@link Ext.form.Basic#baseParams baseParams}.
+ */
+ doSubmit: function() {
+ var form = this.buildForm();
+ form.submit();
+ Ext.removeNode(form);
+ }
- }, 50);
+});
- ready = true;
+/**
+ * @class Ext.form.field.Checkbox
+ * @extends Ext.form.field.Base
+
+Single checkbox field. Can be used as a direct replacement for traditional checkbox fields. Also serves as a
+parent class for {@link Ext.form.field.Radio radio buttons}.
+
+__Labeling:__ In addition to the {@link Ext.form.Labelable standard field labeling options}, checkboxes
+may be given an optional {@link #boxLabel} which will be displayed immediately after checkbox. Also see
+{@link Ext.form.CheckboxGroup} for a convenient method of grouping related checkboxes.
+
+__Values:__
+The main value of a checkbox is a boolean, indicating whether or not the checkbox is checked.
+The following values will check the checkbox:
+* `true`
+* `'true'`
+* `'1'`
+* `'on'`
+
+Any other value will uncheck the checkbox.
+
+In addition to the main boolean value, you may also specify a separate {@link #inputValue}. This will be
+sent as the parameter value when the form is {@link Ext.form.Basic#submit submitted}. You will want to set
+this value if you have multiple checkboxes with the same {@link #name}. If not specified, the value `on`
+will be used.
+{@img Ext.form.Checkbox/Ext.form.Checkbox.png Ext.form.Checkbox Checkbox component}
+__Example usage:__
+
+ Ext.create('Ext.form.Panel', {
+ bodyPadding: 10,
+ width : 300,
+ title : 'Pizza Order',
+ items: [
+ {
+ xtype : 'fieldcontainer',
+ fieldLabel : 'Toppings',
+ defaultType: 'checkboxfield',
+ items: [
+ {
+ boxLabel : 'Anchovies',
+ name : 'topping',
+ inputValue: '1',
+ id : 'checkbox1'
+ }, {
+ boxLabel : 'Artichoke Hearts',
+ name : 'topping',
+ inputValue: '2',
+ checked : true,
+ id : 'checkbox2'
+ }, {
+ boxLabel : 'Bacon',
+ name : 'topping',
+ inputValue: '3',
+ id : 'checkbox3'
+ }
+ ]
+ }
+ ],
+ bbar: [
+ {
+ text: 'Select Bacon',
+ handler: function() {
+ var checkbox = Ext.getCmp('checkbox3');
+ checkbox.setValue(true);
+ }
+ },
+ '-',
+ {
+ text: 'Select All',
+ handler: function() {
+ var checkbox1 = Ext.getCmp('checkbox1'),
+ checkbox2 = Ext.getCmp('checkbox2'),
+ checkbox3 = Ext.getCmp('checkbox3');
- Ext.History.fireEvent('ready', Ext.History);
- }
+ checkbox1.setValue(true);
+ checkbox2.setValue(true);
+ checkbox3.setValue(true);
+ }
+ },
+ {
+ text: 'Deselect All',
+ handler: function() {
+ var checkbox1 = Ext.getCmp('checkbox1'),
+ checkbox2 = Ext.getCmp('checkbox2'),
+ checkbox3 = Ext.getCmp('checkbox3');
- function startUp() {
- currentToken = hiddenField.value ? hiddenField.value : getHash();
+ checkbox1.setValue(false);
+ checkbox2.setValue(false);
+ checkbox3.setValue(false);
+ }
+ }
+ ],
+ renderTo: Ext.getBody()
+ });
- 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);
+ * @docauthor Robert Dougan
+ * @markdown
+ */
+Ext.define('Ext.form.field.Checkbox', {
+ extend: 'Ext.form.field.Base',
+ alias: ['widget.checkboxfield', 'widget.checkbox'],
+ alternateClassName: 'Ext.form.Checkbox',
+ requires: ['Ext.XTemplate', 'Ext.form.CheckboxManager'],
+
+ fieldSubTpl: [
+ '',
+ '',
+ '',
+ // Creates not an actual checkbox, but a button which is given aria role="checkbox" and
+ // styled with a custom checkbox image. This allows greater control and consistency in
+ // styling, and using a button allows it to gain focus and handle keyboard nav properly.
+ 'tabIndex="{tabIdx}" ',
+ 'class="{fieldCls} {typeCls}" autocomplete="off" hidefocus="true" />',
+ '',
+ '',
+ '',
+ {
+ disableFormats: true,
+ compiled: true
}
- }
+ ],
- 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',
+ isCheckbox: true,
- events:{},
+ /**
+ * @cfg {String} focusCls The CSS class to use when the checkbox receives focus
+ * (defaults to 'x-form-cb-focus')
+ */
+ focusCls: Ext.baseCSSPrefix + 'form-cb-focus',
- /**
- * 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();
- },
+ /**
+ * @cfg {String} fieldCls The default CSS class for the checkbox (defaults to 'x-form-field')
+ */
- /**
- * 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;
- }
- },
+ /**
+ * @cfg {String} fieldBodyCls
+ * An extra CSS class to be applied to the body content element in addition to {@link #fieldBodyCls}.
+ * Defaults to 'x-form-cb-wrap.
+ */
+ fieldBodyCls: Ext.baseCSSPrefix + 'form-cb-wrap',
- /**
- * Programmatically steps back one step in browser history (equivalent to the user pressing the Back button).
- */
- back: function(){
- history.go(-1);
- },
+ /**
+ * @cfg {Boolean} checked true if the checkbox should render initially checked (defaults to false)
+ */
+ checked: false,
- /**
- * Programmatically steps forward one step in browser history (equivalent to the user pressing the Forward button).
- */
- forward: function(){
- history.go(1);
- },
+ /**
+ * @cfg {String} checkedCls The CSS class added to the component's main element when it is in the checked state.
+ */
+ checkedCls: Ext.baseCSSPrefix + 'form-cb-checked',
- /**
- * 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 {String} boxLabel An optional text label that will appear next to the checkbox. Whether it appears before
+ * or after the checkbox is determined by the {@link #boxLabelAlign} config (defaults to after).
*/
+
/**
- * @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 {String} boxLabelCls The CSS class to be applied to the {@link #boxLabel} element
*/
+ boxLabelCls: Ext.baseCSSPrefix + 'form-cb-label',
+
/**
- * @cfg {Number} minWidth The minimum width of the tip in pixels (defaults to 40).
+ * @cfg {String} boxLabelAlign The position relative to the checkbox where the {@link #boxLabel} should
+ * appear. Recognized values are 'before' and 'after'. Defaults to 'after'.
*/
- minWidth : 40,
+ boxLabelAlign: 'after',
+
/**
- * @cfg {Number} maxWidth The maximum width of the tip in pixels (defaults to 300). The maximum supported value is 500.
+ * @cfg {String} inputValue The value that should go into the generated input element's value attribute and
+ * should be used as the parameter value when submitting as part of a form. Defaults to "on".
*/
- maxWidth : 300,
+ inputValue: 'on',
+
/**
- * @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 {String} uncheckedValue If configured, this will be submitted as the checkbox's value during form
+ * submit if the checkbox is unchecked. By default this is undefined, which results in nothing being
+ * submitted for the checkbox field when the form is submitted (the default behavior of HTML checkboxes).
*/
- 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?").
+ * @cfg {Function} handler A function called when the {@link #checked} value changes (can be used instead of
+ * handling the {@link #change change event}). The handler is passed the following parameters:
+ *
+ *
checkbox : Ext.form.field.Checkbox
The Checkbox being toggled.
+ *
checked : Boolean
The new checked state of the checkbox.
+ *
*/
- 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,
+ /**
+ * @cfg {Object} scope An object to use as the scope ('this' reference) of the {@link #handler} function
+ * (defaults to this Checkbox).
+ */
- closeAction: 'hide',
+ // private overrides
+ checkChangeEvents: [],
+ inputType: 'checkbox',
+ ariaRole: 'checkbox',
// private
- initComponent : function(){
- Ext.Tip.superclass.initComponent.call(this);
- if(this.closable && !this.title){
- this.elements += ',header';
- }
+ onRe: /^on$/i,
+
+ initComponent: function(){
+ this.callParent(arguments);
+ this.getManager().add(this);
},
- // private
- afterRender : function(){
- Ext.Tip.superclass.afterRender.call(this);
- if(this.closable){
- this.addTool({
- id: 'close',
- handler: this[this.closeAction],
- scope: this
- });
- }
+ initValue: function() {
+ var me = this,
+ checked = !!me.checked;
+
+ /**
+ * The original value of the field as configured in the {@link #checked} configuration, or
+ * as loaded by the last form load operation if the form's {@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}
+ * setting is true.
+ * @type Mixed
+ * @property originalValue
+ */
+ me.originalValue = me.lastValue = checked;
+
+ // Set the initial checked state
+ me.setValue(checked);
},
- /**
- * 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]);
+ // private
+ onRender : function(ct, position) {
+ var me = this;
+ Ext.applyIf(me.renderSelectors, {
+ /**
+ * @property boxLabelEl
+ * @type Ext.core.Element
+ * A reference to the label element created for the {@link #boxLabel}. Only present if the
+ * component has been rendered and has a boxLabel configured.
+ */
+ boxLabelEl: 'label.' + me.boxLabelCls
+ });
+ Ext.applyIf(me.subTplData, {
+ boxLabel: me.boxLabel,
+ boxLabelCls: me.boxLabelCls,
+ boxLabelAlign: me.boxLabelAlign
+ });
+
+ me.callParent(arguments);
},
- // 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;
- }
+ initEvents: function() {
+ var me = this;
+ me.callParent();
+ me.mon(me.inputEl, 'click', me.onBoxClick, me);
},
/**
- * 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).
+ * @private Handle click on the checkbox button
*/
- showBy : function(el, pos){
- if(!this.rendered){
- this.render(Ext.getBody());
+ onBoxClick: function(e) {
+ var me = this;
+ if (!me.disabled && !me.readOnly) {
+ this.setValue(!this.checked);
}
- 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]).
+ * Returns the checked state of the checkbox.
+ * @return {Boolean} True if checked, else false
*/
+ getRawValue: function() {
+ return this.checked;
+ },
+
/**
- * @cfg {Boolean} trackMouse True to have the tooltip follow the mouse as it
- * moves over the target element (defaults to false).
+ * Returns the checked state of the checkbox.
+ * @return {Boolean} True if checked, else false
*/
- trackMouse : false,
+ getValue: function() {
+ return this.checked;
+ },
+
/**
- * @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.
+ * Returns the submit value for the checkbox which can be used when submitting forms.
+ * @return {Boolean/null} True if checked; otherwise either the {@link #uncheckedValue} or null.
*/
- anchorToTarget : true,
+ getSubmitValue: function() {
+ var unchecked = this.uncheckedValue,
+ uncheckedVal = Ext.isDefined(unchecked) ? unchecked : null;
+ return this.checked ? this.inputValue : uncheckedVal;
+ },
+
/**
- * @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.
+ * Sets the checked state of the checkbox.
+ * @param {Boolean/String} value The following values will check the checkbox:
+ * true, 'true', '1', or 'on', as well as a String that matches the {@link #inputValue}.
+ * Any other value will uncheck the checkbox.
+ * @return {Boolean} the new checked state of the checkbox
*/
- 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;
- }
+ setRawValue: function(value) {
+ var me = this,
+ inputEl = me.inputEl,
+ inputValue = me.inputValue,
+ checked = (value === true || value === 'true' || value === '1' ||
+ ((Ext.isString(value) && inputValue) ? value == inputValue : me.onRe.test(value)));
+
+ if (inputEl) {
+ inputEl.dom.setAttribute('aria-checked', checked);
+ me[checked ? 'addCls' : 'removeCls'](me.checkedCls);
}
- });
-});
- *
- */
- // private
- targetCounter : 0,
+ me.checked = me.rawValue = checked;
+ return checked;
+ },
- constrainPosition : false,
+ /**
+ * Sets the checked state of the checkbox, and invokes change detection.
+ * @param {Boolean/String} checked The following values will check the checkbox:
+ * true, 'true', '1', or 'on', as well as a String that matches the {@link #inputValue}.
+ * Any other value will uncheck the checkbox.
+ * @return {Ext.form.field.Checkbox} this
+ */
+ setValue: function(checked) {
+ var me = this;
- // private
- initComponent : function(){
- Ext.ToolTip.superclass.initComponent.call(this);
- this.lastActive = new Date();
- this.initTarget(this.target);
- this.origAnchor = this.anchor;
- },
+ // If an array of strings is passed, find all checkboxes in the group with the same name as this
+ // one and check all those whose inputValue is in the array, unchecking all the others. This is to
+ // facilitate setting values from Ext.form.Basic#setValues, but is not publicly documented as we
+ // don't want users depending on this behavior.
+ if (Ext.isArray(checked)) {
+ me.getManager().getByName(me.name).each(function(cb) {
+ cb.setValue(Ext.Array.contains(checked, cb.inputValue));
+ });
+ } else {
+ me.callParent(arguments);
+ }
- // 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
- });
+ return me;
},
// private
- afterRender : function(){
- Ext.ToolTip.superclass.afterRender.call(this);
- this.anchorEl.setStyle('z-index', this.el.getZIndex() + 1).setVisibilityMode(Ext.Element.DISPLAY);
+ valueToRaw: function(value) {
+ // No extra conversion for checkboxes
+ return value;
},
/**
- * 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
+ * @private
+ * Called when the checkbox's checked state changes. Invokes the {@link #handler} callback
+ * function if specified.
*/
- 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;
+ onChange: function(newVal, oldVal) {
+ var me = this,
+ handler = me.handler;
+ if (handler) {
+ handler.call(me.scope || me, me, newVal);
}
+ me.callParent(arguments);
},
- // 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();
- }
+ // inherit docs
+ getManager: function() {
+ return Ext.form.CheckboxManager;
},
- // 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]];
+ onEnable: function() {
+ var me = this,
+ inputEl = me.inputEl;
+ me.callParent();
+ if (inputEl) {
+ // Can still be disabled if the field is readOnly
+ inputEl.dom.disabled = me.readOnly;
}
},
- getMouseOffset : function(){
- var offset = this.anchor ? [0,0] : [15,18];
- if(this.mouseOffset){
- offset[0] += this.mouseOffset[0];
- offset[1] += this.mouseOffset[1];
+ setReadOnly: function(readOnly) {
+ var me = this,
+ inputEl = me.inputEl;
+ if (inputEl) {
+ // Set the button to disabled when readonly
+ inputEl.dom.disabled = readOnly || me.disabled;
}
- return offset;
+ me.readOnly = readOnly;
},
- // 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);
- }
+ /**
+ * @protected Calculate and return the natural width of the bodyEl. It's possible that the initial
+ * rendering will cause the boxLabel to wrap and give us a bad width, so we must prevent wrapping
+ * while measuring.
+ */
+ getBodyNaturalWidth: function() {
+ var me = this,
+ bodyEl = me.bodyEl,
+ ws = 'white-space',
+ width;
+ bodyEl.setStyle(ws, 'nowrap');
+ width = bodyEl.getWidth();
+ bodyEl.setStyle(ws, '');
+ return width;
+ }
- 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
+ * @class Ext.layout.component.field.Trigger
+ * @extends Ext.layout.component.field.Field
+ * Layout class for {@link Ext.form.field.Trigger} fields. Adjusts the input field size to accommodate
+ * the trigger button(s).
+ * @private
+ */
- // 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;
- }
+Ext.define('Ext.layout.component.field.Trigger', {
+
+ /* Begin Definitions */
+
+ alias: ['layout.triggerfield'],
+
+ extend: 'Ext.layout.component.field.Field',
+
+ /* End Definitions */
+
+ type: 'triggerfield',
+
+ sizeBodyContents: function(width, height) {
+ var me = this,
+ owner = me.owner,
+ inputEl = owner.inputEl,
+ triggerWrap = owner.triggerWrap,
+ triggerWidth = owner.getTriggerWidth();
+
+ // If we or our ancestor is hidden, we can get a triggerWidth calculation
+ // of 0. We don't want to resize in this case.
+ if (owner.hideTrigger || owner.readOnly || triggerWidth > 0) {
+ // Decrease the field's width by the width of the triggers. Both the field and the triggerWrap
+ // are floated left in CSS so they'll stack up side by side.
+ me.setElementSize(inputEl, Ext.isNumber(width) ? width - triggerWidth : width);
+
+ // Explicitly set the triggerWrap's width, to prevent wrapping
+ triggerWrap.setWidth(triggerWidth);
}
- var mouseOffset = this.getMouseOffset();
- offsets[0] += mouseOffset[0];
- offsets[1] += mouseOffset[1];
+ }
+});
+/**
+ * @class Ext.view.View
+ * @extends Ext.view.AbstractView
+ *
+ * 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.Panel}.
+ *
+ * {@img Ext.DataView/Ext.DataView.png Ext.DataView component}
+ *
+ * Ext.regModel('Image', {
+ * Fields: [
+ * {name:'src', type:'string'},
+ * {name:'caption', type:'string'}
+ * ]
+ * });
+ *
+ * Ext.create('Ext.data.Store', {
+ * id:'imagesStore',
+ * model: 'Image',
+ * data: [
+ * {src:'http://www.sencha.com/img/20110215-feat-drawing.png', caption:'Drawing & Charts'},
+ * {src:'http://www.sencha.com/img/20110215-feat-data.png', caption:'Advanced Data'},
+ * {src:'http://www.sencha.com/img/20110215-feat-html5.png', caption:'Overhauled Theme'},
+ * {src:'http://www.sencha.com/img/20110215-feat-perf.png', caption:'Performance Tuned'}
+ * ]
+ * });
+ *
+ * var imageTpl = new Ext.XTemplate(
+ * '<tpl for=".">',
+ * '<div style="thumb-wrap">',
+ * '<img src="{src}" />',
+ * '<br/><span>{caption}</span>',
+ * '</div>',
+ * '</tpl>'
+ * );
+ *
+ * Ext.create('Ext.DataView', {
+ * store: Ext.data.StoreManager.lookup('imagesStore'),
+ * tpl: imageTpl,
+ * itemSelector: 'div.thumb-wrap',
+ * emptyText: 'No images available',
+ * renderTo: Ext.getBody()
+ * });
+ */
+Ext.define('Ext.view.View', {
+ extend: 'Ext.view.AbstractView',
+ alternateClassName: 'Ext.DataView',
+ alias: 'widget.dataview',
+
+ inheritableStatics: {
+ EventMap: {
+ mousedown: 'MouseDown',
+ mouseup: 'MouseUp',
+ click: 'Click',
+ dblclick: 'DblClick',
+ contextmenu: 'ContextMenu',
+ mouseover: 'MouseOver',
+ mouseout: 'MouseOut',
+ mouseenter: 'MouseEnter',
+ mouseleave: 'MouseLeave',
+ keydown: 'KeyDown',
+ focus: 'Focus'
+ }
+ },
+
+ addCmpEvents: function() {
+ this.addEvents(
+ /**
+ * @event beforeitemmousedown
+ * Fires before the mousedown event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemmousedown',
+ /**
+ * @event beforeitemmouseup
+ * Fires before the mouseup event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemmouseup',
+ /**
+ * @event beforeitemmouseenter
+ * Fires before the mouseenter event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemmouseenter',
+ /**
+ * @event beforeitemmouseleave
+ * Fires before the mouseleave event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemmouseleave',
+ /**
+ * @event beforeitemclick
+ * Fires before the click event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemclick',
+ /**
+ * @event beforeitemdblclick
+ * Fires before the dblclick event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemdblclick',
+ /**
+ * @event beforeitemcontextmenu
+ * Fires before the contextmenu event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforeitemcontextmenu',
+ /**
+ * @event beforeitemkeydown
+ * Fires before the keydown event on an item is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object. Use {@link Ext.EventObject#getKey getKey()} to retrieve the key that was pressed.
+ */
+ 'beforeitemkeydown',
+ /**
+ * @event itemmousedown
+ * Fires when there is a mouse down on an item
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemmousedown',
+ /**
+ * @event itemmouseup
+ * Fires when there is a mouse up on an item
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemmouseup',
+ /**
+ * @event itemmouseenter
+ * Fires when the mouse enters an item.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemmouseenter',
+ /**
+ * @event itemmouseleave
+ * Fires when the mouse leaves an item.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemmouseleave',
+ /**
+ * @event itemclick
+ * Fires when an item is clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemclick',
+ /**
+ * @event itemdblclick
+ * Fires when an item is double clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemdblclick',
+ /**
+ * @event itemcontextmenu
+ * Fires when an item is right clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'itemcontextmenu',
+ /**
+ * @event itemkeydown
+ * Fires when a key is pressed while an item is currently selected.
+ * @param {Ext.view.View} this
+ * @param {Ext.data.Model} record The record that belongs to the item
+ * @param {HTMLElement} item The item's element
+ * @param {Number} index The item's index
+ * @param {Ext.EventObject} e The raw event object. Use {@link Ext.EventObject#getKey getKey()} to retrieve the key that was pressed.
+ */
+ 'itemkeydown',
+ /**
+ * @event beforecontainermousedown
+ * Fires before the mousedown event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainermousedown',
+ /**
+ * @event beforecontainermouseup
+ * Fires before the mouseup event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainermouseup',
+ /**
+ * @event beforecontainermouseover
+ * Fires before the mouseover event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainermouseover',
+ /**
+ * @event beforecontainermouseout
+ * Fires before the mouseout event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainermouseout',
+ /**
+ * @event beforecontainerclick
+ * Fires before the click event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainerclick',
+ /**
+ * @event beforecontainerdblclick
+ * Fires before the dblclick event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainerdblclick',
+ /**
+ * @event beforecontainercontextmenu
+ * Fires before the contextmenu event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'beforecontainercontextmenu',
+ /**
+ * @event beforecontainerkeydown
+ * Fires before the keydown event on the container is processed. Returns false to cancel the default action.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object. Use {@link Ext.EventObject#getKey getKey()} to retrieve the key that was pressed.
+ */
+ 'beforecontainerkeydown',
+ /**
+ * @event containermouseup
+ * Fires when there is a mouse up on the container
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containermouseup',
+ /**
+ * @event containermouseover
+ * Fires when you move the mouse over the container.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containermouseover',
+ /**
+ * @event containermouseout
+ * Fires when you move the mouse out of the container.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containermouseout',
+ /**
+ * @event containerclick
+ * Fires when the container is clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containerclick',
+ /**
+ * @event containerdblclick
+ * Fires when the container is double clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containerdblclick',
+ /**
+ * @event containercontextmenu
+ * Fires when the container is right clicked.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object
+ */
+ 'containercontextmenu',
+ /**
+ * @event containerkeydown
+ * Fires when a key is pressed while the container is focused, and no item is currently selected.
+ * @param {Ext.view.View} this
+ * @param {Ext.EventObject} e The raw event object. Use {@link Ext.EventObject#getKey getKey()} to retrieve the key that was pressed.
+ */
+ 'containerkeydown',
- return offsets;
+ /**
+ * @event selectionchange
+ * Fires when the selected nodes change. Relayed event from the underlying selection model.
+ * @param {Ext.view.View} 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.view.View} this
+ * @param {HTMLElement} node The node to be selected
+ * @param {Array} selections Array of currently selected nodes
+ */
+ 'beforeselect'
+ );
},
-
// 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();
- }
- },
+ afterRender: function(){
+ var me = this,
+ listeners;
- // 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();
- }
- },
+ me.callParent();
- // private
- onTargetOut : function(e){
- if(this.disabled || e.within(this.target.dom, true)){
- return;
- }
- this.clearTimer('show');
- if(this.autoHide !== false){
- this.delayHide();
- }
- },
+ listeners = {
+ scope: me,
+ /*
+ * We need to make copies of this since some of the events fired here will end up triggering
+ * a new event to be called and the shared event object will be mutated. In future we should
+ * investigate if there are any issues with creating a new event object for each event that
+ * is fired.
+ */
+ freezeEvent: true,
+ click: me.handleEvent,
+ mousedown: me.handleEvent,
+ mouseup: me.handleEvent,
+ dblclick: me.handleEvent,
+ contextmenu: me.handleEvent,
+ mouseover: me.handleEvent,
+ mouseout: me.handleEvent,
+ keydown: me.handleEvent
+ };
- // private
- delayHide : function(){
- if(!this.hidden && !this.hideTimer){
- this.hideTimer = this.hide.defer(this.hideDelay, this);
+ me.mon(me.getTargetEl(), listeners);
+
+ if (me.store) {
+ me.bindStore(me.store, true);
}
},
- /**
- * Hides this tooltip if visible.
- */
- hide: function(){
- this.clearTimer('dismiss');
- this.lastActive = new Date();
- if(this.anchorEl){
- this.anchorEl.hide();
+ handleEvent: function(e) {
+ if (this.processUIEvent(e) !== false) {
+ this.processSpecialEvent(e);
}
- Ext.ToolTip.superclass.hide.call(this);
- delete this.triggerElement;
},
- /**
- * Shows this tooltip at the current event target XY position.
+ // Private template method
+ processItemEvent: Ext.emptyFn,
+ processContainerEvent: Ext.emptyFn,
+ processSpecialEvent: Ext.emptyFn,
+
+ /*
+ * Returns true if this mouseover/out event is still over the overItem.
*/
- 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.anchorEl.show();
- this.syncAnchor();
- this.constrainPosition = this.origConstrainPosition;
- }else{
- this.anchorEl.hide();
- }
- },
+ stillOverItem: function (event, overItem) {
+ var nowOver;
- // 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();
- }else{
- this.anchorEl.hide();
+ // There is this weird bug when you hover over the border of a cell it is saying
+ // the target is the table.
+ // BrowserBug: IE6 & 7. If me.mouseOverItem has been removed and is no longer
+ // in the DOM then accessing .offsetParent will throw an "Unspecified error." exception.
+ // typeof'ng and checking to make sure the offsetParent is an object will NOT throw
+ // this hard exception.
+ if (overItem && typeof(overItem.offsetParent) === "object") {
+ // mouseout : relatedTarget == nowOver, target == wasOver
+ // mouseover: relatedTarget == wasOver, target == nowOver
+ nowOver = (event.type == 'mouseout') ? event.getRelatedTarget() : event.getTarget();
+ return Ext.fly(overItem).contains(nowOver);
}
- },
- // 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);
+ return false;
},
- // private
- setPagePosition : function(x, y){
- Ext.ToolTip.superclass.setPagePosition.call(this, x, y);
- if(this.anchor){
- this.syncAnchor();
- }
- },
+ processUIEvent: function(e) {
+ var me = this,
+ item = e.getTarget(me.getItemSelector(), me.getTargetEl()),
+ map = this.statics().EventMap,
+ index, record,
+ type = e.type,
+ overItem = me.mouseOverItem,
+ newType;
- // private
- clearTimer : function(name){
- name = name + 'Timer';
- clearTimeout(this[name]);
- delete this[name];
- },
+ if (!item) {
+ if (type == 'mouseover' && me.stillOverItem(e, overItem)) {
+ item = overItem;
+ }
- // private
- clearTimers : function(){
- this.clearTimer('show');
- this.clearTimer('dismiss');
- this.clearTimer('hide');
- },
+ // Try to get the selected item to handle the keydown event, otherwise we'll just fire a container keydown event
+ if (type == 'keydown') {
+ record = me.getSelectionModel().getLastSelected();
+ if (record) {
+ item = me.getNode(record);
+ }
+ }
+ }
- // private
- onShow : function(){
- Ext.ToolTip.superclass.onShow.call(this);
- Ext.getDoc().on('mousedown', this.onDocMouseDown, this);
- },
+ if (item) {
+ index = me.indexOf(item);
+ if (!record) {
+ record = me.getRecord(item);
+ }
- // private
- onHide : function(){
- Ext.ToolTip.superclass.onHide.call(this);
- Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
- },
+ if (me.processItemEvent(record, item, index, e) === false) {
+ return false;
+ }
- // private
- onDocMouseDown : function(e){
- if(this.autoHide !== true && !this.closable && !e.within(this.el.dom)){
- this.disable();
- this.doEnable.defer(100, this);
- }
- },
-
- // private
- doEnable : function(){
- if(!this.isDestroyed){
- this.enable();
- }
- },
+ newType = me.isNewItemEvent(item, e);
+ if (newType === false) {
+ return false;
+ }
- // private
- onDisable : function(){
- this.clearTimers();
- this.hide();
- },
+ if (
+ (me['onBeforeItem' + map[newType]](record, item, index, e) === false) ||
+ (me.fireEvent('beforeitem' + newType, me, record, item, index, e) === false) ||
+ (me['onItem' + map[newType]](record, item, index, e) === false)
+ ) {
+ return false;
+ }
- // 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;
+ me.fireEvent('item' + newType, me, record, item, index, e);
+ }
+ else {
+ if (
+ (me.processContainerEvent(e) === false) ||
+ (me['onBeforeContainer' + map[type]](e) === false) ||
+ (me.fireEvent('beforecontainer' + type, me, e) === false) ||
+ (me['onContainer' + map[type]](e) === false)
+ ) {
+ return false;
}
+
+ me.fireEvent('container' + type, me, e);
}
- 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);
+
+ return true;
},
- // private
- onDestroy : function(){
- Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
- Ext.ToolTip.superclass.onDestroy.call(this);
- }
-});
+ isNewItemEvent: function (item, e) {
+ var me = this,
+ overItem = me.mouseOverItem,
+ type = e.type;
-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,
+ switch (type) {
+ case 'mouseover':
+ if (item === overItem) {
+ return false;
+ }
+ me.mouseOverItem = item;
+ return 'mouseenter';
- // private
- tagConfig : {
- namespace : "ext",
- attribute : "qtip",
- width : "qwidth",
- target : "target",
- title : "qtitle",
- hide : "hide",
- cls : "qclass",
- align : "qalign",
- anchor : "anchor"
+ case 'mouseout':
+ // If the currently mouseovered item contains the mouseover target, it's *NOT* a mouseleave
+ if (me.stillOverItem(e, overItem)) {
+ return false;
+ }
+ me.mouseOverItem = null;
+ return 'mouseleave';
+ }
+ return type;
},
// private
- initComponent : function(){
- this.target = this.target || Ext.getDoc();
- this.targets = this.targets || {};
- Ext.QuickTip.superclass.initComponent.call(this);
+ onItemMouseEnter: function(record, item, index, e) {
+ if (this.trackOver) {
+ this.highlightItem(item);
+ }
},
- /**
- * 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;
- }
- }
+ // private
+ onItemMouseLeave : function(record, item, index, e) {
+ if (this.trackOver) {
+ this.clearHighlight();
}
},
+ // @private, template methods
+ onItemMouseDown: Ext.emptyFn,
+ onItemMouseUp: Ext.emptyFn,
+ onItemFocus: Ext.emptyFn,
+ onItemClick: Ext.emptyFn,
+ onItemDblClick: Ext.emptyFn,
+ onItemContextMenu: Ext.emptyFn,
+ onItemKeyDown: Ext.emptyFn,
+ onBeforeItemMouseDown: Ext.emptyFn,
+ onBeforeItemMouseUp: Ext.emptyFn,
+ onBeforeItemFocus: Ext.emptyFn,
+ onBeforeItemMouseEnter: Ext.emptyFn,
+ onBeforeItemMouseLeave: Ext.emptyFn,
+ onBeforeItemClick: Ext.emptyFn,
+ onBeforeItemDblClick: Ext.emptyFn,
+ onBeforeItemContextMenu: Ext.emptyFn,
+ onBeforeItemKeyDown: Ext.emptyFn,
+
+ // @private, template methods
+ onContainerMouseDown: Ext.emptyFn,
+ onContainerMouseUp: Ext.emptyFn,
+ onContainerMouseOver: Ext.emptyFn,
+ onContainerMouseOut: Ext.emptyFn,
+ onContainerClick: Ext.emptyFn,
+ onContainerDblClick: Ext.emptyFn,
+ onContainerContextMenu: Ext.emptyFn,
+ onContainerKeyDown: Ext.emptyFn,
+ onBeforeContainerMouseDown: Ext.emptyFn,
+ onBeforeContainerMouseUp: Ext.emptyFn,
+ onBeforeContainerMouseOver: Ext.emptyFn,
+ onBeforeContainerMouseOut: Ext.emptyFn,
+ onBeforeContainerClick: Ext.emptyFn,
+ onBeforeContainerDblClick: Ext.emptyFn,
+ onBeforeContainerContextMenu: Ext.emptyFn,
+ onBeforeContainerKeyDown: Ext.emptyFn,
+
/**
- * 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.
+ * Highlight a given item in the DataView. This is called by the mouseover handler if {@link #overItemCls}
+ * and {@link #trackOver} are configured, but can also be called manually by other code, for instance to
+ * handle stepping through the list via keyboard navigation.
+ * @param {HTMLElement} item The item to highlight
*/
- unregister : function(el){
- delete this.targets[Ext.id(el)];
+ highlightItem: function(item) {
+ var me = this;
+ me.clearHighlight();
+ me.highlightedItem = item;
+ Ext.fly(item).addCls(me.overItemCls);
},
-
+
/**
- * 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.
+ * Un-highlight the currently highlighted item, if any.
*/
- 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');
+ clearHighlight: function() {
+ var me = this,
+ highlighted = me.highlightedItem;
+
+ if (highlighted) {
+ Ext.fly(highlighted).removeCls(me.overItemCls);
+ delete me.highlightedItem;
}
},
-
- 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);
+
+ refresh: function() {
+ var me = this;
+ me.clearHighlight();
+ me.callParent(arguments);
+ if (!me.isFixedHeight()) {
+ me.doComponentLayout();
}
- return ttp;
+ }
+});
+/**
+ * Component layout for {@link Ext.view.BoundList}. Handles constraining the height to the configured maxHeight.
+ * @class Ext.layout.component.BoundList
+ * @extends Ext.layout.component.Component
+ * @private
+ */
+Ext.define('Ext.layout.component.BoundList', {
+ extend: 'Ext.layout.component.Component',
+ alias: 'layout.boundlist',
+
+ type: 'component',
+
+ beforeLayout: function() {
+ return this.callParent(arguments) || this.owner.refreshed > 0;
},
- // 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;
+ onLayout : function(width, height) {
+ var me = this,
+ owner = me.owner,
+ floating = owner.floating,
+ el = owner.el,
+ xy = el.getXY(),
+ isNumber = Ext.isNumber,
+ minWidth, maxWidth, minHeight, maxHeight,
+ naturalWidth, naturalHeight, constrainedWidth, constrainedHeight, undef;
+
+ if (floating) {
+ // Position offscreen so the natural width is not affected by the viewport's right edge
+ el.setXY([-9999,-9999]);
}
- 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;
+
+ // Calculate initial layout
+ me.setTargetSize(width, height);
+
+ // Handle min/maxWidth for auto-width
+ if (!isNumber(width)) {
+ minWidth = owner.minWidth;
+ maxWidth = owner.maxWidth;
+ if (isNumber(minWidth) || isNumber(maxWidth)) {
+ naturalWidth = el.getWidth();
+ if (naturalWidth < minWidth) {
+ constrainedWidth = minWidth;
+ }
+ else if (naturalWidth > maxWidth) {
+ constrainedWidth = maxWidth;
+ }
+ if (constrainedWidth) {
+ me.setTargetSize(constrainedWidth);
+ }
}
- 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;
+ // Handle min/maxHeight for auto-height
+ if (!isNumber(height)) {
+ minHeight = owner.minHeight;
+ maxHeight = owner.maxHeight;
+ if (isNumber(minHeight) || isNumber(maxHeight)) {
+ naturalHeight = el.getHeight();
+ if (naturalHeight < minHeight) {
+ constrainedHeight = minHeight;
+ }
+ else if (naturalHeight > maxHeight) {
+ constrainedHeight = maxHeight;
+ }
+ if (constrainedHeight) {
+ me.setTargetSize(undef, constrainedHeight);
+ }
}
- 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;
+ if (floating) {
+ // Restore position
+ el.setXY(xy);
}
+ },
- this.clearTimer('show');
- if(this.autoHide !== false){
- this.delayHide();
+ afterLayout: function() {
+ var me = this,
+ toolbar = me.owner.pagingToolbar;
+ me.callParent();
+ if (toolbar) {
+ toolbar.doComponentLayout();
}
},
- // 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;
+ setTargetSize : function(width, height) {
+ var me = this,
+ owner = me.owner,
+ listHeight = null,
+ toolbar;
+
+ // Size the listEl
+ if (Ext.isNumber(height)) {
+ listHeight = height - owner.el.getFrameWidth('tb');
+ toolbar = owner.pagingToolbar;
+ if (toolbar) {
+ listHeight -= toolbar.getHeight();
}
}
- Ext.QuickTip.superclass.showAt.call(this, xy);
- },
+ me.setElementSize(owner.listEl, null, listHeight);
- // inherit docs
- hide: function(){
- delete this.activeTarget;
- Ext.QuickTip.superclass.hide.call(this);
+ me.callParent(arguments);
}
-});
-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 the config options for the {@link Ext.QuickTip QuickTip} class
- *
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, // Show 50ms after entering target
- 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: 10000 // Hide after 10 seconds hover
});
-
- *
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,
- disabled = false;
-
- 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',
- disabled: disabled
- });
- if(autoRender !== false){
- tip.render(Ext.getBody());
- }
- }
- },
-
- // Protected method called by the dd classes
- ddDisable : function(){
- // don't disable it if we don't need to
- if(tip && !disabled){
- tip.disable();
- }
- },
-
- // Protected method called by the dd classes
- ddEnable : function(){
- // only enable it if it hasn't been disabled
- if(tip && !disabled){
- tip.enable();
- }
- },
-
- /**
- * Enable quick tips globally.
- */
- enable : function(){
- if(tip){
- tip.enable();
- }
- disabled = false;
- },
-
- /**
- * Disable quick tips globally.
- */
- disable : function(){
- if(tip){
- tip.disable();
- }
- disabled = true;
- },
-
- /**
- * Returns true if quick tips are enabled, else false.
- * @return {Boolean}
- */
- isEnabled : function(){
- return tip !== undefined && !tip.disabled;
- },
-
- /**
- * Gets the single {@link Ext.QuickTip QuickTip} instance used to show tips from all registered elements.
- * @return {Ext.QuickTip}
- */
- 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:
-
+/**
+ * @class Ext.toolbar.TextItem
+ * @extends Ext.toolbar.Item
+ *
+ * A simple class that renders text directly into a toolbar.
+ *
+ * ## Example usage
+ *
+ * {@img Ext.toolbar.TextItem/Ext.toolbar.TextItem.png TextItem component}
+ *
+ * Ext.create('Ext.panel.Panel', {
+ * title: 'Panel with TextItem',
+ * width: 300,
+ * height: 200,
+ * tbar: [
+ * {xtype: 'tbtext', text: 'Sample TextItem'}
+ * ],
+ * renderTo: Ext.getBody()
+ * });
+ *
+ * @constructor
+ * Creates a new TextItem
+ * @param {Object} text A text string, or a config object containing a text property
*/
-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
- });
- },
+Ext.define('Ext.toolbar.TextItem', {
+ extend: 'Ext.toolbar.Item',
+ requires: ['Ext.XTemplate'],
+ alias: 'widget.tbtext',
+ alternateClassName: 'Ext.Toolbar.TextItem',
/**
- * @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
+ * @cfg {String} text The text to be used as innerHTML (html tags are accepted)
*/
- onSlide : function(slider, e, thumb) {
- this.show();
- this.body.update(this.getText(thumb));
- this.doAutoWidth();
- this.el.alignTo(thumb.el, 'b-t?', this.offsets);
+ text: '',
+
+ renderTpl: '{text}',
+ //
+ baseCls: Ext.baseCSSPrefix + 'toolbar-text',
+
+ onRender : function() {
+ Ext.apply(this.renderData, {
+ text: this.text
+ });
+ this.callParent(arguments);
},
/**
- * 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
+ * Updates this item's text, setting the text to be used as innerHTML.
+ * @param {String} t The text to display (html accepted).
*/
- getText : function(thumb) {
- return String(thumb.value);
+ setText : function(t) {
+ if (this.rendered) {
+ this.el.update(t);
+ this.ownerCt.doLayout(); // In case an empty text item (centered at zero height) receives new text.
+ } else {
+ this.text = t;
+ }
}
});
-
-//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.
- *
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 Trigger field directly, as it renders exactly like a combobox
+ * for which you can provide a custom implementation.
+ * {@img Ext.form.field.Trigger/Ext.form.field.Trigger.png Ext.form.field.Trigger component}
+ * For example:
*
- * @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}).
+ *
However, in general you will most likely want to use Trigger as the base class for a reusable component.
+ * {@link Ext.form.field.Date} and {@link Ext.form.field.ComboBox} are perfect examples of this.
*
* @constructor
- * @param {Object} config
- * @xtype treepanel
+ * Create a new Trigger field.
+ * @param {Object} config Configuration options (valid {@Ext.form.field.Text} config options will also be applied
+ * to the base Text field)
*/
-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.
',
+ {
+ compiled: true,
+ disableFormats: true
}
- // args inline for performance while bubbling events
- return this.fireEvent(ename, a1, a2, a3, a4, a5, a6);
- },
+ ],
+ /**
+ * @cfg {String} triggerCls
+ * An additional CSS class used to style the trigger button. The trigger will always get the
+ * {@link #triggerBaseCls} by default and triggerCls will be appended if specified.
+ * Defaults to undefined.
+ */
/**
- * Returns this root node for this tree
- * @return {Node}
+ * @cfg {String} triggerBaseCls
+ * The base CSS class that is always added to the trigger button. The {@link #triggerCls} will be
+ * appended in addition to this class.
*/
- getRootNode : function(){
- return this.root;
- },
+ triggerBaseCls: Ext.baseCSSPrefix + 'form-trigger',
/**
- * 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}
+ * @cfg {String} triggerWrapCls
+ * The CSS class that is added to the div wrapping the trigger button(s).
*/
- setRootNode : function(node){
- this.destroyRoot();
- 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();
- }
- },
+ triggerWrapCls: Ext.baseCSSPrefix + 'form-trigger-wrap',
/**
- * Gets a node in this tree by its id
- * @param {String} id
- * @return {Node}
+ * @cfg {Boolean} hideTrigger true to hide the trigger element and display only the base
+ * text field (defaults to false)
*/
- getNodeById : function(id){
- return this.nodeHash[id];
- },
+ hideTrigger: false,
+
+ /**
+ * @cfg {Boolean} editable false to prevent the user from typing text directly into the field;
+ * the field can only have its value set via an action invoked by the trigger. (defaults to true).
+ */
+ editable: true,
+
+ /**
+ * @cfg {Boolean} readOnly true to prevent the user from changing the field, and
+ * hides the trigger. Supercedes the editable and hideTrigger options if the value is true.
+ * (defaults to false)
+ */
+ readOnly: false,
+
+ /**
+ * @cfg {Boolean} selectOnFocus true to select any existing text in the field immediately on focus.
+ * Only applies when {@link #editable editable} = true (defaults to false).
+ */
+
+ /**
+ * @cfg {Boolean} repeatTriggerClick true to attach a {@link Ext.util.ClickRepeater click repeater}
+ * to the trigger. Defaults to false.
+ */
+ repeatTriggerClick: false,
+
+ /**
+ * @hide
+ * @method autoSize
+ */
+ autoSize: Ext.emptyFn,
// private
- registerNode : function(node){
- this.nodeHash[node.id] = node;
+ monitorTab: true,
+ // private
+ mimicing: false,
+ // private
+ triggerIndexRe: /trigger-index-(\d+)/,
+
+ componentLayout: 'triggerfield',
+
+ initComponent: function() {
+ this.wrapFocusCls = this.triggerWrapCls + '-focus';
+ this.callParent(arguments);
},
// private
- unregisterNode : function(node){
- delete this.nodeHash[node.id];
+ onRender: function(ct, position) {
+ var me = this,
+ triggerCls,
+ triggerBaseCls = me.triggerBaseCls,
+ triggerWrapCls = me.triggerWrapCls,
+ triggerConfigs = [],
+ i;
+
+ // triggerCls is a synonym for trigger1Cls, so copy it.
+ // TODO this triggerCls API design doesn't feel clean, especially where it butts up against the
+ // single triggerCls config. Should rethink this, perhaps something more structured like a list of
+ // trigger config objects that hold cls, handler, etc.
+ if (!me.trigger1Cls) {
+ me.trigger1Cls = me.triggerCls;
+ }
+
+ // Create as many trigger elements as we have triggerCls configs, but always at least one
+ for (i = 0; (triggerCls = me['trigger' + (i + 1) + 'Cls']) || i < 1; i++) {
+ triggerConfigs.push({
+ cls: [Ext.baseCSSPrefix + 'trigger-index-' + i, triggerBaseCls, triggerCls].join(' '),
+ role: 'button'
+ });
+ }
+ triggerConfigs[i - 1].cls += ' ' + triggerBaseCls + '-last';
+
+ Ext.applyIf(me.renderSelectors, {
+ /**
+ * @property triggerWrap
+ * @type Ext.core.Element
+ * A reference to the div element wrapping the trigger button(s). Only set after the field has been rendered.
+ */
+ triggerWrap: '.' + triggerWrapCls
+ });
+ Ext.applyIf(me.subTplData, {
+ triggerWrapCls: triggerWrapCls,
+ triggerEl: Ext.core.DomHelper.markup(triggerConfigs),
+ clearCls: me.clearCls
+ });
+
+ me.callParent(arguments);
+
+ /**
+ * @property triggerEl
+ * @type Ext.CompositeElement
+ * A composite of all the trigger button elements. Only set after the field has been rendered.
+ */
+ me.triggerEl = Ext.select('.' + triggerBaseCls, true, me.triggerWrap.dom);
+
+ me.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc();
+ me.initTrigger();
},
- // private
- toString : function(){
- return '[Tree'+(this.id?' '+this.id:'')+']';
+ onEnable: function() {
+ this.callParent();
+ this.triggerWrap.unmask();
+ },
+
+ onDisable: function() {
+ this.callParent();
+ this.triggerWrap.mask();
+ },
+
+ afterRender: function() {
+ this.callParent();
+ this.updateEditState();
},
- // private
- restrictExpand : function(node){
- var p = node.parentNode;
- if(p){
- if(p.expandedChild && p.expandedChild.parentNode == p){
- p.expandedChild.collapse();
+ updateEditState: function() {
+ var me = this,
+ inputEl = me.inputEl,
+ triggerWrap = me.triggerWrap,
+ noeditCls = Ext.baseCSSPrefix + 'trigger-noedit',
+ displayed,
+ readOnly;
+
+ if (me.rendered) {
+ if (me.readOnly) {
+ inputEl.addCls(noeditCls);
+ readOnly = true;
+ displayed = false;
+ } else {
+ if (me.editable) {
+ inputEl.removeCls(noeditCls);
+ readOnly = false;
+ } else {
+ inputEl.addCls(noeditCls);
+ readOnly = true;
+ }
+ displayed = !me.hideTrigger;
}
- p.expandedChild = node;
+
+ triggerWrap.setDisplayed(displayed);
+ inputEl.dom.readOnly = readOnly;
+ me.doComponentLayout();
}
},
/**
- * 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}
+ * Get the total width of the trigger button area. Only useful after the field has been rendered.
+ * @return {Number} The trigger width
*/
- 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;
+ getTriggerWidth: function() {
+ var me = this,
+ triggerWrap = me.triggerWrap,
+ totalTriggerWidth = 0;
+ if (triggerWrap && !me.hideTrigger && !me.readOnly) {
+ me.triggerEl.each(function(trigger) {
+ totalTriggerWidth += trigger.getWidth();
+ });
+ totalTriggerWidth += me.triggerWrap.getFrameWidth('lr');
+ }
+ return totalTriggerWidth;
},
- /**
- * Returns the default {@link Ext.tree.TreeLoader} for this TreePanel.
- * @return {Ext.tree.TreeLoader} The TreeLoader for this TreePanel.
- */
- getLoader : function(){
- return this.loader;
+ setHideTrigger: function(hideTrigger) {
+ if (hideTrigger != this.hideTrigger) {
+ this.hideTrigger = hideTrigger;
+ this.updateEditState();
+ }
},
/**
- * Expand all nodes
+ * @param {Boolean} editable 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.
*/
- expandAll : function(){
- this.root.expand(true);
+ setEditable: function(editable) {
+ if (editable != this.editable) {
+ this.editable = editable;
+ this.updateEditState();
+ }
},
/**
- * Collapse all nodes
+ * @param {Boolean} readOnly 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.
*/
- collapseAll : function(){
- this.root.collapse(true);
+ setReadOnly: function(readOnly) {
+ if (readOnly != this.readOnly) {
+ this.readOnly = readOnly;
+ this.updateEditState();
+ }
},
- /**
- * 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();
+ // private
+ initTrigger: function() {
+ var me = this,
+ triggerWrap = me.triggerWrap,
+ triggerEl = me.triggerEl;
+
+ if (me.repeatTriggerClick) {
+ me.triggerRepeater = Ext.create('Ext.util.ClickRepeater', triggerWrap, {
+ preventDefault: true,
+ handler: function(cr, e) {
+ me.onTriggerWrapClick(e);
+ }
+ });
+ } else {
+ me.mon(me.triggerWrap, 'click', me.onTriggerWrapClick, me);
}
- return this.selModel;
+
+ triggerEl.addClsOnOver(me.triggerBaseCls + '-over');
+ triggerEl.each(function(el, c, i) {
+ el.addClsOnOver(me['trigger' + (i + 1) + 'Cls'] + '-over');
+ });
+ triggerEl.addClsOnClick(me.triggerBaseCls + '-click');
+ triggerEl.each(function(el, c, i) {
+ el.addClsOnClick(me['trigger' + (i + 1) + 'Cls'] + '-click');
+ });
},
- /**
- * 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){
- if(Ext.isEmpty(path)){
- if(callback){
- callback(false, undefined);
- }
- return;
- }
- 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);
+ // private
+ onDestroy: function() {
+ var me = this;
+ Ext.destroyMembers(me, 'triggerRepeater', 'triggerWrap', 'triggerEl');
+ delete me.doc;
+ me.callParent();
},
- /**
- * 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){
- if(Ext.isEmpty(path)){
- if(callback){
- callback(false, undefined);
- }
- return;
- }
- 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);
+ // private
+ onFocus: function() {
+ var me = this;
+ this.callParent();
+ if (!me.mimicing) {
+ me.bodyEl.addCls(me.wrapFocusCls);
+ me.mimicing = true;
+ me.mon(me.doc, 'mousedown', me.mimicBlur, me, {
+ delay: 10
+ });
+ if (me.monitorTab) {
+ me.on('specialkey', me.checkTab, me);
}
}
},
- /**
- * Returns the underlying Element for this tree
- * @return {Ext.Element} The Element
- */
- getTreeEl : function(){
- return this.body;
+ // private
+ checkTab: function(me, e) {
+ if (!this.ignoreMonitorTab && e.getKey() == e.TAB) {
+ this.triggerBlur();
+ }
},
// 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')});
- },
+ onBlur: Ext.emptyFn,
// private
- initEvents : function(){
- Ext.tree.TreePanel.superclass.initEvents.call(this);
+ mimicBlur: function(e) {
+ if (!this.isDestroyed && !this.bodyEl.contains(e.target) && this.validateBlur(e)) {
+ this.triggerBlur();
+ }
+ },
- 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
+ triggerBlur: function() {
+ var me = this;
+ me.mimicing = false;
+ me.mun(me.doc, 'mousedown', me.mimicBlur, me);
+ if (me.monitorTab && me.inputEl) {
+ me.un('specialkey', me.checkTab, me);
+ }
+ Ext.form.field.Trigger.superclass.onBlur.call(me);
+ if (me.bodyEl) {
+ me.bodyEl.removeCls(me.wrapFocusCls);
+ }
},
+ beforeBlur: Ext.emptyFn,
+
// private
- afterRender : function(){
- Ext.tree.TreePanel.superclass.afterRender.call(this);
- this.renderRoot();
+ // This should be overridden by any subclass that needs to check whether or not the field can be blurred.
+ validateBlur: function(e) {
+ return true;
},
- beforeDestroy : function(){
- if(this.rendered){
- Ext.dd.ScrollManager.unregister(this.body);
- Ext.destroy(this.dropZone, this.dragZone);
+ // private
+ // process clicks upon triggers.
+ // determine which trigger index, and dispatch to the appropriate click handler
+ onTriggerWrapClick: function(e) {
+ var me = this,
+ t = e && e.getTarget('.' + Ext.baseCSSPrefix + 'form-trigger', null),
+ match = t && t.className.match(me.triggerIndexRe),
+ idx,
+ triggerClickMethod;
+
+ if (match && !me.readOnly) {
+ idx = parseInt(match[1], 10);
+ triggerClickMethod = me['onTrigger' + (idx + 1) + 'Click'] || me.onTriggerClick;
+ if (triggerClickMethod) {
+ triggerClickMethod.call(me, e);
+ }
}
- this.destroyRoot();
- Ext.destroy(this.loader);
- this.nodeHash = this.root = this.loader = null;
- Ext.tree.TreePanel.superclass.beforeDestroy.call(this);
},
-
- /**
- * Destroy the root node. Not included by itself because we need to pass the silent parameter.
- * @private
- */
- destroyRoot : function(){
- if(this.root && this.root.destroy){
- this.root.destroy(true);
- }
- }
/**
- * @cfg {String/Number} activeItem
- * @hide
+ * 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.field.ComboBox and Ext.form.field.Date for
+ * sample implementations.
+ * @method
+ * @param {Ext.EventObject} e
*/
+ onTriggerClick: Ext.emptyFn
+
/**
- * @cfg {Boolean} autoDestroy
- * @hide
+ * @cfg {Boolean} grow @hide
*/
/**
- * @cfg {Object/String/Function} autoLoad
- * @hide
+ * @cfg {Number} growMin @hide
*/
/**
- * @cfg {Boolean} autoWidth
- * @hide
+ * @cfg {Number} growMax @hide
*/
+});
+
+/**
+ * @class Ext.form.field.Picker
+ * @extends Ext.form.field.Trigger
+ *
An abstract class for fields that have a single trigger which opens a "picker" popup below
+ * the field, e.g. a combobox menu list or a date picker. It provides a base implementation for
+ * toggling the picker's visibility when the trigger is clicked, as well as keyboard navigation
+ * and some basic events. Sizing and alignment of the picker can be controlled via the {@link #matchFieldWidth}
+ * and {@link #pickerAlign}/{@link #pickerOffset} config properties respectively.
+ *
You would not normally use this class directly, but instead use it as the parent class for
+ * a specific picker field implementation. Subclasses must implement the {@link #createPicker} method
+ * to create a picker component appropriate for the field.
+ *
+ */
+Ext.define('Ext.form.field.Picker', {
+ extend: 'Ext.form.field.Trigger',
+ alias: 'widget.pickerfield',
+ alternateClassName: 'Ext.form.Picker',
+ requires: ['Ext.util.KeyNav'],
+
/**
- * @cfg {Boolean/Number} bufferResize
- * @hide
+ * @cfg {Boolean} matchFieldWidth
+ * Whether the picker dropdown's width should be explicitly set to match the width of the field.
+ * Defaults to true.
*/
+ matchFieldWidth: true,
+
/**
- * @cfg {String} defaultType
- * @hide
+ * @cfg {String} pickerAlign
+ * The {@link Ext.core.Element#alignTo alignment position} with which to align the picker. Defaults
+ * to "tl-bl?"
*/
+ pickerAlign: 'tl-bl?',
+
/**
- * @cfg {Object} defaults
- * @hide
+ * @cfg {Array} pickerOffset
+ * An offset [x,y] to use in addition to the {@link #pickerAlign} when positioning the picker.
+ * Defaults to undefined.
*/
+
/**
- * @cfg {Boolean} hideBorders
- * @hide
+ * @cfg {String} openCls
+ * A class to be added to the field's {@link #bodyEl} element when the picker is opened. Defaults
+ * to 'x-pickerfield-open'.
*/
+ openCls: Ext.baseCSSPrefix + 'pickerfield-open',
+
/**
- * @cfg {Mixed} items
- * @hide
+ * @property isExpanded
+ * @type Boolean
+ * True if the picker is currently expanded, false if not.
*/
+
/**
- * @cfg {String} layout
- * @hide
+ * @cfg {Boolean} editable false to prevent the user from typing text directly into the field;
+ * the field can only have its value set via selecting a value from the picker. In this state, the picker
+ * can also be opened by clicking directly on the input field itself.
+ * (defaults to true).
*/
+ editable: true,
+
+
+ initComponent: function() {
+ this.callParent();
+
+ // Custom events
+ this.addEvents(
+ /**
+ * @event expand
+ * Fires when the field's picker is expanded.
+ * @param {Ext.form.field.Picker} field This field instance
+ */
+ 'expand',
+ /**
+ * @event collapse
+ * Fires when the field's picker is collapsed.
+ * @param {Ext.form.field.Picker} field This field instance
+ */
+ 'collapse',
+ /**
+ * @event select
+ * Fires when a value is selected via the picker.
+ * @param {Ext.form.field.Picker} field This field instance
+ * @param {Mixed} value The value that was selected. The exact type of this value is dependent on
+ * the individual field and picker implementations.
+ */
+ 'select'
+ );
+ },
+
+
+ initEvents: function() {
+ var me = this;
+ me.callParent();
+
+ // Add handlers for keys to expand/collapse the picker
+ me.keyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
+ down: function() {
+ if (!me.isExpanded) {
+ // Don't call expand() directly as there may be additional processing involved before
+ // expanding, e.g. in the case of a ComboBox query.
+ me.onTriggerClick();
+ }
+ },
+ esc: me.collapse,
+ scope: me,
+ forceKeyDown: true
+ });
+
+ // Non-editable allows opening the picker by clicking the field
+ if (!me.editable) {
+ me.mon(me.inputEl, 'click', me.onTriggerClick, me);
+ }
+
+ // Disable native browser autocomplete
+ if (Ext.isGecko) {
+ me.inputEl.dom.setAttribute('autocomplete', 'off');
+ }
+ },
+
+
/**
- * @cfg {Object} layoutConfig
- * @hide
+ * Expand this field's picker dropdown.
*/
+ expand: function() {
+ var me = this,
+ bodyEl, picker, collapseIf;
+
+ if (me.rendered && !me.isExpanded && !me.isDestroyed) {
+ bodyEl = me.bodyEl;
+ picker = me.getPicker();
+ collapseIf = me.collapseIf;
+
+ // show the picker and set isExpanded flag
+ picker.show();
+ me.isExpanded = true;
+ me.alignPicker();
+ bodyEl.addCls(me.openCls);
+
+ // monitor clicking and mousewheel
+ me.mon(Ext.getDoc(), {
+ mousewheel: collapseIf,
+ mousedown: collapseIf,
+ scope: me
+ });
+ Ext.EventManager.onWindowResize(me.alignPicker, me);
+ me.fireEvent('expand', me);
+ me.onExpand();
+ }
+ },
+
+ onExpand: Ext.emptyFn,
+
/**
- * @cfg {Boolean} monitorResize
- * @hide
+ * @protected
+ * Aligns the picker to the
*/
+ alignPicker: function() {
+ var me = this,
+ picker, isAbove,
+ aboveSfx = '-above';
+
+ if (this.isExpanded) {
+ picker = me.getPicker();
+ if (me.matchFieldWidth) {
+ // Auto the height (it will be constrained by min and max width) unless there are no records to display.
+ picker.setSize(me.bodyEl.getWidth(), picker.store && picker.store.getCount() ? null : 0);
+ }
+ if (picker.isFloating()) {
+ picker.alignTo(me.inputEl, me.pickerAlign, me.pickerOffset);
+
+ // add the {openCls}-above class if the picker was aligned above
+ // the field due to hitting the bottom of the viewport
+ isAbove = picker.el.getY() < me.inputEl.getY();
+ me.bodyEl[isAbove ? 'addCls' : 'removeCls'](me.openCls + aboveSfx);
+ picker.el[isAbove ? 'addCls' : 'removeCls'](picker.baseCls + aboveSfx);
+ }
+ }
+ },
+
/**
- * @property items
- * @hide
+ * Collapse this field's picker dropdown.
*/
+ collapse: function() {
+ if (this.isExpanded && !this.isDestroyed) {
+ var me = this,
+ openCls = me.openCls,
+ picker = me.picker,
+ doc = Ext.getDoc(),
+ collapseIf = me.collapseIf,
+ aboveSfx = '-above';
+
+ // hide the picker and set isExpanded flag
+ picker.hide();
+ me.isExpanded = false;
+
+ // remove the openCls
+ me.bodyEl.removeCls([openCls, openCls + aboveSfx]);
+ picker.el.removeCls(picker.baseCls + aboveSfx);
+
+ // remove event listeners
+ doc.un('mousewheel', collapseIf, me);
+ doc.un('mousedown', collapseIf, me);
+ Ext.EventManager.removeResizeListener(me.alignPicker, me);
+ me.fireEvent('collapse', me);
+ me.onCollapse();
+ }
+ },
+
+ onCollapse: Ext.emptyFn,
+
+
/**
- * @method cascade
- * @hide
+ * @private
+ * Runs on mousewheel and mousedown of doc to check to see if we should collapse the picker
*/
+ collapseIf: function(e) {
+ var me = this;
+ if (!me.isDestroyed && !e.within(me.bodyEl, false, true) && !e.within(me.picker.el, false, true)) {
+ me.collapse();
+ }
+ },
+
/**
- * @method doLayout
- * @hide
+ * Return a reference to the picker component for this field, creating it if necessary by
+ * calling {@link #createPicker}.
+ * @return {Ext.Component} The picker component
*/
+ getPicker: function() {
+ var me = this;
+ return me.picker || (me.picker = me.createPicker());
+ },
+
/**
- * @method find
- * @hide
+ * Create and return the component to be used as this field's picker. Must be implemented
+ * by subclasses of Picker.
+ * @return {Ext.Component} The picker component
*/
+ createPicker: Ext.emptyFn,
+
/**
- * @method findBy
- * @hide
+ * Handles the trigger click; by default toggles between expanding and collapsing the
+ * picker component.
*/
+ onTriggerClick: function() {
+ var me = this;
+ if (!me.readOnly && !me.disabled) {
+ if (me.isExpanded) {
+ me.collapse();
+ } else {
+ me.expand();
+ }
+ me.inputEl.focus();
+ }
+ },
+
+ mimicBlur: function(e) {
+ var me = this,
+ picker = me.picker;
+ // ignore mousedown events within the picker element
+ if (!picker || !e.within(picker.el, false, true)) {
+ me.callParent(arguments);
+ }
+ },
+
+ onDestroy : function(){
+ var me = this;
+ Ext.EventManager.removeResizeListener(me.alignPicker, me);
+ Ext.destroy(me.picker, me.keyNav);
+ me.callParent();
+ }
+
+});
+
+
+/**
+ * @class Ext.form.field.Spinner
+ * @extends Ext.form.field.Trigger
+ *
A field with a pair of up/down spinner buttons. This class is not normally instantiated directly,
+ * instead it is subclassed and the {@link #onSpinUp} and {@link #onSpinDown} methods are implemented
+ * to handle when the buttons are clicked. A good example of this is the {@link Ext.form.field.Number} field
+ * which uses the spinner to increment and decrement the field's value by its {@link Ext.form.field.Number#step step}
+ * config value.
+ * {@img Ext.form.field.Spinner/Ext.form.field.Spinner.png Ext.form.field.Spinner field}
+ * For example:
+ Ext.define('Ext.ux.CustomSpinner', {
+ extend: 'Ext.form.field.Spinner',
+ alias: 'widget.customspinner',
+
+ // override onSpinUp (using step isn't neccessary)
+ onSpinUp: function() {
+ var me = this;
+ if (!me.readOnly) {
+ var val = me.step; // set the default value to the step value
+ if(me.getValue() !== '') {
+ val = parseInt(me.getValue().slice(0, -5)); // gets rid of " Pack"
+ }
+ me.setValue((val + me.step) + ' Pack');
+ }
+ },
+
+ // override onSpinDown
+ onSpinDown: function() {
+ var me = this;
+ if (!me.readOnly) {
+ if(me.getValue() !== '') {
+ val = parseInt(me.getValue().slice(0, -5)); // gets rid of " Pack"
+ }
+ me.setValue((val - me.step) + ' Pack');
+ }
+ }
+ });
+
+ Ext.create('Ext.form.FormPanel', {
+ title: 'Form with SpinnerField',
+ bodyPadding: 5,
+ width: 350,
+ renderTo: Ext.getBody(),
+ items:[{
+ xtype: 'customspinner',
+ fieldLabel: 'How Much Beer?',
+ step: 6
+ }]
+ });
+ *
By default, pressing the up and down arrow keys will also trigger the onSpinUp and onSpinDown methods;
+ * to prevent this, set {@link #keyNavEnabled} = false.
+ *
+ */
+Ext.define('Ext.form.field.Spinner', {
+ extend: 'Ext.form.field.Trigger',
+ alias: 'widget.spinnerfield',
+ alternateClassName: 'Ext.form.Spinner',
+ requires: ['Ext.util.KeyNav'],
+
+ trigger1Cls: Ext.baseCSSPrefix + 'form-spinner-up',
+ trigger2Cls: Ext.baseCSSPrefix + 'form-spinner-down',
+
/**
- * @method findById
- * @hide
+ * @cfg {Boolean} spinUpEnabled
+ * Specifies whether the up spinner button is enabled. Defaults to true. To change this
+ * after the component is created, use the {@link #setSpinUpEnabled} method.
*/
+ spinUpEnabled: true,
+
/**
- * @method findByType
- * @hide
+ * @cfg {Boolean} spinDownEnabled
+ * Specifies whether the down spinner button is enabled. Defaults to true. To change this
+ * after the component is created, use the {@link #setSpinDownEnabled} method.
*/
+ spinDownEnabled: true,
+
/**
- * @method getComponent
- * @hide
+ * @cfg {Boolean} keyNavEnabled
+ * Specifies whether the up and down arrow keys should trigger spinning up and down.
+ * Defaults to true.
*/
+ keyNavEnabled: true,
+
/**
- * @method getLayout
- * @hide
+ * @cfg {Boolean} mouseWheelEnabled
+ * Specifies whether the mouse wheel should trigger spinning up and down while the field has
+ * focus. Defaults to true.
*/
+ mouseWheelEnabled: true,
+
/**
- * @method getUpdater
- * @hide
+ * @cfg {Boolean} repeatTriggerClick Whether a {@link Ext.util.ClickRepeater click repeater} should be
+ * attached to the spinner buttons. Defaults to true.
*/
+ repeatTriggerClick: true,
+
/**
- * @method insert
- * @hide
+ * This method is called when the spinner up button is clicked, or when the up arrow key is pressed
+ * if {@link #keyNavEnabled} is true. Must be implemented by subclasses.
*/
+ onSpinUp: Ext.emptyFn,
+
/**
- * @method load
- * @hide
+ * This method is called when the spinner down button is clicked, or when the down arrow key is pressed
+ * if {@link #keyNavEnabled} is true. Must be implemented by subclasses.
*/
+ onSpinDown: Ext.emptyFn,
+
+ initComponent: function() {
+ this.callParent();
+
+ this.addEvents(
+ /**
+ * @event spin
+ * Fires when the spinner is made to spin up or down.
+ * @param {Ext.form.field.Spinner} this
+ * @param {String} direction Either 'up' if spinning up, or 'down' if spinning down.
+ */
+ 'spin',
+
+ /**
+ * @event spinup
+ * Fires when the spinner is made to spin up.
+ * @param {Ext.form.field.Spinner} this
+ */
+ 'spinup',
+
+ /**
+ * @event spindown
+ * Fires when the spinner is made to spin down.
+ * @param {Ext.form.field.Spinner} this
+ */
+ 'spindown'
+ );
+ },
+
/**
- * @method remove
- * @hide
+ * @private override
*/
+ onRender: function() {
+ var me = this,
+ triggers;
+
+ me.callParent(arguments);
+ triggers = me.triggerEl;
+
+ /**
+ * @property spinUpEl
+ * @type Ext.core.Element
+ * The spinner up button element
+ */
+ me.spinUpEl = triggers.item(0);
+ /**
+ * @property spinDownEl
+ * @type Ext.core.Element
+ * The spinner down button element
+ */
+ me.spinDownEl = triggers.item(1);
+
+ // Set initial enabled/disabled states
+ me.setSpinUpEnabled(me.spinUpEnabled);
+ me.setSpinDownEnabled(me.spinDownEnabled);
+
+ // Init up/down arrow keys
+ if (me.keyNavEnabled) {
+ me.spinnerKeyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
+ scope: me,
+ up: me.spinUp,
+ down: me.spinDown
+ });
+ }
+
+ // Init mouse wheel
+ if (me.mouseWheelEnabled) {
+ me.mon(me.bodyEl, 'mousewheel', me.onMouseWheel, me);
+ }
+ },
+
/**
- * @event add
- * @hide
+ * @private override
+ * Since the triggers are stacked, only measure the width of one of them.
*/
+ getTriggerWidth: function() {
+ return this.hideTrigger || this.readOnly ? 0 : this.spinUpEl.getWidth() + this.triggerWrap.getFrameWidth('lr');
+ },
+
/**
- * @method removeAll
- * @hide
+ * @private Handles the spinner up button clicks.
*/
+ onTrigger1Click: function() {
+ this.spinUp();
+ },
+
/**
- * @event afterLayout
- * @hide
+ * @private Handles the spinner down button clicks.
*/
+ onTrigger2Click: function() {
+ this.spinDown();
+ },
+
/**
- * @event beforeadd
- * @hide
+ * Triggers the spinner to step up; fires the {@link #spin} and {@link #spinup} events and calls the
+ * {@link #onSpinUp} method. Does nothing if the field is {@link #disabled} or if {@link #spinUpEnabled}
+ * is false.
*/
+ spinUp: function() {
+ var me = this;
+ if (me.spinUpEnabled && !me.disabled) {
+ me.fireEvent('spin', me, 'up');
+ me.fireEvent('spinup', me);
+ me.onSpinUp();
+ }
+ },
+
/**
- * @event beforeremove
- * @hide
+ * Triggers the spinner to step down; fires the {@link #spin} and {@link #spindown} events and calls the
+ * {@link #onSpinDown} method. Does nothing if the field is {@link #disabled} or if {@link #spinDownEnabled}
+ * is false.
*/
+ spinDown: function() {
+ var me = this;
+ if (me.spinDownEnabled && !me.disabled) {
+ me.fireEvent('spin', me, 'down');
+ me.fireEvent('spindown', me);
+ me.onSpinDown();
+ }
+ },
+
/**
- * @event remove
- * @hide
+ * Sets whether the spinner up button is enabled.
+ * @param {Boolean} enabled true to enable the button, false to disable it.
*/
-
-
+ setSpinUpEnabled: function(enabled) {
+ var me = this,
+ wasEnabled = me.spinUpEnabled;
+ me.spinUpEnabled = enabled;
+ if (wasEnabled !== enabled && me.rendered) {
+ me.spinUpEl[enabled ? 'removeCls' : 'addCls'](me.trigger1Cls + '-disabled');
+ }
+ },
/**
- * @cfg {String} allowDomMove @hide
+ * Sets whether the spinner down button is enabled.
+ * @param {Boolean} enabled true to enable the button, false to disable it.
*/
+ setSpinDownEnabled: function(enabled) {
+ var me = this,
+ wasEnabled = me.spinDownEnabled;
+ me.spinDownEnabled = enabled;
+ if (wasEnabled !== enabled && me.rendered) {
+ me.spinDownEl[enabled ? 'removeCls' : 'addCls'](me.trigger2Cls + '-disabled');
+ }
+ },
+
/**
- * @cfg {String} autoEl @hide
+ * @private
+ * Handles mousewheel events on the field
*/
+ onMouseWheel: function(e) {
+ var me = this,
+ delta;
+ if (me.hasFocus) {
+ delta = e.getWheelDelta();
+ if (delta > 0) {
+ me.spinUp();
+ }
+ else if (delta < 0) {
+ me.spinDown();
+ }
+ e.stopEvent();
+ }
+ },
+
+ onDestroy: function() {
+ Ext.destroyMembers(this, 'spinnerKeyNav', 'spinUpEl', 'spinDownEl');
+ this.callParent();
+ }
+
+});
+/**
+ * @class Ext.form.field.Number
+ * @extends Ext.form.field.Spinner
+
+A numeric text field that provides automatic keystroke filtering to disallow non-numeric characters,
+and numeric validation to limit the value to a range of valid numbers. The range of acceptable number
+values can be controlled by setting the {@link #minValue} and {@link #maxValue} configs, and fractional
+decimals can be disallowed by setting {@link #allowDecimals} to `false`.
+
+By default, the number field is also rendered with a set of up/down spinner buttons and has
+up/down arrow key and mouse wheel event listeners attached for incrementing/decrementing the value by the
+{@link #step} value. To hide the spinner buttons set `{@link #hideTrigger hideTrigger}:true`; to disable the arrow key
+and mouse wheel handlers set `{@link #keyNavEnabled keyNavEnabled}:false` and
+`{@link #mouseWheelEnabled mouseWheelEnabled}:false`. See the example below.
+
+#Example usage:#
+{@img Ext.form.Number/Ext.form.Number1.png Ext.form.Number component}
+ Ext.create('Ext.form.Panel', {
+ title: 'On The Wall',
+ width: 300,
+ bodyPadding: 10,
+ renderTo: Ext.getBody(),
+ items: [{
+ xtype: 'numberfield',
+ anchor: '100%',
+ name: 'bottles',
+ fieldLabel: 'Bottles of Beer',
+ value: 99,
+ maxValue: 99,
+ minValue: 0
+ }],
+ buttons: [{
+ text: 'Take one down, pass it around',
+ handler: function() {
+ this.up('form').down('[name=bottles]').spinDown();
+ }
+ }]
+ });
+
+#Removing UI Enhancements#
+{@img Ext.form.Number/Ext.form.Number2.png Ext.form.Number component}
+ Ext.create('Ext.form.Panel', {
+ title: 'Personal Info',
+ width: 300,
+ bodyPadding: 10,
+ renderTo: Ext.getBody(),
+ items: [{
+ xtype: 'numberfield',
+ anchor: '100%',
+ name: 'age',
+ fieldLabel: 'Age',
+ minValue: 0, //prevents negative numbers
+
+ // Remove spinner buttons, and arrow key and mouse wheel listeners
+ hideTrigger: true,
+ keyNavEnabled: false,
+ mouseWheelEnabled: false
+ }]
+ });
+
+#Using Step#
+ Ext.create('Ext.form.Panel', {
+ renderTo: Ext.getBody(),
+ title: 'Step',
+ width: 300,
+ bodyPadding: 10,
+ items: [{
+ xtype: 'numberfield',
+ anchor: '100%',
+ name: 'evens',
+ fieldLabel: 'Even Numbers',
+
+ // Set step so it skips every other number
+ step: 2,
+ value: 0,
+
+ // Add change handler to force user-entered numbers to evens
+ listeners: {
+ change: function(field, value) {
+ value = parseInt(value, 10);
+ field.setValue(value + value % 2);
+ }
+ }
+ }]
+ });
+
+
+ *
+ * @markdown
+ * @docauthor Jason Johnston
+ */
+Ext.define('Ext.form.field.Number', {
+ extend:'Ext.form.field.Spinner',
+ alias: 'widget.numberfield',
+ alternateClassName: ['Ext.form.NumberField', 'Ext.form.Number'],
+
/**
- * @cfg {String} applyTo @hide
+ * @cfg {RegExp} stripCharsRe @hide
*/
/**
- * @cfg {String} contentEl @hide
+ * @cfg {RegExp} maskRe @hide
*/
+
/**
- * @cfg {Mixed} data @hide
+ * @cfg {Boolean} allowDecimals False to disallow decimal values (defaults to true)
*/
+ allowDecimals : true,
+
/**
- * @cfg {Mixed} tpl @hide
+ * @cfg {String} decimalSeparator Character(s) to allow as the decimal separator (defaults to '.')
*/
+ decimalSeparator : '.',
+
/**
- * @cfg {String} tplWriteMode @hide
+ * @cfg {Number} decimalPrecision The maximum precision to display after the decimal separator (defaults to 2)
*/
+ decimalPrecision : 2,
+
/**
- * @cfg {String} disabledClass @hide
+ * @cfg {Number} minValue The minimum allowed value (defaults to Number.NEGATIVE_INFINITY). Will be used by
+ * the field's validation logic, and for
+ * {@link Ext.form.field.Spinner#setSpinUpEnabled enabling/disabling the down spinner button}.
*/
+ minValue: Number.NEGATIVE_INFINITY,
+
/**
- * @cfg {String} elements @hide
+ * @cfg {Number} maxValue The maximum allowed value (defaults to Number.MAX_VALUE). Will be used by
+ * the field's validation logic, and for
+ * {@link Ext.form.field.Spinner#setSpinUpEnabled enabling/disabling the up spinner button}.
*/
+ maxValue: Number.MAX_VALUE,
+
/**
- * @cfg {String} html @hide
+ * @cfg {Number} step Specifies a numeric interval by which the field's value will be incremented or
+ * decremented when the user invokes the spinner. Defaults to 1.
*/
+ step: 1,
+
/**
- * @cfg {Boolean} preventBodyReset
- * @hide
+ * @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}',
+
/**
- * @property disabled
- * @hide
+ * @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}',
+
/**
- * @method applyToMarkup
- * @hide
+ * @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',
+
/**
- * @method enable
- * @hide
+ * @cfg {String} negativeText Error text to display if the value is negative and {@link #minValue} is set to
+ * 0. This is used instead of the {@link #minText} in that circumstance only.
*/
+ negativeText : 'The value cannot be negative',
+
/**
- * @method disable
- * @hide
+ * @cfg {String} baseChars The base set of characters to evaluate as valid numbers (defaults to '0123456789').
*/
+ baseChars : '0123456789',
+
/**
- * @method setDisabled
- * @hide
+ * @cfg {Boolean} autoStripChars True to automatically strip not allowed characters from the field. Defaults to false
*/
-});
-
-Ext.tree.TreePanel.nodeTypes = {};
+ autoStripChars: false,
-Ext.reg('treepanel', Ext.tree.TreePanel);Ext.tree.TreeEventModel = function(tree){
- this.tree = tree;
- this.tree.on('render', this.initEvents, this);
-};
+ initComponent: function() {
+ var me = this,
+ allowed;
-Ext.tree.TreeEventModel.prototype = {
- initEvents : function(){
- var t = this.tree;
+ me.callParent();
- 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
- });
- },
+ me.setMinValue(me.minValue);
+ me.setMaxValue(me.maxValue);
- 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);
+ // Build regexes for masking and stripping based on the configured options
+ if (me.disableKeyFilter !== true) {
+ allowed = me.baseChars + '';
+ if (me.allowDecimals) {
+ allowed += me.decimalSeparator;
}
- }
- 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 (me.minValue < 0) {
+ allowed += '-';
+ }
+ allowed = Ext.String.escapeRegex(allowed);
+ me.maskRe = new RegExp('[' + allowed + ']');
+ if (me.autoStripChars) {
+ me.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
}
- }
- 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));
- }
- },
+ /**
+ * Runs all of Number's validations and returns an array of any errors. Note that this first
+ * runs Text'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 me = this,
+ errors = me.callParent(arguments),
+ format = Ext.String.format,
+ num;
- 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;
+ value = Ext.isDefined(value) ? value : this.processRawValue(this.getRawValue());
+
+ if (value.length < 1) { // if it's blank and textfield didn't flag it then it's valid
+ return errors;
}
- },
+ value = String(value).replace(me.decimalSeparator, '.');
- 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');
+ if(isNaN(value)){
+ errors.push(format(me.nanText, value));
}
- },
- delegateDblClick : function(e, t){
- if(this.beforeEvent(e)){
- if(this.getNodeTarget(e)){
- this.onNodeDblClick(e, this.getNode(e));
- }
- }else{
- this.checkContainerEvent(e, 'dblclick');
+ num = me.parseValue(value);
+
+ if (me.minValue === 0 && num < 0) {
+ errors.push(this.negativeText);
+ }
+ else if (num < me.minValue) {
+ errors.push(format(me.minText, me.minValue));
}
- },
- delegateContextMenu : function(e, t){
- if(this.beforeEvent(e)){
- if(this.getNodeTarget(e)){
- this.onNodeContextMenu(e, this.getNode(e));
- }
- }else{
- this.checkContainerEvent(e, 'contextmenu');
+ if (num > me.maxValue) {
+ errors.push(format(me.maxText, me.maxValue));
}
+
+
+ return errors;
},
-
- checkContainerEvent: function(e, type){
- if(this.disabled){
- e.stopEvent();
- return false;
+
+ rawToValue: function(rawValue) {
+ var value = this.fixPrecision(this.parseValue(rawValue));
+ if (value === null) {
+ value = rawValue || null;
}
- this.onContainerEvent(e, type);
+ return value;
},
- onContainerEvent: function(e, type){
- this.tree.fireEvent('container' + type, this.tree, e);
+ valueToRaw: function(value) {
+ var me = this,
+ decimalSeparator = me.decimalSeparator;
+ value = me.parseValue(value);
+ value = me.fixPrecision(value);
+ value = Ext.isNumber(value) ? value : parseFloat(String(value).replace(decimalSeparator, '.'));
+ value = isNaN(value) ? '' : String(value).replace('.', decimalSeparator);
+ return value;
},
- onNodeClick : function(e, node){
- node.ui.onClick(e);
- },
+ onChange: function() {
+ var me = this,
+ value = me.getValue(),
+ valueIsNull = value === null;
- onNodeOver : function(e, node){
- this.lastOverNode = node;
- node.ui.onOver(e);
- },
+ me.callParent(arguments);
- onNodeOut : function(e, node){
- node.ui.onOut(e);
+ // Update the spinner buttons
+ me.setSpinUpEnabled(valueIsNull || value < me.maxValue);
+ me.setSpinDownEnabled(valueIsNull || value > me.minValue);
},
- onIconOver : function(e, node){
- node.ui.addClass('x-tree-ec-over');
+ /**
+ * Replaces any existing {@link #minValue} with the new value.
+ * @param {Number} value The minimum value
+ */
+ setMinValue : function(value) {
+ this.minValue = Ext.Number.from(value, Number.NEGATIVE_INFINITY);
},
- onIconOut : function(e, node){
- node.ui.removeClass('x-tree-ec-over');
+ /**
+ * Replaces any existing {@link #maxValue} with the new value.
+ * @param {Number} value The maximum value
+ */
+ setMaxValue: function(value) {
+ this.maxValue = Ext.Number.from(value, Number.MAX_VALUE);
},
- onIconClick : function(e, node){
- node.ui.ecClick(e);
+ // private
+ parseValue : function(value) {
+ value = parseFloat(String(value).replace(this.decimalSeparator, '.'));
+ return isNaN(value) ? null : value;
},
- onCheckboxClick : function(e, node){
- node.ui.onCheckChange(e);
- },
+ /**
+ * @private
+ *
+ */
+ fixPrecision : function(value) {
+ var me = this,
+ nan = isNaN(value),
+ precision = me.decimalPrecision;
- onNodeDblClick : function(e, node){
- node.ui.onDblClick(e);
- },
+ if (nan || !value) {
+ return nan ? '' : value;
+ } else if (!me.allowDecimals || precision <= 0) {
+ precision = 0;
+ }
- onNodeContextMenu : function(e, node){
- node.ui.onContextMenu(e);
+ return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
},
- beforeEvent : function(e){
- var node = this.getNode(e);
- if(this.disabled || !node || !node.ui){
- e.stopEvent();
- return false;
+ beforeBlur : function() {
+ var me = this,
+ v = me.parseValue(me.getRawValue());
+
+ if (!Ext.isEmpty(v)) {
+ me.setValue(v);
}
- return true;
},
- disable: function(){
- this.disabled = true;
+ onSpinUp: function() {
+ var me = this;
+ if (!me.readOnly) {
+ me.setValue(Ext.Number.constrain(me.getValue() + me.step, me.minValue, me.maxValue));
+ }
},
- enable: function(){
- this.disabled = false;
+ onSpinDown: function() {
+ var me = this;
+ if (!me.readOnly) {
+ me.setValue(Ext.Number.constrain(me.getValue() - me.step, me.minValue, me.maxValue));
+ }
}
-};/**
- * @class Ext.tree.DefaultSelectionModel
- * @extends Ext.util.Observable
- * The default single selection for a TreePanel.
- */
-Ext.tree.DefaultSelectionModel = Ext.extend(Ext.util.Observable, {
-
- constructor : 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);
- },
-
- 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);
- },
-
+/**
+ * @class Ext.toolbar.Paging
+ * @extends Ext.toolbar.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
+ * appropriate data.
+ *
Ext.toolbar.Paging 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.
+ */
+Ext.define('Ext.toolbar.Paging', {
+ extend: 'Ext.toolbar.Toolbar',
+ alias: 'widget.pagingtoolbar',
+ alternateClassName: 'Ext.PagingToolbar',
+ requires: ['Ext.toolbar.TextItem', 'Ext.form.field.Number'],
/**
- * Select a node.
- * @param {TreeNode} node The node to select
- * @return {TreeNode} The selected node
+ * @cfg {Ext.data.Store} store
+ * The {@link Ext.data.Store} the paging toolbar should use as its data source (required).
*/
- 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.
+ * @cfg {Boolean} displayInfo
+ * true to display the displayMsg (defaults to false)
*/
- unselect : function(node, silent){
- if(this.selNode == node){
- this.clearSelections(silent);
- }
- },
-
+ displayInfo: false,
/**
- * Clear all selections
- * @param {Boolean} silent True to stop the selectionchange event from firing.
+ * @cfg {Boolean} prependButtons
+ * true to insert any configured itemsbefore the paging buttons.
+ * Defaults to false.
*/
- 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;
- },
-
+ prependButtons: false,
/**
- * Get the selected node
- * @return {TreeNode} The selected node
+ * @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.
*/
- getSelectedNode : function(){
- return this.selNode;
- },
-
+ displayMsg : 'Displaying {0} - {1} of {2}',
/**
- * Returns true if the node is selected
- * @param {TreeNode} node The node to check
- * @return {Boolean}
+ * @cfg {String} emptyMsg
+ * The message to display when no records are found (defaults to 'No data to display')
*/
- isSelected : function(node){
- return this.selNode == node;
- },
-
+ emptyMsg : 'No data to display',
/**
- * Selects the node above the selected node in the tree, intelligently walking the nodes
- * @return TreeNode The new selection
+ * @cfg {String} beforePageText
+ * The text displayed before the input item (defaults to 'Page').
*/
- 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;
- },
-
+ beforePageText : 'Page',
/**
- * Selects the node above the selected node in the tree, intelligently walking the nodes
- * @return TreeNode The new selection
+ * @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.
*/
- 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 = Ext.extend(Ext.util.Observable, {
-
- constructor : 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);
- },
-
- 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);
- }
- },
-
+ afterPageText : 'of {0}',
/**
- * 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
+ * @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.
*/
- 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;
- },
-
+ firstText : 'First Page',
/**
- * Deselect a node.
- * @param {TreeNode} node The node to unselect
+ * @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.
*/
- 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);
- }
- },
-
+ prevText : 'Previous Page',
/**
- * Clear all selections
+ * @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.
*/
- 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);
- }
- }
- },
-
+ nextText : 'Next Page',
/**
- * Returns true if the node is selected
- * @param {TreeNode} node The node to check
- * @return {Boolean}
+ * @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.
*/
- isSelected : function(node){
- return this.selMap[node.id] ? true : false;
- },
+ lastText : 'Last Page',
+ /**
+ * @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.
+ */
+ refreshText : 'Refresh',
+ /**
+ * @cfg {Number} inputItemWidth
+ * The width in pixels of the input field used to display and change the current page number (defaults to 30).
+ */
+ inputItemWidth : 30,
/**
- * Returns an array of the selected nodes
- * @return {Array}
+ * Gets the standard paging items in the toolbar
+ * @private
*/
- getSelectedNodes : function(){
- return this.selNodes.concat([]);
+ getPagingItems: function() {
+ var me = this;
+
+ return [{
+ itemId: 'first',
+ tooltip: me.firstText,
+ overflowText: me.firstText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-first',
+ disabled: true,
+ handler: me.moveFirst,
+ scope: me
+ },{
+ itemId: 'prev',
+ tooltip: me.prevText,
+ overflowText: me.prevText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-prev',
+ disabled: true,
+ handler: me.movePrevious,
+ scope: me
+ },
+ '-',
+ me.beforePageText,
+ {
+ xtype: 'numberfield',
+ itemId: 'inputItem',
+ name: 'inputItem',
+ cls: Ext.baseCSSPrefix + 'tbar-page-number',
+ allowDecimals: false,
+ minValue: 1,
+ hideTrigger: true,
+ enableKeyEvents: true,
+ selectOnFocus: true,
+ submitValue: false,
+ width: me.inputItemWidth,
+ margins: '-1 2 3 2',
+ listeners: {
+ scope: me,
+ keydown: me.onPagingKeyDown,
+ blur: me.onPagingBlur
+ }
+ },{
+ xtype: 'tbtext',
+ itemId: 'afterTextItem',
+ text: Ext.String.format(me.afterPageText, 1)
+ },
+ '-',
+ {
+ itemId: 'next',
+ tooltip: me.nextText,
+ overflowText: me.nextText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-next',
+ disabled: true,
+ handler: me.moveNext,
+ scope: me
+ },{
+ itemId: 'last',
+ tooltip: me.lastText,
+ overflowText: me.lastText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-page-last',
+ disabled: true,
+ handler: me.moveLast,
+ scope: me
+ },
+ '-',
+ {
+ itemId: 'refresh',
+ tooltip: me.refreshText,
+ overflowText: me.refreshText,
+ iconCls: Ext.baseCSSPrefix + 'tbar-loading',
+ handler: me.doRefresh,
+ scope: me
+ }];
},
- 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 = Ext.extend(Ext.util.Observable, {
-
- constructor: function(root){
- this.nodeHash = {};
- /**
- * The root node for this tree
- * @type Node
- */
- this.root = null;
- if(root){
- this.setRootNode(root);
+ initComponent : function(){
+ var me = this,
+ pagingItems = me.getPagingItems(),
+ userItems = me.items || me.buttons || [];
+
+ if (me.prependButtons) {
+ me.items = userItems.concat(pagingItems);
+ } else {
+ me.items = pagingItems.concat(userItems);
}
- 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",
+ delete me.buttons;
+
+ if (me.displayInfo) {
+ me.items.push('->');
+ me.items.push({xtype: 'tbtext', itemId: 'displayItem'});
+ }
+
+ me.callParent();
+
+ me.addEvents(
/**
- * @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
+ * @event change
+ * Fires after the active page has been changed.
+ * @param {Ext.toolbar.Paging} 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
+ *
currentPage : Number
The current page number
+ *
pageCount : 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})
+ *
toRecord : Number
The starting record index for the current page
+ *
fromRecord : Number
The ending record index for the current page
+ *
*/
- "beforemove",
+ 'change',
/**
- * @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
+ * @event beforechange
+ * Fires just before the active page is changed.
+ * Return false to prevent the active page from being changed.
+ * @param {Ext.toolbar.Paging} this
+ * @param {Number} page The page number that will be loaded on change
*/
- "beforeinsert"
+ 'beforechange'
);
- Ext.data.Tree.superclass.constructor.call(this);
- },
-
- /**
- * @cfg {String} pathSeparator
- * The token used to separate paths in node ids (defaults to '/').
- */
- pathSeparator: "/",
+ me.on('afterlayout', me.onLoad, me, {single: true});
+ me.bindStore(me.store, true);
+ },
// private
- proxyNodeEvent : function(){
- return this.fireEvent.apply(this, arguments);
+ updateInfo : function(){
+ var me = this,
+ displayItem = me.child('#displayItem'),
+ store = me.store,
+ pageData = me.getPageData(),
+ count, msg;
+
+ if (displayItem) {
+ count = store.getCount();
+ if (count === 0) {
+ msg = me.emptyMsg;
+ } else {
+ msg = Ext.String.format(
+ me.displayMsg,
+ pageData.fromRecord,
+ pageData.toRecord,
+ pageData.total
+ );
+ }
+ displayItem.setText(msg);
+ me.doComponentLayout();
+ }
},
- /**
- * Returns the root node for this tree.
- * @return {Node}
- */
- getRootNode : function(){
- return this.root;
- },
+ // private
+ onLoad : function(){
+ var me = this,
+ pageData,
+ currPage,
+ pageCount,
+ afterText;
+
+ if (!me.rendered) {
+ return;
+ }
- /**
- * 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;
- },
+ pageData = me.getPageData();
+ currPage = pageData.currentPage;
+ pageCount = pageData.pageCount;
+ afterText = Ext.String.format(me.afterPageText, isNaN(pageCount) ? 1 : pageCount);
- /**
- * Gets a node in this tree by its id.
- * @param {String} id
- * @return {Node}
- */
- getNodeById : function(id){
- return this.nodeHash[id];
+ me.child('#afterTextItem').setText(afterText);
+ me.child('#inputItem').setValue(currPage);
+ me.child('#first').setDisabled(currPage === 1);
+ me.child('#prev').setDisabled(currPage === 1);
+ me.child('#next').setDisabled(currPage === pageCount);
+ me.child('#last').setDisabled(currPage === pageCount);
+ me.child('#refresh').enable();
+ me.updateInfo();
+ me.fireEvent('change', me, pageData);
},
// private
- registerNode : function(node){
- this.nodeHash[node.id] = node;
+ getPageData : function(){
+ var store = this.store,
+ totalCount = store.getTotalCount();
+
+ return {
+ total : totalCount,
+ currentPage : store.currentPage,
+ pageCount: Math.ceil(totalCount / store.pageSize),
+ fromRecord: ((store.currentPage - 1) * store.pageSize) + 1,
+ toRecord: Math.min(store.currentPage * store.pageSize, totalCount)
+
+ };
},
// private
- unregisterNode : function(node){
- delete this.nodeHash[node.id];
+ onLoadError : function(){
+ if (!this.rendered) {
+ return;
+ }
+ this.child('#refresh').enable();
},
- 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 = Ext.extend(Ext.util.Observable, {
-
- constructor: 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;
+ // private
+ readPageFromInput : function(pageData){
+ var v = this.child('#inputItem').getValue(),
+ pageNum = parseInt(v, 10);
+
+ if (!v || isNaN(pageNum)) {
+ this.child('#inputItem').setValue(pageData.currentPage);
+ return false;
}
- /**
- * All child nodes of this node. @type Array
- */
- this.childNodes = [];
- /**
- * 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;
+ return pageNum;
+ },
- 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);
+ onPagingFocus : function(){
+ this.child('#inputItem').select();
},
-
+
+ //private
+ onPagingBlur : function(e){
+ var curPage = this.getPageData().currentPage;
+ this.child('#inputItem').setValue(curPage);
+ },
+
// 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;
+ onPagingKeyDown : function(field, e){
+ var me = this,
+ k = e.getKey(),
+ pageData = me.getPageData(),
+ increment = e.shiftKey ? 10 : 1,
+ pageNum;
+
+ if (k == e.RETURN) {
+ e.stopEvent();
+ pageNum = me.readPageFromInput(pageData);
+ if (pageNum !== false) {
+ pageNum = Math.min(Math.max(1, pageNum), pageData.pageCount);
+ if(me.fireEvent('beforechange', me, pageNum) !== false){
+ me.store.loadPage(pageNum);
+ }
+ }
+ } else if (k == e.HOME || k == e.END) {
+ e.stopEvent();
+ pageNum = k == e.HOME ? 1 : pageData.pageCount;
+ field.setValue(pageNum);
+ } else if (k == e.UP || k == e.PAGEUP || k == e.DOWN || k == e.PAGEDOWN) {
+ e.stopEvent();
+ pageNum = me.readPageFromInput(pageData);
+ if (pageNum) {
+ if (k == e.DOWN || k == e.PAGEDOWN) {
+ increment *= -1;
+ }
+ pageNum += increment;
+ if (pageNum >= 1 && pageNum <= pageData.pages) {
+ field.setValue(pageNum);
+ }
}
}
- return true;
},
- /**
- * Returns true if this node is a leaf
- * @return {Boolean}
- */
- isLeaf : function(){
- return this.leaf === true;
+ // private
+ beforeLoad : function(){
+ if(this.rendered && this.refresh){
+ this.refresh.disable();
+ }
},
// private
- setFirstChild : function(node){
- this.firstChild = node;
+ doLoad : function(start){
+ if(this.fireEvent('beforechange', this, o) !== false){
+ this.store.load();
+ }
},
- //private
- setLastChild : function(node){
- this.lastChild = node;
+ /**
+ * Move to the first page, has the same effect as clicking the 'first' button.
+ */
+ moveFirst : function(){
+ if (this.fireEvent('beforechange', this, 1) !== false){
+ this.store.loadPage(1);
+ }
},
-
/**
- * Returns true if this node is the last child of its parent
- * @return {Boolean}
+ * Move to the previous page, has the same effect as clicking the 'previous' button.
*/
- isLast : function(){
- return (!this.parentNode ? true : this.parentNode.lastChild == this);
+ movePrevious : function(){
+ var me = this,
+ prev = me.store.currentPage - 1;
+
+ if (prev > 0) {
+ if (me.fireEvent('beforechange', me, prev) !== false) {
+ me.store.previousPage();
+ }
+ }
},
/**
- * Returns true if this node is the first child of its parent
- * @return {Boolean}
+ * Move to the next page, has the same effect as clicking the 'next' button.
*/
- isFirst : function(){
- return (!this.parentNode ? true : this.parentNode.firstChild == this);
+ moveNext : function(){
+ var me = this,
+ total = me.getPageData().pageCount,
+ next = me.store.currentPage + 1;
+
+ if (next <= total) {
+ if (me.fireEvent('beforechange', me, next) !== false) {
+ me.store.nextPage();
+ }
+ }
},
/**
- * Returns true if this node has one or more child nodes, else false.
- * @return {Boolean}
+ * Move to the last page, has the same effect as clicking the 'last' button.
*/
- hasChildNodes : function(){
- return !this.isLeaf() && this.childNodes.length > 0;
+ moveLast : function(){
+ var me = this,
+ last = me.getPageData().pageCount;
+
+ if (me.fireEvent('beforechange', me, last) !== false) {
+ me.store.loadPage(last);
+ }
},
/**
- * 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}
+ * Refresh the current page, has the same effect as clicking the 'refresh' button.
*/
- isExpandable : function(){
- return this.attributes.expandable || this.hasChildNodes();
+ doRefresh : function(){
+ var me = this,
+ current = me.store.currentPage;
+
+ if (me.fireEvent('beforechange', me, current) !== false) {
+ me.store.loadPage(current);
+ }
},
/**
- * 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
+ * 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
*/
- 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;
+ bindStore : function(store, initial){
+ var me = this;
+
+ if (!initial && me.store) {
+ if(store !== me.store && me.store.autoDestroy){
+ me.store.destroy();
}else{
- node.previousSibling = null;
+ me.store.un('beforeload', me.beforeLoad, me);
+ me.store.un('load', me.onLoad, me);
+ me.store.un('exception', me.onLoadError, me);
}
- 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);
+ if(!store){
+ me.store = null;
}
- return node;
}
+ if (store) {
+ store = Ext.data.StoreManager.lookup(store);
+ store.on({
+ scope: me,
+ beforeload: me.beforeLoad,
+ load: me.onLoad,
+ exception: me.onLoadError
+ });
+ }
+ me.store = store;
},
/**
- * 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
+ * Unbinds the paging toolbar from the specified {@link Ext.data.Store} (deprecated)
+ * @param {Ext.data.Store} store The data store to unbind
*/
- 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);
- }
+ unbind : function(store){
+ this.bindStore(null);
+ },
- this.fireEvent("remove", this.ownerTree, this, node);
- if(destroy){
- node.destroy(true);
- }else{
- node.clear();
- }
- return node;
+ /**
+ * 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
- 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;
- }
- },
+ onDestroy : function(){
+ this.bindStore(null);
+ this.callParent();
+ }
+});
+
+/**
+ * @class Ext.view.BoundList
+ * @extends Ext.view.View
+ * An internal used DataView for ComboBox, MultiSelect and ItemSelector.
+ */
+Ext.define('Ext.view.BoundList', {
+ extend: 'Ext.view.View',
+ alias: 'widget.boundlist',
+ alternateClassName: 'Ext.BoundList',
+ requires: ['Ext.layout.component.BoundList', 'Ext.toolbar.Paging'],
/**
- * Destroys the node.
+ * @cfg {Number} pageSize If greater than 0, a {@link Ext.toolbar.Paging} is displayed at the
+ * bottom of the list and store queries will execute with page start and
+ * {@link Ext.toolbar.Paging#pageSize limit} parameters.
*/
- 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);
- }
- },
+ pageSize: 0,
/**
- * 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
+ * @property pagingToolbar
+ * @type {Ext.toolbar.Paging}
+ * A reference to the PagingToolbar instance in this view. Only populated if {@link #pageSize} is greater
+ * than zero and the BoundList has been rendered.
*/
- 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;
+ // private overrides
+ autoScroll: true,
+ baseCls: Ext.baseCSSPrefix + 'boundlist',
+ listItemCls: '',
+ shadow: false,
+ trackOver: true,
+ refreshed: 0,
- // when moving internally, indexes will change after remove
- if(oldParent == this && this.childNodes.indexOf(node) < index){
- refIndex--;
- }
+ ariaRole: 'listbox',
- // 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;
+ componentLayout: 'boundlist',
+
+ renderTpl: [''],
+
+ initComponent: function() {
+ var me = this,
+ baseCls = me.baseCls,
+ itemCls = baseCls + '-item';
+ me.itemCls = itemCls;
+ me.selectedItemCls = baseCls + '-selected';
+ me.overItemCls = baseCls + '-item-over';
+ me.itemSelector = "." + itemCls;
+
+ if (me.floating) {
+ me.addCls(baseCls + '-floating');
+ }
+
+ if (!me.tpl) {
+ // should be setting aria-posinset based on entire set of data
+ // not filtered set
+ me.tpl = Ext.create('Ext.XTemplate',
+ '
',
+ '
' + me.getInnerTpl(me.displayField) + '
',
+ '
'
+ );
+ } else if (Ext.isString(me.tpl)) {
+ me.tpl = Ext.create('Ext.XTemplate', me.tpl);
}
- 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);
+
+ if (me.pageSize) {
+ me.pagingToolbar = me.createPagingToolbar();
}
- return node;
+
+ me.callParent();
+
+ Ext.applyIf(me.renderSelectors, {
+ listEl: '.list-ct'
+ });
},
- /**
- * 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;
+ createPagingToolbar: function() {
+ return Ext.widget('pagingtoolbar', {
+ pageSize: this.pageSize,
+ store: this.store,
+ border: false
+ });
},
- /**
- * 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);
+ onRender: function() {
+ var me = this,
+ toolbar = me.pagingToolbar;
+ me.callParent(arguments);
+ if (toolbar) {
+ toolbar.render(me.el);
}
- return this;
},
- /**
- * Returns the child node at the specified index.
- * @param {Number} index
- * @return {Node}
- */
- item : function(index){
- return this.childNodes[index];
+ bindStore : function(store, initial) {
+ var me = this,
+ toolbar = me.pagingToolbar;
+ me.callParent(arguments);
+ if (toolbar) {
+ toolbar.bindStore(store, initial);
+ }
},
- /**
- * 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;
+ getTargetEl: function() {
+ return this.listEl || this.el;
},
- /**
- * 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);
+ getInnerTpl: function(displayField) {
+ return '{' + displayField + '}';
},
- /**
- * 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;
- }
+ refresh: function() {
+ var me = this;
+ me.callParent();
+ if (me.isVisible()) {
+ me.refreshed++;
+ me.doComponentLayout();
+ me.refreshed--;
}
- 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;
- },
+ initAria: function() {
+ this.callParent();
- // 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);
- }
+ var selModel = this.getSelectionModel(),
+ mode = selModel.getSelectionMode(),
+ actionEl = this.getActionEl();
+
+ // TODO: subscribe to mode changes or allow the selModel to manipulate this attribute.
+ if (mode !== 'SINGLE') {
+ actionEl.dom.setAttribute('aria-multiselectable', true);
}
},
+ onDestroy: function() {
+ Ext.destroyMembers(this, 'pagingToolbar', 'listEl');
+ this.callParent();
+ }
+});
+
+/**
+ * @class Ext.view.BoundListKeyNav
+ * @extends Ext.util.KeyNav
+ * A specialized {@link Ext.util.KeyNav} implementation for navigating a {@link Ext.view.BoundList} using
+ * the keyboard. The up, down, pageup, pagedown, home, and end keys move the active highlight
+ * through the list. The enter key invokes the selection model's select action using the highlighted item.
+ */
+Ext.define('Ext.view.BoundListKeyNav', {
+ extend: 'Ext.util.KeyNav',
+ requires: 'Ext.view.BoundList',
+
/**
- * Changes the id of this node.
- * @param {String} id The new id for the node.
+ * @cfg {Ext.view.BoundList} boundList
+ * @required
+ * The {@link Ext.view.BoundList} instance for which key navigation will be managed. This is required.
*/
- 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);
- }
+
+ constructor: function(el, config) {
+ var me = this;
+ me.boundList = config.boundList;
+ me.callParent([el, Ext.apply({}, config, me.defaultHandlers)]);
},
- // private
- onIdChange: Ext.emptyFn,
+ defaultHandlers: {
+ up: function() {
+ var me = this,
+ boundList = me.boundList,
+ allItems = boundList.all,
+ oldItem = boundList.highlightedItem,
+ oldItemIdx = oldItem ? boundList.indexOf(oldItem) : -1,
+ newItemIdx = oldItemIdx > 0 ? oldItemIdx - 1 : allItems.getCount() - 1; //wraps around
+ me.highlightAt(newItemIdx);
+ },
- /**
- * 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;
+ down: function() {
+ var me = this,
+ boundList = me.boundList,
+ allItems = boundList.all,
+ oldItem = boundList.highlightedItem,
+ oldItemIdx = oldItem ? boundList.indexOf(oldItem) : -1,
+ newItemIdx = oldItemIdx < allItems.getCount() - 1 ? oldItemIdx + 1 : 0; //wraps around
+ me.highlightAt(newItemIdx);
+ },
+
+ pageup: function() {
+ //TODO
+ },
+
+ pagedown: function() {
+ //TODO
+ },
+
+ home: function() {
+ this.highlightAt(0);
+ },
+
+ end: function() {
+ var me = this;
+ me.highlightAt(me.boundList.all.getCount() - 1);
+ },
+
+ enter: function(e) {
+ this.selectHighlighted(e);
}
- 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)
+ * Highlights the item at the given index.
+ * @param {Number} index
*/
- bubble : function(fn, scope, args){
- var p = this;
- while(p){
- if(fn.apply(scope || p, args || [p]) === false){
- break;
- }
- p = p.parentNode;
+ highlightAt: function(index) {
+ var boundList = this.boundList,
+ item = boundList.all.item(index);
+ if (item) {
+ item = item.dom;
+ boundList.highlightItem(item);
+ boundList.getTargetEl().scrollChildIntoView(item, false);
}
},
/**
- * 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)
+ * Triggers selection of the currently highlighted item according to the behavior of
+ * the configured SelectionModel.
*/
- 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);
- }
+ selectHighlighted: function(e) {
+ var me = this,
+ boundList = me.boundList,
+ highlighted = boundList.highlightedItem,
+ selModel = boundList.getSelectionModel();
+ if (highlighted) {
+ selModel.selectWithEvent(boundList.getRecord(highlighted), e);
}
- },
+ }
+
+});
+/**
+ * @class Ext.form.field.ComboBox
+ * @extends Ext.form.field.Picker
+ *
+ * A combobox control with support for autocomplete, remote loading, and many other features.
+ *
+ * A ComboBox is like a combination of a traditional HTML text `` field and a `