Represents a filter that can be applied to a {@link Ext.util.MixedCollection MixedCollection}. Can either simply
* filter on a property/value pair or pass in a filter function with custom logic. Filters are always used in the context
* of MixedCollections, though {@link Ext.data.Store Store}s frequently create them when filtering and searching on their
* records. Example usage:
* In general this class will not be instanced directly, rather the {@link Ext.core.Element#load} method
* will be used.
*
*/
Ext.define('Ext.ElementLoader', {
/* Begin Definitions */
mixins: {
observable: 'Ext.util.Observable'
},
uses: [
'Ext.data.Connection',
'Ext.Ajax'
],
statics: {
Renderer: {
Html: function(loader, response, active){
loader.getTarget().update(response.responseText, active.scripts === true);
return true;
}
}
},
/* End Definitions */
/**
* @cfg {String} url The url to retrieve the content from. Defaults to Returns the element into which rendering must take place. Defaults to the owner Component's encapsulating element.
* May be overridden in Component layout managers which implement an inner element.
* @return {Ext.core.Element}
*/
getRenderTarget : function() {
return this.owner.el;
},
/**
* Set the size of the target element.
* @param {Mixed} width The new width to set.
* @param {Mixed} height The new height to set.
*/
setTargetSize : function(width, height) {
var me = this;
me.setElementSize(me.owner.el, width, height);
if (me.owner.frameBody) {
var targetInfo = me.getTargetInfo(),
padding = targetInfo.padding,
border = targetInfo.border,
frameSize = me.frameSize;
me.setElementSize(me.owner.frameBody,
Ext.isNumber(width) ? (width - frameSize.left - frameSize.right - padding.left - padding.right - border.left - border.right) : width,
Ext.isNumber(height) ? (height - frameSize.top - frameSize.bottom - padding.top - padding.bottom - border.top - border.bottom) : height
);
}
me.autoSized = {
width: !Ext.isNumber(width),
height: !Ext.isNumber(height)
};
me.lastComponentSize = {
width: width,
height: height
};
},
getTargetInfo : function() {
if (!this.targetInfo) {
var target = this.getTarget(),
body = this.owner.getTargetEl();
this.targetInfo = {
padding: {
top: target.getPadding('t'),
right: target.getPadding('r'),
bottom: target.getPadding('b'),
left: target.getPadding('l')
},
border: {
top: target.getBorderWidth('t'),
right: target.getBorderWidth('r'),
bottom: target.getBorderWidth('b'),
left: target.getBorderWidth('l')
},
bodyMargin: {
top: body.getMargin('t'),
right: body.getMargin('r'),
bottom: body.getMargin('b'),
left: body.getMargin('l')
}
};
}
return this.targetInfo;
},
// Start laying out UP the ownerCt's layout when flagged to do so.
doOwnerCtLayouts: function() {
var owner = this.owner,
ownerCt = owner.ownerCt,
ownerCtComponentLayout, ownerCtContainerLayout,
curSize = this.lastComponentSize,
prevSize = this.previousComponentSize,
widthChange = (prevSize && curSize && curSize.width) ? curSize.width !== prevSize.width : true,
heightChange = (prevSize && curSize && curSize.height) ? curSize.height !== prevSize.height : true;
// If size has not changed, do not inform upstream layouts
if (!ownerCt || (!widthChange && !heightChange)) {
return;
}
ownerCtComponentLayout = ownerCt.componentLayout;
ownerCtContainerLayout = ownerCt.layout;
if (!owner.floating && ownerCtComponentLayout && ownerCtComponentLayout.monitorChildren && !ownerCtComponentLayout.layoutBusy) {
if (!ownerCt.suspendLayout && ownerCtContainerLayout && !ownerCtContainerLayout.layoutBusy) {
// If the owning Container may be adjusted in any of the the dimension which have changed, perform its Component layout
if (((widthChange && !ownerCt.isFixedWidth()) || (heightChange && !ownerCt.isFixedHeight()))) {
// Set the isSizing flag so that the upstream Container layout (called after a Component layout) can omit this component from sizing operations
this.isSizing = true;
ownerCt.doComponentLayout();
this.isSizing = false;
}
// Execute upstream Container layout
else if (ownerCtContainerLayout.bindToOwnerCtContainer === true) {
ownerCtContainerLayout.layout();
}
}
}
},
doContainerLayout: function() {
var me = this,
owner = me.owner,
ownerCt = owner.ownerCt,
layout = owner.layout,
ownerCtComponentLayout;
// Run the container layout if it exists (layout for child items)
// **Unless automatic laying out is suspended, or the layout is currently running**
if (!owner.suspendLayout && layout && layout.isLayout && !layout.layoutBusy && !layout.isAutoDock) {
layout.layout();
}
// Tell the ownerCt that it's child has changed and can be re-layed by ignoring the lastComponentSize cache.
if (ownerCt && ownerCt.componentLayout) {
ownerCtComponentLayout = ownerCt.componentLayout;
if (!owner.floating && ownerCtComponentLayout.monitorChildren && !ownerCtComponentLayout.layoutBusy) {
ownerCtComponentLayout.childrenChanged = true;
}
}
},
afterLayout : function(width, height, isSetSize, layoutOwner) {
this.doContainerLayout();
this.owner.afterComponentLayout(width, height, isSetSize, layoutOwner);
}
});
/**
* @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:
*/
Ext.define('Ext.state.Manager', {
singleton: true,
requires: ['Ext.state.Provider'],
constructor: function() {
this.provider = Ext.create('Ext.state.Provider');
},
/**
* Configures the default state provider for your application
* @param {Provider} stateProvider The state provider to set
*/
setProvider : function(stateProvider){
this.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 this.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){
this.provider.set(key, value);
},
/**
* Clears a value from the state
* @param {String} name The key name
*/
clear : function(key){
this.provider.clear(key);
},
/**
* Gets the currently configured state provider
* @return {Provider} The state provider
*/
getProvider : function(){
return this.provider;
}
});
/**
* @class Ext.state.Stateful
* A mixin for being able to save the state of an object to an underlying
* {@link Ext.state.Provider}.
*/
Ext.define('Ext.state.Stateful', {
/* Begin Definitions */
mixins: {
observable: 'Ext.util.Observable'
},
requires: ['Ext.state.Manager'],
/* End Definitions */
/**
* @cfg {Boolean} stateful
* A flag which causes the object to attempt to restore the state of
* internal properties from a saved state on startup. The object must have
* a {@link #stateId} for state to be managed.
* Auto-generated ids are not guaranteed to be stable across page loads and
* cannot be relied upon to save and restore the same state for a object.
*
For state saving to work, the state manager's provider must have been
* set to an implementation of {@link Ext.state.Provider} which overrides the
* {@link Ext.state.Provider#set set} and {@link Ext.state.Provider#get get}
* methods to save and recall name/value pairs. A built-in implementation,
* {@link Ext.state.CookieProvider} is available.
* To set the state provider for the current page:
*
Ext.state.Manager.setProvider(new Ext.state.CookieProvider({
expires: new Date(new Date().getTime()+(1000*60*60*24*7)), //7 days from now
}));
* A stateful object attempts to save state when one of the events
* listed in the {@link #stateEvents} configuration fires.
* To save state, a stateful object first serializes its state by
* calling {@link #getState}
* The value yielded by getState is passed to {@link Ext.state.Manager#set}
* which uses the configured {@link Ext.state.Provider} to save the object
* keyed by the {@link #stateId}
.
* During construction, a stateful object attempts to restore
* its state by calling {@link Ext.state.Manager#get} passing the
* {@link #stateId}
* The resulting object is passed to {@link #applyState}{@link #applyState} simply copies
* properties into the object, but a developer may override this to support
* more behaviour.
* You can perform extra processing on state save and restore by attaching
* handlers to the {@link #beforestaterestore}, {@link #staterestore},
* {@link #beforestatesave} and {@link #statesave} events.
*/
stateful: true,
/**
* @cfg {String} stateId
* The unique id for this object to use for state management purposes.
* See {@link #stateful} for an explanation of saving and restoring state.
*/
/**
* @cfg {Array} stateEvents
* An array of events that, when fired, should trigger this object to
* save its state (defaults to none). stateEvents may be any type
* of event supported by this object, including browser or custom events
* (e.g., ['click', 'customerchange'] ).
* See {@link #stateful} for an explanation of saving and
* restoring object state.
*/
/**
* @cfg {Number} saveBuffer A buffer to be applied if many state events are fired within
* a short period. Defaults to 100.
*/
saveDelay: 100,
autoGenIdRe: /^((\w+-)|(ext-comp-))\d{4,}$/i,
constructor: function(config) {
var me = this;
config = config || {};
if (Ext.isDefined(config.stateful)) {
me.stateful = config.stateful;
}
if (Ext.isDefined(config.saveDelay)) {
me.saveDelay = config.saveDelay;
}
me.stateId = me.stateId || config.stateId;
if (!me.stateEvents) {
me.stateEvents = [];
}
if (config.stateEvents) {
me.stateEvents.concat(config.stateEvents);
}
this.addEvents(
/**
* @event beforestaterestore
* Fires before the state of the object is restored. Return false from an event handler to stop the restore.
* @param {Ext.state.Stateful} this
* @param {Object} state The hash of state values returned from the StateProvider. If this
* event is not vetoed, then the state object is passed to applyState applyState getState() getState() undefined if not found.
*/
get : function(id) {
return this.all.get(id);
},
/**
* Registers an item to be managed
* @param {Mixed} item The item to register
*/
register: function(item) {
this.all.add(item);
},
/**
* Unregisters an item by removing it from this manager
* @param {Mixed} item The item to unregister
*/
unregister: function(item) {
this.all.remove(item);
},
/**
* Registers a new item constructor, keyed by a type key.
* @param {String} type The mnemonic string by which the class may be looked up.
* @param {Constructor} cls The new instance class.
*/
registerType : function(type, cls) {
this.types[type] = cls;
cls[this.typeName] = type;
},
/**
* Checks if an item type is registered.
* @param {String} type The mnemonic string by which the class may be looked up
* @return {Boolean} Whether the type is registered.
*/
isRegistered : function(type){
return this.types[type] !== undefined;
},
/**
* Creates and returns an instance of whatever this manager manages, based on the supplied type and config object
* @param {Object} config The config object
* @param {String} defaultType If no type is discovered in the config object, we fall back to this type
* @return {Mixed} The instance of whatever this manager is managing
*/
create: function(config, defaultType) {
var type = config[this.typeName] || config.type || defaultType,
Constructor = this.types[type];
return new Constructor(config);
},
/**
* Registers a function that will be called when an item with the specified id is added to the manager. This will happen on instantiation.
* @param {String} id The item id
* @param {Function} fn The callback function. Called with a single parameter, the item.
* @param {Object} scope The scope (this reference) in which the callback is executed. Defaults to the item.
*/
onAvailable : function(id, fn, scope){
var all = this.all,
item;
if (all.containsKey(id)) {
item = all.get(id);
fn.call(scope || item, item);
} else {
all.on('add', function(map, key, item){
if (key == id) {
fn.call(scope || item, item);
all.un('add', fn, scope);
}
});
}
},
/**
* Executes the specified function once for each item in the collection.
* Returning false from the function will cease iteration.
*
* The paramaters passed to the function are:
*
* @param {Object} fn The function to execute.
* @param {Object} scope The scope to execute in. Defaults to this .
*/
each: function(fn, scope){
this.all.each(fn, scope || this);
},
/**
* Gets the number of items in the collection.
* @return {Number} The number of items in the collection.
*/
getCount: function(){
return this.all.getCount();
}
});
/**
* @class Ext.PluginManager
* @extends Ext.AbstractManager
* Provides a registry of available Plugin classes indexed by a mnemonic code known as the Plugin's ptype.
* The {@link Ext.Component#xtype xtype} provides a way to avoid instantiating child Components
* when creating a full, nested config object for a complete Ext page.
* A child Component may be specified simply as a config object
* as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component
* needs rendering, the correct type can be looked up for lazy instantiation.
* For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.
* @singleton
*/
Ext.define('Ext.PluginManager', {
extend: 'Ext.AbstractManager',
alternateClassName: 'Ext.PluginMgr',
singleton: true,
typeName: 'ptype',
/**
* Creates a new Plugin from the specified config object using the
* config object's ptype to determine the class to instantiate.
* @param {Object} config A configuration object for the Plugin you wish to create.
* @param {Constructor} defaultType The constructor to provide the default Plugin type if
* the config object does not contain a ptype. (Optional if the config contains a ptype).
* @return {Ext.Component} The newly instantiated Plugin.
*/
//create: function(plugin, defaultType) {
// if (plugin instanceof this) {
// return plugin;
// } else {
// var type, config = {};
//
// if (Ext.isString(plugin)) {
// type = plugin;
// }
// else {
// type = plugin[this.typeName] || defaultType;
// config = plugin;
// }
//
// return Ext.createByAlias('plugin.' + type, config);
// }
//},
create : function(config, defaultType){
if (config.init) {
return config;
} else {
return Ext.createByAlias('plugin.' + (config.ptype || defaultType), config);
}
// Prior system supported Singleton plugins.
//var PluginCls = this.types[config.ptype || defaultType];
//if (PluginCls.init) {
// return PluginCls;
//} else {
// return new PluginCls(config);
//}
},
/**
* Returns all plugins registered with the given type. Here, 'type' refers to the type of plugin, not its ptype.
* @param {String} type The type to search for
* @param {Boolean} defaultsOnly True to only return plugins of this type where the plugin's isDefault property is truthy
* @return {Array} All matching plugins
*/
findByType: function(type, defaultsOnly) {
var matches = [],
types = this.types;
for (var name in types) {
if (!types.hasOwnProperty(name)) {
continue;
}
var item = types[name];
if (item.type == type && (!defaultsOnly || (defaultsOnly === true && item.isDefault))) {
matches.push(item);
}
}
return matches;
}
}, function() {
/**
* Shorthand for {@link Ext.PluginManager#registerType}
* @param {String} ptype The ptype mnemonic string by which the Plugin class
* may be looked up.
* @param {Constructor} cls The new Plugin class.
* @member Ext
* @method preg
*/
Ext.preg = function() {
return Ext.PluginManager.registerType.apply(Ext.PluginManager, arguments);
};
});
/**
* @class Ext.ComponentManager
* @extends Ext.AbstractManager
* Provides a registry of all Components (instances of {@link Ext.Component} or any subclass
* thereof) on a page so that they can be easily accessed by {@link Ext.Component component}
* {@link Ext.Component#id id} (see {@link #get}, or the convenience method {@link Ext#getCmp Ext.getCmp}).
* This object also provides a registry of available Component classes
* indexed by a mnemonic code known as the Component's {@link Ext.Component#xtype xtype}.
* The xtype provides a way to avoid instantiating child Components
* when creating a full, nested config object for a complete Ext page.
* A child Component may be specified simply as a config object
* as long as the correct {@link Ext.Component#xtype xtype} is specified so that if and when the Component
* needs rendering, the correct type can be looked up for lazy instantiation.
* For a list of all available {@link Ext.Component#xtype xtypes}, see {@link Ext.Component}.
* @singleton
*/
Ext.define('Ext.ComponentManager', {
extend: 'Ext.AbstractManager',
alternateClassName: 'Ext.ComponentMgr',
singleton: true,
typeName: 'xtype',
/**
* Creates a new Component from the specified config object using the
* config object's xtype to determine the class to instantiate.
* @param {Object} config A configuration object for the Component you wish to create.
* @param {Constructor} defaultType The constructor to provide the default Component type if
* the config object does not contain a xtype. (Optional if the config contains a xtype).
* @return {Ext.Component} The newly instantiated Component.
*/
create: function(component, defaultType){
if (component instanceof Ext.AbstractComponent) {
return component;
}
else if (Ext.isString(component)) {
return Ext.createByAlias('widget.' + component);
}
else {
var type = component.xtype || defaultType,
config = component;
return Ext.createByAlias('widget.' + type, config);
}
},
registerType: function(type, cls) {
this.types[type] = cls;
cls[this.typeName] = type;
cls.prototype[this.typeName] = type;
}
});
/**
* @class Ext.XTemplate
* @extends Ext.Template
* A template class that supports advanced functionality like:
* Autofilling arrays using templates and sub-templates
* Conditional processing with basic comparison operators
* Basic math function support
* Execute arbitrary inline code with special built-in template variables
* Custom member functions
* Many special tags and built-in operators that aren't defined as part of
* the API, but are supported in the templates that can be created
* XTemplate provides the templating mechanism built into:
* {@link Ext.view.View}
*
*
* Sample Data
*
This is the data object used for reference in each code example:
*
var data = {
name: 'Tommy Maintz',
title: 'Lead Developer',
company: 'Sencha Inc.',
email: 'tommy@sencha.com',
address: '5 Cups Drive',
city: 'Palo Alto',
state: 'CA',
zip: '44102',
drinks: ['Coffee', 'Soda', 'Water'],
kids: [{
name: 'Joshua',
age:3
},{
name: 'Matthew',
age:2
},{
name: 'Solomon',
age:0
}]
};
*
Auto filling of arrays
*
The tpl for
* If the value specified in for is an array, it will auto-fill,
* repeating the template block inside the tpl tag for each item in the
* array.
* If for="." is specified, the data object provided is examined.
* While processing an array, the special variable {#}
* will provide the current array index + 1 (starts at 1, not 0).
*
*
*
<tpl for =".">...</tpl> // loop through array at root node
<tpl for ="foo">...</tpl> // loop through array at foo node
<tpl for ="foo.bar">...</tpl> // loop through array at foo.bar node
* Using the sample data above:
*
var tpl = new Ext.XTemplate(
'<p>Kids: ',
'<tpl for =".">', // process the data.kids node
'<p>{#}. {name}</p>', // use current array index to autonumber
'</tpl></p>'
);
tpl.overwrite(panel.body, data.kids); // pass the kids property of the data object
*
An example illustrating how the for
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Title: {title}</p>',
'<p>Company: {company}</p>',
'<p>Kids: ',
'<tpl for="kids" >', // interrogate the kids property within the data
'<p>{name}</p>',
'</tpl></p>'
);
tpl.overwrite(panel.body, data); // pass the root node of the data object
*
Flat arrays that contain values (and not objects) can be auto-rendered
* using the special {.}
*
var tpl = new Ext.XTemplate(
'<p>{name}\'s favorite beverages:</p>',
'<tpl for="drinks">',
'<div> - {.}</div>',
'</tpl>'
);
tpl.overwrite(panel.body, data);
*
When processing a sub-template, for example while looping through a child array,
* you can access the parent object's members via the parent
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Kids: ',
'<tpl for="kids">',
'<tpl if="age > 1">',
'<p>{name}</p>',
'<p>Dad: {parent .name}</p>',
'</tpl>',
'</tpl></p>'
);
tpl.overwrite(panel.body, data);
*
Conditional processing with basic comparison operators
*
The tpl if
* Double quotes must be encoded if used within the conditional
* There is no else operator — if needed, two opposite
* if statements should be used.
*
*
<tpl if="age > 1 && age < 10">Child</tpl>
<tpl if="age >= 10 && age < 18">Teenager</tpl>
<tpl if ="this.isGirl(name)">...</tpl>
<tpl if ="id==\'download\'">...</tpl>
<tpl if ="needsIcon"><img src="{icon}" class="{iconCls}"/></tpl>
// no good:
<tpl if="name == "Tommy"">Hello</tpl>
// encode " if it is part of the condition, e.g.
<tpl if="name == "Tommy"">Hello</tpl>
*
* Using the sample data above:
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Kids: ',
'<tpl for="kids">',
'<tpl if="age > 1">',
'<p>{name}</p>',
'</tpl>',
'</tpl></p>'
);
tpl.overwrite(panel.body, data);
*
Basic math support
*
The following basic math operators may be applied directly on numeric
* data values:
* + - * /
*
* For example:
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Kids: ',
'<tpl for="kids">',
'<tpl if="age > 1">', // <-- Note that the > is encoded
'<p>{#}: {name}</p>', // <-- Auto-number each item
'<p>In 5 Years: {age+5}</p>', // <-- Basic math
'<p>Dad: {parent.name}</p>',
'</tpl>',
'</tpl></p>'
);
tpl.overwrite(panel.body, data);
*
Execute arbitrary inline code with special built-in template variables
*
Anything between {[ ... ]} is considered code to be executed
* in the scope of the template. There are some special variables available in that code:
*
* values values is.parent xindex xcount
* This example demonstrates basic row striping using an inline code block and the
*
xindex variable:
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Company: {[values.company.toUpperCase() + ", " + values.title]}</p>',
'<p>Kids: ',
'<tpl for="kids">',
'<div class="{[xindex % 2 === 0 ? "even" : "odd"]}">',
'{name}',
'</div>',
'</tpl></p>'
);
tpl.overwrite(panel.body, data);
*
Template member functions
*
One or more member functions can be specified in a configuration
* object passed into the XTemplate constructor for more complex processing:
*
var tpl = new Ext.XTemplate(
'<p>Name: {name}</p>',
'<p>Kids: ',
'<tpl for="kids">',
'<tpl if="this.isGirl(name)">',
'<p>Girl: {name} - {age}</p>',
'</tpl>',
// use opposite if statement to simulate 'else' processing:
'<tpl if="this.isGirl(name) == false">',
'<p>Boy: {name} - {age}</p>',
'</tpl>',
'<tpl if="this.isBaby(age)">',
'<p>{name} is a baby!</p>',
'</tpl>',
'</tpl></p>',
{
// XTemplate configuration:
compiled: true,
// member functions:
isGirl: function(name){
return name == 'Sara Grace';
},
isBaby: function(age){
return age < 1;
}
}
);
tpl.overwrite(panel.body, data);
*
display:none textarea, preferred) or innerHTML.
* @param {String/HTMLElement} el A DOM element or its id
* @return {Ext.Template} The created template
* @static
*/
from: function(el, config) {
el = Ext.getDom(el);
return new this(el.value || el.innerHTML, config || {});
}
},
argsRe: /]*>((?:(?=([^<]+))\2|<(?!tpl\b[^>]*>))*?)<\/tpl>/,
nameRe: /^]*?for="(.*?)"/,
ifRe: /^]*?if="(.*?)"/,
execRe: /^]*?exec="(.*?)"/,
constructor: function() {
this.callParent(arguments);
var me = this,
html = me.html,
argsRe = me.argsRe,
nameRe = me.nameRe,
ifRe = me.ifRe,
execRe = me.execRe,
id = 0,
tpls = [],
VALUES = 'values',
PARENT = 'parent',
XINDEX = 'xindex',
XCOUNT = 'xcount',
RETURN = 'return ',
WITHVALUES = 'with(values){ ',
m, matchName, matchIf, matchExec, exp, fn, exec, name, i;
html = ['', html, ' '].join('');
while ((m = html.match(argsRe))) {
exp = null;
fn = null;
exec = null;
matchName = m[0].match(nameRe);
matchIf = m[0].match(ifRe);
matchExec = m[0].match(execRe);
exp = matchIf ? matchIf[1] : null;
if (exp) {
fn = Ext.functionFactory(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES + 'try{' + RETURN + Ext.String.htmlDecode(exp) + ';}catch(e){return;}}');
}
exp = matchExec ? matchExec[1] : null;
if (exp) {
exec = Ext.functionFactory(VALUES, PARENT, XINDEX, XCOUNT, WITHVALUES + Ext.String.htmlDecode(exp) + ';}');
}
name = matchName ? matchName[1] : null;
if (name) {
if (name === '.') {
name = VALUES;
} else if (name === '..') {
name = PARENT;
}
name = Ext.functionFactory(VALUES, PARENT, 'try{' + WITHVALUES + RETURN + name + ';}}catch(e){return;}');
}
tpls.push({
id: id,
target: name,
exec: exec,
test: fn,
body: m[1] || ''
});
html = html.replace(m[0], '{xtpl' + id + '}');
id = id + 1;
}
for (i = tpls.length - 1; i >= 0; --i) {
me.compileTpl(tpls[i]);
}
me.master = tpls[tpls.length - 1];
me.tpls = tpls;
},
applySubTemplate: function(id, values, parent, xindex, xcount) {
var me = this, t = me.tpls[id];
return t.compiled.call(me, values, parent, xindex, xcount);
},
codeRe: /\{\[((?:\\\]|.|\n)*?)\]\}/g,
re: /\{([\w-\.\#]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?(\s?[\+\-\*\/]\s?[\d\.\+\-\*\/\(\)]+)?\}/g,
compileTpl: function(tpl) {
var fm = Ext.util.Format,
me = this,
useFormat = me.disableFormats !== true,
body, bodyReturn, evaluatedFn;
function fn(m, name, format, args, math) {
var v;
if (name.substr(0, 4) == 'xtpl') {
return "',this.applySubTemplate(" + name.substr(4) + ", values, parent, xindex, xcount),'";
}
if (name == '.') {
v = 'Ext.Array.indexOf(["string", "number", "boolean"], typeof values) > -1 || Ext.isDate(values) ? values : ""';
}
else if (name == '#') {
v = 'xindex';
}
else if (name.substr(0, 7) == "parent.") {
v = name;
}
else if (name.indexOf('.') != -1) {
v = "values." + name;
}
else {
v = "values['" + name + "']";
}
if (math) {
v = '(' + v + math + ')';
}
if (format && useFormat) {
args = args ? ',' + args : "";
if (format.substr(0, 5) != "this.") {
format = "fm." + format + '(';
}
else {
format = 'this.' + format.substr(5) + '(';
}
}
else {
args = '';
format = "(" + v + " === undefined ? '' : ";
}
return "'," + format + v + args + "),'";
}
function codeFn(m, code) {
return "',(" + code.replace(me.compileARe, "'") + "),'";
}
bodyReturn = tpl.body.replace(me.compileBRe, '\\n').replace(me.compileCRe, "\\'").replace(me.re, fn).replace(me.codeRe, codeFn);
body = "evaluatedFn = function(values, parent, xindex, xcount){return ['" + bodyReturn + "'].join('');};";
eval(body);
tpl.compiled = function(values, parent, xindex, xcount) {
var vs,
length,
buffer,
i;
if (tpl.test && !tpl.test.call(me, values, parent, xindex, xcount)) {
return '';
}
vs = tpl.target ? tpl.target.call(me, values, parent) : values;
if (!vs) {
return '';
}
parent = tpl.target ? values : parent;
if (tpl.target && Ext.isArray(vs)) {
buffer = [];
length = vs.length;
if (tpl.exec) {
for (i = 0; i < length; i++) {
buffer[buffer.length] = evaluatedFn.call(me, vs[i], parent, i + 1, length);
tpl.exec.call(me, vs[i], parent, i + 1, length);
}
} else {
for (i = 0; i < length; i++) {
buffer[buffer.length] = evaluatedFn.call(me, vs[i], parent, i + 1, length);
}
}
return buffer.join('');
}
if (tpl.exec) {
tpl.exec.call(me, vs, parent, xindex, xcount);
}
return evaluatedFn.call(me, vs, parent, xindex, xcount);
};
return this;
},
applyTemplate: function(values) {
return this.master.compiled.call(this, values, {}, 1, 1);
},
compile: function() {
return this;
}
}, function() {
this.createAlias('apply', 'applyTemplate');
});
Ext.define('Ext.util.AbstractMixedCollection', {
requires: ['Ext.util.Filter'],
mixins: {
observable: 'Ext.util.Observable'
},
constructor: function(allowFunctions, keyFn) {
var me = this;
me.items = [];
me.map = {};
me.keys = [];
me.length = 0;
me.addEvents(
'clear',
'add',
'replace',
'remove'
);
me.allowFunctions = allowFunctions === true;
if (keyFn) {
me.getKey = keyFn;
}
me.mixins.observable.constructor.call(me);
},
allowFunctions : false,
add : function(key, obj){
var me = this,
myObj = obj,
myKey = key,
old;
if (arguments.length == 1) {
myObj = myKey;
myKey = me.getKey(myObj);
}
if (typeof myKey != 'undefined' && myKey !== null) {
old = me.map[myKey];
if (typeof old != 'undefined') {
return me.replace(myKey, myObj);
}
me.map[myKey] = myObj;
}
me.length++;
me.items.push(myObj);
me.keys.push(myKey);
me.fireEvent('add', me.length - 1, myObj, myKey);
return myObj;
},
getKey : function(o){
return o.id;
},
replace : function(key, o){
var me = this,
old,
index;
if (arguments.length == 1) {
o = arguments[0];
key = me.getKey(o);
}
old = me.map[key];
if (typeof key == 'undefined' || key === null || typeof old == 'undefined') {
return me.add(key, o);
}
index = me.indexOfKey(key);
me.items[index] = o;
me.map[key] = o;
me.fireEvent('replace', key, old, o);
return o;
},
addAll : function(objs){
var me = this,
i = 0,
args,
len,
key;
if (arguments.length > 1 || Ext.isArray(objs)) {
args = arguments.length > 1 ? arguments : objs;
for (len = args.length; i < len; i++) {
me.add(args[i]);
}
} else {
for (key in objs) {
if (objs.hasOwnProperty(key)) {
if (me.allowFunctions || typeof objs[key] != 'function') {
me.add(key, objs[key]);
}
}
}
}
},
each : function(fn, scope){
var items = [].concat(this.items),
i = 0,
len = items.length,
item;
for (; i < len; i++) {
item = items[i];
if (fn.call(scope || item, item, i, len) === false) {
break;
}
}
},
eachKey : function(fn, scope){
var keys = this.keys,
items = this.items,
i = 0,
len = keys.length;
for (; i < len; i++) {
fn.call(scope || window, keys[i], items[i], i, len);
}
},
findBy : function(fn, scope) {
var keys = this.keys,
items = this.items,
i = 0,
len = items.length;
for (; i < len; i++) {
if (fn.call(scope || window, items[i], keys[i])) {
return items[i];
}
}
return null;
},
find : function() {
if (Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Ext.util.MixedCollection: find has been deprecated. Use findBy instead.');
}
return this.findBy.apply(this, arguments);
},
insert : function(index, key, obj){
var me = this,
myKey = key,
myObj = obj;
if (arguments.length == 2) {
myObj = myKey;
myKey = me.getKey(myObj);
}
if (me.containsKey(myKey)) {
me.suspendEvents();
me.removeAtKey(myKey);
me.resumeEvents();
}
if (index >= me.length) {
return me.add(myKey, myObj);
}
me.length++;
Ext.Array.splice(me.items, index, 0, myObj);
if (typeof myKey != 'undefined' && myKey !== null) {
me.map[myKey] = myObj;
}
Ext.Array.splice(me.keys, index, 0, myKey);
me.fireEvent('add', index, myObj, myKey);
return myObj;
},
remove : function(o){
return this.removeAt(this.indexOf(o));
},
removeAll : function(items){
Ext.each(items || [], function(item) {
this.remove(item);
}, this);
return this;
},
removeAt : function(index){
var me = this,
o,
key;
if (index < me.length && index >= 0) {
me.length--;
o = me.items[index];
Ext.Array.erase(me.items, index, 1);
key = me.keys[index];
if (typeof key != 'undefined') {
delete me.map[key];
}
Ext.Array.erase(me.keys, index, 1);
me.fireEvent('remove', o, key);
return o;
}
return false;
},
removeAtKey : function(key){
return this.removeAt(this.indexOfKey(key));
},
getCount : function(){
return this.length;
},
indexOf : function(o){
return Ext.Array.indexOf(this.items, o);
},
indexOfKey : function(key){
return Ext.Array.indexOf(this.keys, key);
},
get : function(key) {
var me = this,
mk = me.map[key],
item = mk !== undefined ? mk : (typeof key == 'number') ? me.items[key] : undefined;
return typeof item != 'function' || me.allowFunctions ? item : null;
},
getAt : function(index) {
return this.items[index];
},
getByKey : function(key) {
return this.map[key];
},
contains : function(o){
return Ext.Array.contains(this.items, o);
},
containsKey : function(key){
return typeof this.map[key] != 'undefined';
},
clear : function(){
var me = this;
me.length = 0;
me.items = [];
me.keys = [];
me.map = {};
me.fireEvent('clear');
},
first : function() {
return this.items[0];
},
last : function() {
return this.items[this.length - 1];
},
sum: function(property, root, start, end) {
var values = this.extractValues(property, root),
length = values.length,
sum = 0,
i;
start = start || 0;
end = (end || end === 0) ? end : length - 1;
for (i = start; i <= end; i++) {
sum += values[i];
}
return sum;
},
collect: function(property, root, allowNull) {
var values = this.extractValues(property, root),
length = values.length,
hits = {},
unique = [],
value, strValue, i;
for (i = 0; i < length; i++) {
value = values[i];
strValue = String(value);
if ((allowNull || !Ext.isEmpty(value)) && !hits[strValue]) {
hits[strValue] = true;
unique.push(value);
}
}
return unique;
},
extractValues: function(property, root) {
var values = this.items;
if (root) {
values = Ext.Array.pluck(values, root);
}
return Ext.Array.pluck(values, property);
},
getRange : function(start, end){
var me = this,
items = me.items,
range = [],
i;
if (items.length < 1) {
return range;
}
start = start || 0;
end = Math.min(typeof end == 'undefined' ? me.length - 1 : end, me.length - 1);
if (start <= end) {
for (i = start; i <= end; i++) {
range[range.length] = items[i];
}
} else {
for (i = start; i >= end; i--) {
range[range.length] = items[i];
}
}
return range;
},
filter : function(property, value, anyMatch, caseSensitive) {
var filters = [],
filterFn;
if (Ext.isString(property)) {
filters.push(Ext.create('Ext.util.Filter', {
property : property,
value : value,
anyMatch : anyMatch,
caseSensitive: caseSensitive
}));
} else if (Ext.isArray(property) || property instanceof Ext.util.Filter) {
filters = filters.concat(property);
}
filterFn = function(record) {
var isMatch = true,
length = filters.length,
i;
for (i = 0; i < length; i++) {
var filter = filters[i],
fn = filter.filterFn,
scope = filter.scope;
isMatch = isMatch && fn.call(scope, record);
}
return isMatch;
};
return this.filterBy(filterFn);
},
filterBy : function(fn, scope) {
var me = this,
newMC = new this.self(),
keys = me.keys,
items = me.items,
length = items.length,
i;
newMC.getKey = me.getKey;
for (i = 0; i < length; i++) {
if (fn.call(scope || me, items[i], keys[i])) {
newMC.add(keys[i], items[i]);
}
}
return newMC;
},
findIndex : function(property, value, start, anyMatch, caseSensitive){
if(Ext.isEmpty(value, false)){
return -1;
}
value = this.createValueMatcher(value, anyMatch, caseSensitive);
return this.findIndexBy(function(o){
return o && value.test(o[property]);
}, null, start);
},
findIndexBy : function(fn, scope, start){
var me = this,
keys = me.keys,
items = me.items,
i = start || 0,
len = items.length;
for (; i < len; i++) {
if (fn.call(scope || me, items[i], keys[i])) {
return i;
}
}
return -1;
},
createValueMatcher : function(value, anyMatch, caseSensitive, exactMatch) {
if (!value.exec) {
var er = Ext.String.escapeRegex;
value = String(value);
if (anyMatch === true) {
value = er(value);
} else {
value = '^' + er(value);
if (exactMatch === true) {
value += '$';
}
}
value = new RegExp(value, caseSensitive ? '' : 'i');
}
return value;
},
clone : function() {
var me = this,
copy = new this.self(),
keys = me.keys,
items = me.items,
i = 0,
len = items.length;
for(; i < len; i++){
copy.add(keys[i], items[i]);
}
copy.getKey = me.getKey;
return copy;
}
});
Ext.define("Ext.util.Sortable", {
isSortable: true,
defaultSortDirection: "ASC",
requires: [
'Ext.util.Sorter'
],
initSortable: function() {
var me = this,
sorters = me.sorters;
me.sorters = Ext.create('Ext.util.AbstractMixedCollection', false, function(item) {
return item.id || item.property;
});
if (sorters) {
me.sorters.addAll(me.decodeSorters(sorters));
}
},
sort: function(sorters, direction, where, doSort) {
var me = this,
sorter, sorterFn,
newSorters;
if (Ext.isArray(sorters)) {
doSort = where;
where = direction;
newSorters = sorters;
}
else if (Ext.isObject(sorters)) {
doSort = where;
where = direction;
newSorters = [sorters];
}
else if (Ext.isString(sorters)) {
sorter = me.sorters.get(sorters);
if (!sorter) {
sorter = {
property : sorters,
direction: direction
};
newSorters = [sorter];
}
else if (direction === undefined) {
sorter.toggle();
}
else {
sorter.setDirection(direction);
}
}
if (newSorters && newSorters.length) {
newSorters = me.decodeSorters(newSorters);
if (Ext.isString(where)) {
if (where === 'prepend') {
sorters = me.sorters.clone().items;
me.sorters.clear();
me.sorters.addAll(newSorters);
me.sorters.addAll(sorters);
}
else {
me.sorters.addAll(newSorters);
}
}
else {
me.sorters.clear();
me.sorters.addAll(newSorters);
}
if (doSort !== false) {
me.onBeforeSort(newSorters);
}
}
if (doSort !== false) {
sorters = me.sorters.items;
if (sorters.length) {
sorterFn = function(r1, r2) {
var result = sorters[0].sort(r1, r2),
length = sorters.length,
i;
for (i = 1; i < length; i++) {
result = result || sorters[i].sort.call(this, r1, r2);
}
return result;
};
me.doSort(sorterFn);
}
}
return sorters;
},
onBeforeSort: Ext.emptyFn,
decodeSorters: function(sorters) {
if (!Ext.isArray(sorters)) {
if (sorters === undefined) {
sorters = [];
} else {
sorters = [sorters];
}
}
var length = sorters.length,
Sorter = Ext.util.Sorter,
fields = this.model ? this.model.prototype.fields : null,
field,
config, i;
for (i = 0; i < length; i++) {
config = sorters[i];
if (!(config instanceof Sorter)) {
if (Ext.isString(config)) {
config = {
property: config
};
}
Ext.applyIf(config, {
root : this.sortRoot,
direction: "ASC"
});
if (config.fn) {
config.sorterFn = config.fn;
}
if (typeof config == 'function') {
config = {
sorterFn: config
};
}
if (fields && !config.transform) {
field = fields.get(config.property);
config.transform = field ? field.sortType : undefined;
}
sorters[i] = Ext.create('Ext.util.Sorter', config);
}
}
return sorters;
},
getSorters: function() {
return this.sorters.items;
}
});
Ext.define('Ext.util.MixedCollection', {
extend: 'Ext.util.AbstractMixedCollection',
mixins: {
sortable: 'Ext.util.Sortable'
},
constructor: function() {
var me = this;
me.callParent(arguments);
me.addEvents('sort');
me.mixins.sortable.initSortable.call(me);
},
doSort: function(sorterFn) {
this.sortBy(sorterFn);
},
_sort : function(property, dir, fn){
var me = this,
i, len,
dsc = String(dir).toUpperCase() == 'DESC' ? -1 : 1,
c = [],
keys = me.keys,
items = me.items;
fn = fn || function(a, b) {
return a - b;
};
for(i = 0, len = items.length; i < len; i++){
c[c.length] = {
key : keys[i],
value: items[i],
index: i
};
}
Ext.Array.sort(c, function(a, b){
var v = fn(a[property], b[property]) * dsc;
if(v === 0){
v = (a.index < b.index ? -1 : 1);
}
return v;
});
for(i = 0, len = c.length; i < len; i++){
items[i] = c[i].value;
keys[i] = c[i].key;
}
me.fireEvent('sort', me);
},
sortBy: function(sorterFn) {
var me = this,
items = me.items,
keys = me.keys,
length = items.length,
temp = [],
i;
for (i = 0; i < length; i++) {
temp[i] = {
key : keys[i],
value: items[i],
index: i
};
}
Ext.Array.sort(temp, function(a, b) {
var v = sorterFn(a.value, b.value);
if (v === 0) {
v = (a.index < b.index ? -1 : 1);
}
return v;
});
for (i = 0; i < length; i++) {
items[i] = temp[i].value;
keys[i] = temp[i].key;
}
me.fireEvent('sort', me, items, keys);
},
reorder: function(mapping) {
var me = this,
items = me.items,
index = 0,
length = items.length,
order = [],
remaining = [],
oldIndex;
me.suspendEvents();
for (oldIndex in mapping) {
order[mapping[oldIndex]] = items[oldIndex];
}
for (index = 0; index < length; index++) {
if (mapping[index] == undefined) {
remaining.push(items[index]);
}
}
for (index = 0; index < length; index++) {
if (order[index] == undefined) {
order[index] = remaining.shift();
}
}
me.clear();
me.addAll(order);
me.resumeEvents();
me.fireEvent('sort', me);
},
sortByKey : function(dir, fn){
this._sort('key', dir, fn || function(a, b){
var v1 = String(a).toUpperCase(), v2 = String(b).toUpperCase();
return v1 > v2 ? 1 : (v1 < v2 ? -1 : 0);
});
}
});
Ext.define('Ext.data.StoreManager', {
extend: 'Ext.util.MixedCollection',
alternateClassName: ['Ext.StoreMgr', 'Ext.data.StoreMgr', 'Ext.StoreManager'],
singleton: true,
uses: ['Ext.data.ArrayStore'],
register : function() {
for (var i = 0, s; (s = arguments[i]); i++) {
this.add(s);
}
},
unregister : function() {
for (var i = 0, s; (s = arguments[i]); i++) {
this.remove(this.lookup(s));
}
},
lookup : function(store) {
if (Ext.isArray(store)) {
var fields = ['field1'],
expand = !Ext.isArray(store[0]),
data = store,
i,
len;
if(expand){
data = [];
for (i = 0, len = store.length; i < len; ++i) {
data.push([store[i]]);
}
} else {
for(i = 2, len = store[0].length; i <= len; ++i){
fields.push('field' + i);
}
}
return Ext.create('Ext.data.ArrayStore', {
data : data,
fields: fields,
autoDestroy: true,
autoCreated: true,
expanded: expand
});
}
if (Ext.isString(store)) {
return this.get(store);
} else {
return Ext.data.AbstractStore.create(store);
}
},
getKey : function(o) {
return o.storeId;
}
}, function() {
Ext.regStore = function(name, config) {
var store;
if (Ext.isObject(name)) {
config = name;
} else {
config.storeId = name;
}
if (config instanceof Ext.data.Store) {
store = config;
} else {
store = Ext.create('Ext.data.Store', config);
}
return Ext.data.StoreManager.register(store);
};
Ext.getStore = function(name) {
return Ext.data.StoreManager.lookup(name);
};
});
Ext.define('Ext.LoadMask', {
mixins: {
observable: 'Ext.util.Observable'
},
requires: ['Ext.data.StoreManager'],
msg : 'Loading...',
msgCls : Ext.baseCSSPrefix + 'mask-loading',
useMsg: true,
disabled: false,
constructor : function(el, config) {
var me = this;
if (el.isComponent) {
me.bindComponent(el);
} else {
me.el = Ext.get(el);
}
Ext.apply(me, config);
me.addEvents('beforeshow', 'show', 'hide');
if (me.store) {
me.bindStore(me.store, true);
}
me.mixins.observable.constructor.call(me, config);
},
bindComponent: function(comp) {
var me = this,
listeners = {
resize: me.onComponentResize,
scope: me
};
if (comp.el) {
me.onComponentRender(comp);
} else {
listeners.render = {
fn: me.onComponentRender,
scope: me,
single: true
};
}
me.mon(comp, listeners);
},
onComponentRender: function(comp) {
this.el = comp.getContentTarget();
},
onComponentResize: function(comp, w, h) {
this.el.isMasked();
},
bindStore : function(store, initial) {
var me = this;
if (!initial && me.store) {
me.mun(me.store, {
scope: me,
beforeload: me.onBeforeLoad,
load: me.onLoad,
exception: me.onLoad
});
if(!store) {
me.store = null;
}
}
if (store) {
store = Ext.data.StoreManager.lookup(store);
me.mon(store, {
scope: me,
beforeload: me.onBeforeLoad,
load: me.onLoad,
exception: me.onLoad
});
}
me.store = store;
if (store && store.isLoading()) {
me.onBeforeLoad();
}
},
disable : function() {
var me = this;
me.disabled = true;
if (me.loading) {
me.onLoad();
}
},
enable : function() {
this.disabled = false;
},
isDisabled : function() {
return this.disabled;
},
onLoad : function() {
var me = this;
me.loading = false;
me.el.unmask();
me.fireEvent('hide', me, me.el, me.store);
},
onBeforeLoad : function() {
var me = this;
if (!me.disabled && !me.loading && me.fireEvent('beforeshow', me, me.el, me.store) !== false) {
if (me.useMsg) {
me.el.mask(me.msg, me.msgCls, false);
} else {
me.el.mask();
}
me.fireEvent('show', me, me.el, me.store);
me.loading = true;
}
},
show: function() {
this.onBeforeLoad();
},
hide: function() {
this.onLoad();
},
destroy : function() {
this.hide();
this.clearListeners();
}
});
Ext.define('Ext.ComponentLoader', {
extend: 'Ext.ElementLoader',
statics: {
Renderer: {
Data: function(loader, response, active){
var success = true;
try {
loader.getTarget().update(Ext.decode(response.responseText));
} catch (e) {
success = false;
}
return success;
},
Component: function(loader, response, active){
var success = true,
target = loader.getTarget(),
items = [];
try {
items = Ext.decode(response.responseText);
} catch (e) {
success = false;
}
if (success) {
if (active.removeAll) {
target.removeAll();
}
target.add(items);
}
return success;
}
}
},
target: null,
loadMask: false,
renderer: 'html',
setTarget: function(target){
var me = this;
if (Ext.isString(target)) {
target = Ext.getCmp(target);
}
if (me.target && me.target != target) {
me.abort();
}
me.target = target;
},
removeMask: function(){
this.target.setLoading(false);
},
addMask: function(mask){
this.target.setLoading(mask);
},
setOptions: function(active, options){
active.removeAll = Ext.isDefined(options.removeAll) ? options.removeAll : this.removeAll;
},
getRenderer: function(renderer){
if (Ext.isFunction(renderer)) {
return renderer;
}
var renderers = this.statics().Renderer;
switch (renderer) {
case 'component':
return renderers.Component;
case 'data':
return renderers.Data;
default:
return Ext.ElementLoader.Renderer.Html;
}
}
});
Ext.define('Ext.layout.component.Auto', {
alias: 'layout.autocomponent',
extend: 'Ext.layout.component.Component',
type: 'autocomponent',
onLayout : function(width, height) {
this.setTargetSize(width, height);
}
});
Ext.define('Ext.AbstractComponent', {
mixins: {
observable: 'Ext.util.Observable',
animate: 'Ext.util.Animate',
state: 'Ext.state.Stateful'
},
requires: [
'Ext.PluginManager',
'Ext.ComponentManager',
'Ext.core.Element',
'Ext.core.DomHelper',
'Ext.XTemplate',
'Ext.ComponentQuery',
'Ext.LoadMask',
'Ext.ComponentLoader',
'Ext.EventManager',
'Ext.layout.Layout',
'Ext.layout.component.Auto'
],
uses: [
'Ext.ZIndexManager'
],
statics: {
AUTO_ID: 1000
},
isComponent: true,
getAutoId: function() {
return ++Ext.AbstractComponent.AUTO_ID;
},
renderTpl: null,
tplWriteMode: 'overwrite',
baseCls: Ext.baseCSSPrefix + 'component',
disabledCls: Ext.baseCSSPrefix + 'item-disabled',
ui: 'default',
uiCls: [],
hidden: false,
disabled: false,
draggable: false,
floating: false,
hideMode: 'display',
styleHtmlContent: false,
styleHtmlCls: Ext.baseCSSPrefix + 'html',
allowDomMove: true,
autoShow: false,
autoRender: false,
needsLayout: false,
rendered: false,
componentLayoutCounter: 0,
weight: 0,
trimRe: /^\s+|\s+$/g,
spacesRe: /\s+/,
maskOnDisable: true,
constructor : function(config) {
var me = this,
i, len;
config = config || {};
me.initialConfig = config;
Ext.apply(me, config);
me.addEvents(
'beforeactivate',
'activate',
'beforedeactivate',
'deactivate',
'added',
'disable',
'enable',
'beforeshow',
'show',
'beforehide',
'hide',
'removed',
'beforerender',
'render',
'afterrender',
'beforedestroy',
'destroy',
'resize',
'move'
);
me.getId();
me.mons = [];
me.additionalCls = [];
me.renderData = me.renderData || {};
me.renderSelectors = me.renderSelectors || {};
if (me.plugins) {
me.plugins = [].concat(me.plugins);
for (i = 0, len = me.plugins.length; i < len; i++) {
me.plugins[i] = me.constructPlugin(me.plugins[i]);
}
}
me.initComponent();
Ext.ComponentManager.register(me);
me.mixins.observable.constructor.call(me);
me.mixins.state.constructor.call(me, config);
this.addStateEvents('resize');
if (me.plugins) {
me.plugins = [].concat(me.plugins);
for (i = 0, len = me.plugins.length; i < len; i++) {
me.plugins[i] = me.initPlugin(me.plugins[i]);
}
}
me.loader = me.getLoader();
if (me.renderTo) {
me.render(me.renderTo);
}
if (me.autoShow) {
me.show();
}
},
initComponent: Ext.emptyFn,
getState: function() {
var me = this,
layout = me.ownerCt ? (me.shadowOwnerCt || me.ownerCt).getLayout() : null,
state = {
collapsed: me.collapsed
},
width = me.width,
height = me.height,
cm = me.collapseMemento,
anchors;
if (me.collapsed && cm) {
if (Ext.isDefined(cm.data.width)) {
width = cm.width;
}
if (Ext.isDefined(cm.data.height)) {
height = cm.height;
}
}
if (layout && me.flex) {
state.flex = me.flex;
if (layout.perpendicularPrefix) {
state[layout.perpendicularPrefix] = me['get' + layout.perpendicularPrefixCap]();
} else {
}
}
else if (layout && me.anchor) {
state.anchor = me.anchor;
anchors = me.anchor.split(' ').concat(null);
if (!anchors[0]) {
if (me.width) {
state.width = width;
}
}
if (!anchors[1]) {
if (me.height) {
state.height = height;
}
}
}
else {
if (me.width) {
state.width = width;
}
if (me.height) {
state.height = height;
}
}
if (state.width == me.initialConfig.width) {
delete state.width;
}
if (state.height == me.initialConfig.height) {
delete state.height;
}
if (layout && layout.align && (layout.align.indexOf('stretch') !== -1)) {
delete state[layout.perpendicularPrefix];
}
return state;
},
show: Ext.emptyFn,
animate: function(animObj) {
var me = this,
to;
animObj = animObj || {};
to = animObj.to || {};
if (Ext.fx.Manager.hasFxBlock(me.id)) {
return me;
}
if (!animObj.dynamic && (to.height || to.width)) {
var curWidth = me.getWidth(),
w = curWidth,
curHeight = me.getHeight(),
h = curHeight,
needsResize = false;
if (to.height && to.height > curHeight) {
h = to.height;
needsResize = true;
}
if (to.width && to.width > curWidth) {
w = to.width;
needsResize = true;
}
if (needsResize) {
var clearWidth = !Ext.isNumber(me.width),
clearHeight = !Ext.isNumber(me.height);
me.componentLayout.childrenChanged = true;
me.setSize(w, h, me.ownerCt);
me.el.setSize(curWidth, curHeight);
if (clearWidth) {
delete me.width;
}
if (clearHeight) {
delete me.height;
}
}
}
return me.mixins.animate.animate.apply(me, arguments);
},
findLayoutController: function() {
return this.findParentBy(function(c) {
return !c.ownerCt || (c.layout.layoutBusy && !c.ownerCt.layout.layoutBusy);
});
},
onShow : function() {
var needsLayout = this.needsLayout;
if (Ext.isObject(needsLayout)) {
this.doComponentLayout(needsLayout.width, needsLayout.height, needsLayout.isSetSize, needsLayout.ownerCt);
}
},
constructPlugin: function(plugin) {
if (plugin.ptype && typeof plugin.init != 'function') {
plugin.cmp = this;
plugin = Ext.PluginManager.create(plugin);
}
else if (typeof plugin == 'string') {
plugin = Ext.PluginManager.create({
ptype: plugin,
cmp: this
});
}
return plugin;
},
initPlugin : function(plugin) {
plugin.init(this);
return plugin;
},
doAutoRender: function() {
var me = this;
if (me.floating) {
me.render(document.body);
} else {
me.render(Ext.isBoolean(me.autoRender) ? Ext.getBody() : me.autoRender);
}
},
render : function(container, position) {
var me = this;
if (!me.rendered && me.fireEvent('beforerender', me) !== false) {
if (me.el) {
me.el = Ext.get(me.el);
}
if (me.floating) {
me.onFloatRender();
}
container = me.initContainer(container);
me.onRender(container, position);
me.el.setVisibilityMode(Ext.core.Element[me.hideMode.toUpperCase()]);
if (me.overCls) {
me.el.hover(me.addOverCls, me.removeOverCls, me);
}
me.fireEvent('render', me);
me.initContent();
me.afterRender(container);
me.fireEvent('afterrender', me);
me.initEvents();
if (me.hidden) {
me.el.hide();
}
if (me.disabled) {
me.disable(true);
}
}
return me;
},
onRender : function(container, position) {
var me = this,
el = me.el,
styles = me.initStyles(),
renderTpl, renderData, i;
position = me.getInsertPosition(position);
if (!el) {
if (position) {
el = Ext.core.DomHelper.insertBefore(position, me.getElConfig(), true);
}
else {
el = Ext.core.DomHelper.append(container, me.getElConfig(), true);
}
}
else if (me.allowDomMove !== false) {
if (position) {
container.dom.insertBefore(el.dom, position);
} else {
container.dom.appendChild(el.dom);
}
}
if (Ext.scopeResetCSS && !me.ownerCt) {
if (el.dom == Ext.getBody().dom) {
el.parent().addCls(Ext.baseCSSPrefix + 'reset');
}
else {
me.resetEl = el.wrap({
cls: Ext.baseCSSPrefix + 'reset'
});
}
}
me.setUI(me.ui);
el.addCls(me.initCls());
el.setStyle(styles);
me.el = el;
me.initFrame();
renderTpl = me.initRenderTpl();
if (renderTpl) {
renderData = me.initRenderData();
renderTpl.append(me.getTargetEl(), renderData);
}
me.applyRenderSelectors();
me.rendered = true;
},
afterRender : function() {
var me = this,
pos,
xy;
me.getComponentLayout();
if (!me.ownerCt || (me.height || me.width)) {
me.setSize(me.width, me.height);
} else {
me.renderChildren();
}
if (me.floating && (me.x === undefined || me.y === undefined)) {
if (me.floatParent) {
xy = me.el.getAlignToXY(me.floatParent.getTargetEl(), 'c-c');
pos = me.floatParent.getTargetEl().translatePoints(xy[0], xy[1]);
} else {
xy = me.el.getAlignToXY(me.container, 'c-c');
pos = me.container.translatePoints(xy[0], xy[1]);
}
me.x = me.x === undefined ? pos.left: me.x;
me.y = me.y === undefined ? pos.top: me.y;
}
if (Ext.isDefined(me.x) || Ext.isDefined(me.y)) {
me.setPosition(me.x, me.y);
}
if (me.styleHtmlContent) {
me.getTargetEl().addCls(me.styleHtmlCls);
}
},
renderChildren: function () {
var me = this,
layout = me.getComponentLayout();
me.suspendLayout = true;
layout.renderChildren();
delete me.suspendLayout;
},
frameCls: Ext.baseCSSPrefix + 'frame',
frameElementCls: {
tl: [],
tc: [],
tr: [],
ml: [],
mc: [],
mr: [],
bl: [],
bc: [],
br: []
},
frameTpl: [
'',
' {parent.baseCls}-{parent.ui}-{.}-tl " style="background-position: {tl}; padding-left: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-tr " style="background-position: {tr}; padding-right: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-tc " style="background-position: {tc}; height: {frameWidth}px" role="presentation">
',
'
',
'
',
' {parent.baseCls}-{parent.ui}-{.}-ml " style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-mr " style="background-position: {mr}; padding-right: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-mc " role="presentation">
',
'
',
'
',
' {parent.baseCls}-{parent.ui}-{.}-bl " style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-br " style="background-position: {br}; padding-right: {frameWidth}px" role="presentation">',
'
{parent.baseCls}-{parent.ui}-{.}-bc " style="background-position: {bc}; height: {frameWidth}px" role="presentation">
',
'
',
'
'
],
frameTableTpl: [
'',
'',
'',
' {parent.baseCls}-{parent.ui}-{.}-tl " style="background-position: {tl}; padding-left:{frameWidth}px" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-tc " style="background-position: {tc}; height: {frameWidth}px" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-tr " style="background-position: {tr}; padding-left: {frameWidth}px" role="presentation"> ',
' ',
'',
' {parent.baseCls}-{parent.ui}-{.}-ml " style="background-position: {ml}; padding-left: {frameWidth}px" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-mc " style="background-position: 0 0;" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-mr " style="background-position: {mr}; padding-left: {frameWidth}px" role="presentation"> ',
'',
'',
' {parent.baseCls}-{parent.ui}-{.}-bl " style="background-position: {bl}; padding-left: {frameWidth}px" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-bc " style="background-position: {bc}; height: {frameWidth}px" role="presentation"> {parent.baseCls}-{parent.ui}-{.}-br " style="background-position: {br}; padding-left: {frameWidth}px" role="presentation"> ',
' ',
'
'
],
initFrame : function() {
if (Ext.supports.CSS3BorderRadius) {
return false;
}
var me = this,
frameInfo = me.getFrameInfo(),
frameWidth = frameInfo.width,
frameTpl = me.getFrameTpl(frameInfo.table);
if (me.frame) {
frameTpl.insertFirst(me.el, Ext.apply({}, {
ui: me.ui,
uiCls: me.uiCls,
frameCls: me.frameCls,
baseCls: me.baseCls,
frameWidth: frameWidth,
top: !!frameInfo.top,
left: !!frameInfo.left,
right: !!frameInfo.right,
bottom: !!frameInfo.bottom
}, me.getFramePositions(frameInfo)));
me.frameBody = me.el.down('.' + me.frameCls + '-mc');
Ext.apply(me.renderSelectors, {
frameTL: '.' + me.baseCls + '-tl',
frameTC: '.' + me.baseCls + '-tc',
frameTR: '.' + me.baseCls + '-tr',
frameML: '.' + me.baseCls + '-ml',
frameMC: '.' + me.baseCls + '-mc',
frameMR: '.' + me.baseCls + '-mr',
frameBL: '.' + me.baseCls + '-bl',
frameBC: '.' + me.baseCls + '-bc',
frameBR: '.' + me.baseCls + '-br'
});
}
},
updateFrame: function() {
if (Ext.supports.CSS3BorderRadius) {
return false;
}
var me = this,
wasTable = this.frameSize && this.frameSize.table,
oldFrameTL = this.frameTL,
oldFrameBL = this.frameBL,
oldFrameML = this.frameML,
oldFrameMC = this.frameMC,
newMCClassName;
this.initFrame();
if (oldFrameMC) {
if (me.frame) {
delete me.frameTL;
delete me.frameTC;
delete me.frameTR;
delete me.frameML;
delete me.frameMC;
delete me.frameMR;
delete me.frameBL;
delete me.frameBC;
delete me.frameBR;
this.applyRenderSelectors();
newMCClassName = this.frameMC.dom.className;
oldFrameMC.insertAfter(this.frameMC);
this.frameMC.remove();
this.frameBody = this.frameMC = oldFrameMC;
oldFrameMC.dom.className = newMCClassName;
if (wasTable) {
me.el.query('> table')[1].remove();
}
else {
if (oldFrameTL) {
oldFrameTL.remove();
}
if (oldFrameBL) {
oldFrameBL.remove();
}
oldFrameML.remove();
}
}
else {
}
}
else if (me.frame) {
this.applyRenderSelectors();
}
},
getFrameInfo: function() {
if (Ext.supports.CSS3BorderRadius) {
return false;
}
var me = this,
left = me.el.getStyle('background-position-x'),
top = me.el.getStyle('background-position-y'),
info, frameInfo = false, max;
if (!left && !top) {
info = me.el.getStyle('background-position').split(' ');
left = info[0];
top = info[1];
}
if (parseInt(left, 10) >= 1000000 && parseInt(top, 10) >= 1000000) {
max = Math.max;
frameInfo = {
table: left.substr(0, 3) == '110',
vertical: top.substr(0, 3) == '110',
top: max(left.substr(3, 2), left.substr(5, 2)),
right: max(left.substr(5, 2), top.substr(3, 2)),
bottom: max(top.substr(3, 2), top.substr(5, 2)),
left: max(top.substr(5, 2), left.substr(3, 2))
};
frameInfo.width = max(frameInfo.top, frameInfo.right, frameInfo.bottom, frameInfo.left);
me.el.setStyle('background-image', 'none');
}
if (me.frame === true && !frameInfo) {
}
me.frame = me.frame || !!frameInfo;
me.frameSize = frameInfo || false;
return frameInfo;
},
getFramePositions: function(frameInfo) {
var me = this,
frameWidth = frameInfo.width,
dock = me.dock,
positions, tc, bc, ml, mr;
if (frameInfo.vertical) {
tc = '0 -' + (frameWidth * 0) + 'px';
bc = '0 -' + (frameWidth * 1) + 'px';
if (dock && dock == "right") {
tc = 'right -' + (frameWidth * 0) + 'px';
bc = 'right -' + (frameWidth * 1) + 'px';
}
positions = {
tl: '0 -' + (frameWidth * 0) + 'px',
tr: '0 -' + (frameWidth * 1) + 'px',
bl: '0 -' + (frameWidth * 2) + 'px',
br: '0 -' + (frameWidth * 3) + 'px',
ml: '-' + (frameWidth * 1) + 'px 0',
mr: 'right 0',
tc: tc,
bc: bc
};
} else {
ml = '-' + (frameWidth * 0) + 'px 0';
mr = 'right 0';
if (dock && dock == "bottom") {
ml = 'left bottom';
mr = 'right bottom';
}
positions = {
tl: '0 -' + (frameWidth * 2) + 'px',
tr: 'right -' + (frameWidth * 3) + 'px',
bl: '0 -' + (frameWidth * 4) + 'px',
br: 'right -' + (frameWidth * 5) + 'px',
ml: ml,
mr: mr,
tc: '0 -' + (frameWidth * 0) + 'px',
bc: '0 -' + (frameWidth * 1) + 'px'
};
}
return positions;
},
getFrameTpl : function(table) {
return table ? this.getTpl('frameTableTpl') : this.getTpl('frameTpl');
},
initCls: function() {
var me = this,
cls = [];
cls.push(me.baseCls);
if (Ext.isDefined(me.cmpCls)) {
if (Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Ext.Component: cmpCls has been deprecated. Please use componentCls.');
}
me.componentCls = me.cmpCls;
delete me.cmpCls;
}
if (me.componentCls) {
cls.push(me.componentCls);
} else {
me.componentCls = me.baseCls;
}
if (me.cls) {
cls.push(me.cls);
delete me.cls;
}
return cls.concat(me.additionalCls);
},
setUI: function(ui) {
var me = this,
oldUICls = Ext.Array.clone(me.uiCls),
newUICls = [],
classes = [],
cls,
i;
for (i = 0; i < oldUICls.length; i++) {
cls = oldUICls[i];
classes = classes.concat(me.removeClsWithUI(cls, true));
newUICls.push(cls);
}
if (classes.length) {
me.removeCls(classes);
}
me.removeUIFromElement();
me.ui = ui;
me.addUIToElement();
classes = [];
for (i = 0; i < newUICls.length; i++) {
cls = newUICls[i];
classes = classes.concat(me.addClsWithUI(cls, true));
}
if (classes.length) {
me.addCls(classes);
}
},
addClsWithUI: function(cls, skip) {
var me = this,
classes = [],
i;
if (!Ext.isArray(cls)) {
cls = [cls];
}
for (i = 0; i < cls.length; i++) {
if (cls[i] && !me.hasUICls(cls[i])) {
me.uiCls = Ext.Array.clone(me.uiCls);
me.uiCls.push(cls[i]);
classes = classes.concat(me.addUIClsToElement(cls[i]));
}
}
if (skip !== true) {
me.addCls(classes);
}
return classes;
},
removeClsWithUI: function(cls, skip) {
var me = this,
classes = [],
i;
if (!Ext.isArray(cls)) {
cls = [cls];
}
for (i = 0; i < cls.length; i++) {
if (cls[i] && me.hasUICls(cls[i])) {
me.uiCls = Ext.Array.remove(me.uiCls, cls[i]);
classes = classes.concat(me.removeUIClsFromElement(cls[i]));
}
}
if (skip !== true) {
me.removeCls(classes);
}
return classes;
},
hasUICls: function(cls) {
var me = this,
uiCls = me.uiCls || [];
return Ext.Array.contains(uiCls, cls);
},
addUIClsToElement: function(cls, force) {
var me = this,
result = [],
frameElementCls = me.frameElementCls;
result.push(Ext.baseCSSPrefix + cls);
result.push(me.baseCls + '-' + cls);
result.push(me.baseCls + '-' + me.ui + '-' + cls);
if (!force && me.frame && !Ext.supports.CSS3BorderRadius) {
var els = ['tl', 'tc', 'tr', 'ml', 'mc', 'mr', 'bl', 'bc', 'br'],
classes, i, j, el;
for (i = 0; i < els.length; i++) {
el = me['frame' + els[i].toUpperCase()];
classes = [me.baseCls + '-' + me.ui + '-' + els[i], me.baseCls + '-' + me.ui + '-' + cls + '-' + els[i]];
if (el && el.dom) {
el.addCls(classes);
} else {
for (j = 0; j < classes.length; j++) {
if (Ext.Array.indexOf(frameElementCls[els[i]], classes[j]) == -1) {
frameElementCls[els[i]].push(classes[j]);
}
}
}
}
}
me.frameElementCls = frameElementCls;
return result;
},
removeUIClsFromElement: function(cls, force) {
var me = this,
result = [],
frameElementCls = me.frameElementCls;
result.push(Ext.baseCSSPrefix + cls);
result.push(me.baseCls + '-' + cls);
result.push(me.baseCls + '-' + me.ui + '-' + cls);
if (!force && me.frame && !Ext.supports.CSS3BorderRadius) {
var els = ['tl', 'tc', 'tr', 'ml', 'mc', 'mr', 'bl', 'bc', 'br'],
i, el;
cls = me.baseCls + '-' + me.ui + '-' + cls + '-' + els[i];
for (i = 0; i < els.length; i++) {
el = me['frame' + els[i].toUpperCase()];
if (el && el.dom) {
el.removeCls(cls);
} else {
Ext.Array.remove(frameElementCls[els[i]], cls);
}
}
}
me.frameElementCls = frameElementCls;
return result;
},
addUIToElement: function(force) {
var me = this,
frameElementCls = me.frameElementCls;
me.addCls(me.baseCls + '-' + me.ui);
if (me.frame && !Ext.supports.CSS3BorderRadius) {
var els = ['tl', 'tc', 'tr', 'ml', 'mc', 'mr', 'bl', 'bc', 'br'],
i, el, cls;
for (i = 0; i < els.length; i++) {
el = me['frame' + els[i].toUpperCase()];
cls = me.baseCls + '-' + me.ui + '-' + els[i];
if (el) {
el.addCls(cls);
} else {
if (!Ext.Array.contains(frameElementCls[els[i]], cls)) {
frameElementCls[els[i]].push(cls);
}
}
}
}
},
removeUIFromElement: function() {
var me = this,
frameElementCls = me.frameElementCls;
me.removeCls(me.baseCls + '-' + me.ui);
if (me.frame && !Ext.supports.CSS3BorderRadius) {
var els = ['tl', 'tc', 'tr', 'ml', 'mc', 'mr', 'bl', 'bc', 'br'],
i, j, el, cls;
for (i = 0; i < els.length; i++) {
el = me['frame' + els[i].toUpperCase()];
cls = me.baseCls + '-' + me.ui + '-' + els[i];
if (el) {
el.removeCls(cls);
} else {
Ext.Array.remove(frameElementCls[els[i]], cls);
}
}
}
},
getElConfig : function() {
var result = this.autoEl || {tag: 'div'};
result.id = this.id;
return result;
},
getInsertPosition: function(position) {
if (position !== undefined) {
if (Ext.isNumber(position)) {
position = this.container.dom.childNodes[position];
}
else {
position = Ext.getDom(position);
}
}
return position;
},
initContainer: function(container) {
var me = this;
if (!container && me.el) {
container = me.el.dom.parentNode;
me.allowDomMove = false;
}
me.container = Ext.get(container);
if (me.ctCls) {
me.container.addCls(me.ctCls);
}
return me.container;
},
initRenderData: function() {
var me = this;
return Ext.applyIf(me.renderData, {
ui: me.ui,
uiCls: me.uiCls,
baseCls: me.baseCls,
componentCls: me.componentCls,
frame: me.frame
});
},
getTpl: function(name) {
var me = this,
prototype = me.self.prototype,
ownerPrototype,
tpl;
if (me.hasOwnProperty(name)) {
tpl = me[name];
if (tpl && !(tpl instanceof Ext.XTemplate)) {
me[name] = Ext.ClassManager.dynInstantiate('Ext.XTemplate', tpl);
}
return me[name];
}
if (!(prototype[name] instanceof Ext.XTemplate)) {
ownerPrototype = prototype;
do {
if (ownerPrototype.hasOwnProperty(name)) {
tpl = ownerPrototype[name];
if (tpl && !(tpl instanceof Ext.XTemplate)) {
ownerPrototype[name] = Ext.ClassManager.dynInstantiate('Ext.XTemplate', tpl);
break;
}
}
ownerPrototype = ownerPrototype.superclass;
} while (ownerPrototype);
}
return prototype[name];
},
initRenderTpl: function() {
return this.getTpl('renderTpl');
},
initStyles: function() {
var style = {},
me = this,
Element = Ext.core.Element;
if (Ext.isString(me.style)) {
style = Element.parseStyles(me.style);
} else {
style = Ext.apply({}, me.style);
}
if (me.padding !== undefined) {
style.padding = Element.unitizeBox((me.padding === true) ? 5 : me.padding);
}
if (me.margin !== undefined) {
style.margin = Element.unitizeBox((me.margin === true) ? 5 : me.margin);
}
delete me.style;
return style;
},
initContent: function() {
var me = this,
target = me.getTargetEl(),
contentEl,
pre;
if (me.html) {
target.update(Ext.core.DomHelper.markup(me.html));
delete me.html;
}
if (me.contentEl) {
contentEl = Ext.get(me.contentEl);
pre = Ext.baseCSSPrefix;
contentEl.removeCls([pre + 'hidden', pre + 'hide-display', pre + 'hide-offsets', pre + 'hide-nosize']);
target.appendChild(contentEl.dom);
}
if (me.tpl) {
if (!me.tpl.isTemplate) {
me.tpl = Ext.create('Ext.XTemplate', me.tpl);
}
if (me.data) {
me.tpl[me.tplWriteMode](target, me.data);
delete me.data;
}
}
},
initEvents : function() {
var me = this,
afterRenderEvents = me.afterRenderEvents,
el,
property,
fn = function(listeners){
me.mon(el, listeners);
};
if (afterRenderEvents) {
for (property in afterRenderEvents) {
if (afterRenderEvents.hasOwnProperty(property)) {
el = me[property];
if (el && el.on) {
Ext.each(afterRenderEvents[property], fn);
}
}
}
}
},
applyRenderSelectors: function() {
var selectors = this.renderSelectors || {},
el = this.el.dom,
selector;
for (selector in selectors) {
if (selectors.hasOwnProperty(selector) && selectors[selector]) {
this[selector] = Ext.get(Ext.DomQuery.selectNode(selectors[selector], el));
}
}
},
is: function(selector) {
return Ext.ComponentQuery.is(this, selector);
},
up: function(selector) {
var result = this.ownerCt;
if (selector) {
for (; result; result = result.ownerCt) {
if (Ext.ComponentQuery.is(result, selector)) {
return result;
}
}
}
return result;
},
nextSibling: function(selector) {
var o = this.ownerCt, it, last, idx, c;
if (o) {
it = o.items;
idx = it.indexOf(this) + 1;
if (idx) {
if (selector) {
for (last = it.getCount(); idx < last; idx++) {
if ((c = it.getAt(idx)).is(selector)) {
return c;
}
}
} else {
if (idx < it.getCount()) {
return it.getAt(idx);
}
}
}
}
return null;
},
previousSibling: function(selector) {
var o = this.ownerCt, it, idx, c;
if (o) {
it = o.items;
idx = it.indexOf(this);
if (idx != -1) {
if (selector) {
for (--idx; idx >= 0; idx--) {
if ((c = it.getAt(idx)).is(selector)) {
return c;
}
}
} else {
if (idx) {
return it.getAt(--idx);
}
}
}
}
return null;
},
previousNode: function(selector, includeSelf) {
var node = this,
result,
it, len, i;
if (includeSelf && node.is(selector)) {
return node;
}
result = this.prev(selector);
if (result) {
return result;
}
if (node.ownerCt) {
for (it = node.ownerCt.items.items, i = Ext.Array.indexOf(it, node) - 1; i > -1; i--) {
if (it[i].query) {
result = it[i].query(selector);
result = result[result.length - 1];
if (result) {
return result;
}
}
}
return node.ownerCt.previousNode(selector, true);
}
},
nextNode: function(selector, includeSelf) {
var node = this,
result,
it, len, i;
if (includeSelf && node.is(selector)) {
return node;
}
result = this.next(selector);
if (result) {
return result;
}
if (node.ownerCt) {
for (it = node.ownerCt.items, i = it.indexOf(node) + 1, it = it.items, len = it.length; i < len; i++) {
if (it[i].down) {
result = it[i].down(selector);
if (result) {
return result;
}
}
}
return node.ownerCt.nextNode(selector);
}
},
getId : function() {
return this.id || (this.id = 'ext-comp-' + (this.getAutoId()));
},
getItemId : function() {
return this.itemId || this.id;
},
getEl : function() {
return this.el;
},
getTargetEl: function() {
return this.frameBody || this.el;
},
isXType: function(xtype, shallow) {
if (Ext.isFunction(xtype)) {
xtype = xtype.xtype;
} else if (Ext.isObject(xtype)) {
xtype = xtype.statics().xtype;
}
return !shallow ? ('/' + this.getXTypes() + '/').indexOf('/' + xtype + '/') != -1: this.self.xtype == xtype;
},
getXTypes: function() {
var self = this.self,
xtypes = [],
parentPrototype = this,
xtype;
if (!self.xtypes) {
while (parentPrototype && Ext.getClass(parentPrototype)) {
xtype = Ext.getClass(parentPrototype).xtype;
if (xtype !== undefined) {
xtypes.unshift(xtype);
}
parentPrototype = parentPrototype.superclass;
}
self.xtypeChain = xtypes;
self.xtypes = xtypes.join('/');
}
return self.xtypes;
},
update : function(htmlOrData, loadScripts, cb) {
var me = this;
if (me.tpl && !Ext.isString(htmlOrData)) {
me.data = htmlOrData;
if (me.rendered) {
me.tpl[me.tplWriteMode](me.getTargetEl(), htmlOrData || {});
}
} else {
me.html = Ext.isObject(htmlOrData) ? Ext.core.DomHelper.markup(htmlOrData) : htmlOrData;
if (me.rendered) {
me.getTargetEl().update(me.html, loadScripts, cb);
}
}
if (me.rendered) {
me.doComponentLayout();
}
},
setVisible : function(visible) {
return this[visible ? 'show': 'hide']();
},
isVisible: function(deep) {
var me = this,
child = me,
visible = !me.hidden,
ancestor = me.ownerCt;
me.hiddenAncestor = false;
if (me.destroyed) {
return false;
}
if (deep && visible && me.rendered && ancestor) {
while (ancestor) {
if (ancestor.hidden || (ancestor.collapsed &&
!(ancestor.getDockedItems && Ext.Array.contains(ancestor.getDockedItems(), child)))) {
me.hiddenAncestor = ancestor;
visible = false;
break;
}
child = ancestor;
ancestor = ancestor.ownerCt;
}
}
return visible;
},
enable: function(silent) {
var me = this;
if (me.rendered) {
me.el.removeCls(me.disabledCls);
me.el.dom.disabled = false;
me.onEnable();
}
me.disabled = false;
if (silent !== true) {
me.fireEvent('enable', me);
}
return me;
},
disable: function(silent) {
var me = this;
if (me.rendered) {
me.el.addCls(me.disabledCls);
me.el.dom.disabled = true;
me.onDisable();
}
me.disabled = true;
if (silent !== true) {
me.fireEvent('disable', me);
}
return me;
},
onEnable: function() {
if (this.maskOnDisable) {
this.el.unmask();
}
},
onDisable : function() {
if (this.maskOnDisable) {
this.el.mask();
}
},
isDisabled : function() {
return this.disabled;
},
setDisabled : function(disabled) {
return this[disabled ? 'disable': 'enable']();
},
isHidden : function() {
return this.hidden;
},
addCls : function(className) {
var me = this;
if (!className) {
return me;
}
if (!Ext.isArray(className)){
className = className.replace(me.trimRe, '').split(me.spacesRe);
}
if (me.rendered) {
me.el.addCls(className);
}
else {
me.additionalCls = Ext.Array.unique(me.additionalCls.concat(className));
}
return me;
},
addClass : function() {
return this.addCls.apply(this, arguments);
},
removeCls : function(className) {
var me = this;
if (!className) {
return me;
}
if (!Ext.isArray(className)){
className = className.replace(me.trimRe, '').split(me.spacesRe);
}
if (me.rendered) {
me.el.removeCls(className);
}
else if (me.additionalCls.length) {
Ext.each(className, function(cls) {
Ext.Array.remove(me.additionalCls, cls);
});
}
return me;
},
addOverCls: function() {
var me = this;
if (!me.disabled) {
me.el.addCls(me.overCls);
}
},
removeOverCls: function() {
this.el.removeCls(this.overCls);
},
addListener : function(element, listeners, scope, options) {
var me = this,
fn,
option;
if (Ext.isString(element) && (Ext.isObject(listeners) || options && options.element)) {
if (options.element) {
fn = listeners;
listeners = {};
listeners[element] = fn;
element = options.element;
if (scope) {
listeners.scope = scope;
}
for (option in options) {
if (options.hasOwnProperty(option)) {
if (me.eventOptionsRe.test(option)) {
listeners[option] = options[option];
}
}
}
}
if (me[element] && me[element].on) {
me.mon(me[element], listeners);
} else {
me.afterRenderEvents = me.afterRenderEvents || {};
if (!me.afterRenderEvents[element]) {
me.afterRenderEvents[element] = [];
}
me.afterRenderEvents[element].push(listeners);
}
}
return me.mixins.observable.addListener.apply(me, arguments);
},
removeManagedListenerItem: function(isClear, managedListener, item, ename, fn, scope){
var me = this,
element = managedListener.options ? managedListener.options.element : null;
if (element) {
element = me[element];
if (element && element.un) {
if (isClear || (managedListener.item === item && managedListener.ename === ename && (!fn || managedListener.fn === fn) && (!scope || managedListener.scope === scope))) {
element.un(managedListener.ename, managedListener.fn, managedListener.scope);
if (!isClear) {
Ext.Array.remove(me.managedListeners, managedListener);
}
}
}
} else {
return me.mixins.observable.removeManagedListenerItem.apply(me, arguments);
}
},
getBubbleTarget : function() {
return this.ownerCt;
},
isFloating : function() {
return this.floating;
},
isDraggable : function() {
return !!this.draggable;
},
isDroppable : function() {
return !!this.droppable;
},
onAdded : function(container, pos) {
this.ownerCt = container;
this.fireEvent('added', this, container, pos);
},
onRemoved : function() {
var me = this;
me.fireEvent('removed', me, me.ownerCt);
delete me.ownerCt;
},
beforeDestroy : Ext.emptyFn,
onResize : Ext.emptyFn,
setSize : function(width, height) {
var me = this,
layoutCollection;
if (Ext.isObject(width)) {
height = width.height;
width = width.width;
}
if (Ext.isNumber(width)) {
width = Ext.Number.constrain(width, me.minWidth, me.maxWidth);
}
if (Ext.isNumber(height)) {
height = Ext.Number.constrain(height, me.minHeight, me.maxHeight);
}
if (!me.rendered || !me.isVisible()) {
if (me.hiddenAncestor) {
layoutCollection = me.hiddenAncestor.layoutOnShow;
layoutCollection.remove(me);
layoutCollection.add(me);
}
me.needsLayout = {
width: width,
height: height,
isSetSize: true
};
if (!me.rendered) {
me.width = (width !== undefined) ? width : me.width;
me.height = (height !== undefined) ? height : me.height;
}
return me;
}
me.doComponentLayout(width, height, true);
return me;
},
isFixedWidth: function() {
var me = this,
layoutManagedWidth = me.layoutManagedWidth;
if (Ext.isDefined(me.width) || layoutManagedWidth == 1) {
return true;
}
if (layoutManagedWidth == 2) {
return false;
}
return (me.ownerCt && me.ownerCt.isFixedWidth());
},
isFixedHeight: function() {
var me = this,
layoutManagedHeight = me.layoutManagedHeight;
if (Ext.isDefined(me.height) || layoutManagedHeight == 1) {
return true;
}
if (layoutManagedHeight == 2) {
return false;
}
return (me.ownerCt && me.ownerCt.isFixedHeight());
},
setCalculatedSize : function(width, height, callingContainer) {
var me = this,
layoutCollection;
if (Ext.isObject(width)) {
callingContainer = width.ownerCt;
height = width.height;
width = width.width;
}
if (Ext.isNumber(width)) {
width = Ext.Number.constrain(width, me.minWidth, me.maxWidth);
}
if (Ext.isNumber(height)) {
height = Ext.Number.constrain(height, me.minHeight, me.maxHeight);
}
if (!me.rendered || !me.isVisible()) {
if (me.hiddenAncestor) {
layoutCollection = me.hiddenAncestor.layoutOnShow;
layoutCollection.remove(me);
layoutCollection.add(me);
}
me.needsLayout = {
width: width,
height: height,
isSetSize: false,
ownerCt: callingContainer
};
return me;
}
me.doComponentLayout(width, height, false, callingContainer);
return me;
},
doComponentLayout : function(width, height, isSetSize, callingContainer) {
var me = this,
componentLayout = me.getComponentLayout(),
lastComponentSize = componentLayout.lastComponentSize || {
width: undefined,
height: undefined
};
if (me.rendered && componentLayout) {
if (!Ext.isDefined(width)) {
if (me.isFixedWidth()) {
width = Ext.isDefined(me.width) ? me.width : lastComponentSize.width;
}
}
if (!Ext.isDefined(height)) {
if (me.isFixedHeight()) {
height = Ext.isDefined(me.height) ? me.height : lastComponentSize.height;
}
}
if (isSetSize) {
me.width = width;
me.height = height;
}
componentLayout.layout(width, height, isSetSize, callingContainer);
}
return me;
},
forceComponentLayout: function () {
this.doComponentLayout();
},
setComponentLayout : function(layout) {
var currentLayout = this.componentLayout;
if (currentLayout && currentLayout.isLayout && currentLayout != layout) {
currentLayout.setOwner(null);
}
this.componentLayout = layout;
layout.setOwner(this);
},
getComponentLayout : function() {
var me = this;
if (!me.componentLayout || !me.componentLayout.isLayout) {
me.setComponentLayout(Ext.layout.Layout.create(me.componentLayout, 'autocomponent'));
}
return me.componentLayout;
},
afterComponentLayout: function(width, height, isSetSize, callingContainer) {
++this.componentLayoutCounter;
this.fireEvent('resize', this, width, height);
},
beforeComponentLayout: function(width, height, isSetSize, callingContainer) {
return true;
},
setPosition : function(x, y) {
var me = this;
if (Ext.isObject(x)) {
y = x.y;
x = x.x;
}
if (!me.rendered) {
return me;
}
if (x !== undefined || y !== undefined) {
me.el.setBox(x, y);
me.onPosition(x, y);
me.fireEvent('move', me, x, y);
}
return me;
},
onPosition: Ext.emptyFn,
setWidth : function(width) {
return this.setSize(width);
},
setHeight : function(height) {
return this.setSize(undefined, height);
},
getSize : function() {
return this.el.getSize();
},
getWidth : function() {
return this.el.getWidth();
},
getHeight : function() {
return this.el.getHeight();
},
getLoader: function(){
var me = this,
autoLoad = me.autoLoad ? (Ext.isObject(me.autoLoad) ? me.autoLoad : {url: me.autoLoad}) : null,
loader = me.loader || autoLoad;
if (loader) {
if (!loader.isLoader) {
me.loader = Ext.create('Ext.ComponentLoader', Ext.apply({
target: me,
autoLoad: autoLoad
}, loader));
} else {
loader.setTarget(me);
}
return me.loader;
}
return null;
},
setLoading : function(load, targetEl) {
var me = this,
config;
if (me.rendered) {
if (load !== false && !me.collapsed) {
if (Ext.isObject(load)) {
config = load;
}
else if (Ext.isString(load)) {
config = {msg: load};
}
else {
config = {};
}
me.loadMask = me.loadMask || Ext.create('Ext.LoadMask', targetEl ? me.getTargetEl() : me.el, config);
me.loadMask.show();
} else if (me.loadMask) {
Ext.destroy(me.loadMask);
me.loadMask = null;
}
}
return me.loadMask;
},
setDocked : function(dock, layoutParent) {
var me = this;
me.dock = dock;
if (layoutParent && me.ownerCt && me.rendered) {
me.ownerCt.doComponentLayout();
}
return me;
},
onDestroy : function() {
var me = this;
if (me.monitorResize && Ext.EventManager.resizeEvent) {
Ext.EventManager.resizeEvent.removeListener(me.setSize, me);
}
Ext.destroy(me.componentLayout, me.loadMask);
},
destroy : function() {
var me = this;
if (!me.isDestroyed) {
if (me.fireEvent('beforedestroy', me) !== false) {
me.destroying = true;
me.beforeDestroy();
if (me.floating) {
delete me.floatParent;
if (me.zIndexManager) {
me.zIndexManager.unregister(me);
}
} else if (me.ownerCt && me.ownerCt.remove) {
me.ownerCt.remove(me, false);
}
me.onDestroy();
Ext.destroy(me.plugins);
if (me.rendered) {
me.el.remove();
}
Ext.ComponentManager.unregister(me);
me.fireEvent('destroy', me);
me.mixins.state.destroy.call(me);
me.clearListeners();
me.destroying = false;
me.isDestroyed = true;
}
}
},
getPlugin: function(pluginId) {
var i = 0,
plugins = this.plugins,
ln = plugins.length;
for (; i < ln; i++) {
if (plugins[i].pluginId === pluginId) {
return plugins[i];
}
}
},
isDescendantOf: function(container) {
return !!this.findParentBy(function(p){
return p === container;
});
}
}, function() {
this.createAlias({
on: 'addListener',
prev: 'previousSibling',
next: 'nextSibling'
});
});
Ext.define('Ext.AbstractPlugin', {
disabled: false,
constructor: function(config) {
Ext.apply(this, config);
},
getCmp: function() {
return this.cmp;
},
init: Ext.emptyFn,
destroy: Ext.emptyFn,
enable: function() {
this.disabled = false;
},
disable: function() {
this.disabled = true;
}
});
Ext.define('Ext.data.Connection', {
mixins: {
observable: 'Ext.util.Observable'
},
statics: {
requestId: 0
},
url: null,
async: true,
method: null,
username: '',
password: '',
disableCaching: true,
disableCachingParam: '_dc',
timeout : 30000,
useDefaultHeader : true,
defaultPostHeader : 'application/x-www-form-urlencoded; charset=UTF-8',
useDefaultXhrHeader : true,
defaultXhrHeader : 'XMLHttpRequest',
constructor : function(config) {
config = config || {};
Ext.apply(this, config);
this.addEvents(
'beforerequest',
'requestcomplete',
'requestexception'
);
this.requests = {};
this.mixins.observable.constructor.call(this);
},
request : function(options) {
options = options || {};
var me = this,
scope = options.scope || window,
username = options.username || me.username,
password = options.password || me.password || '',
async,
requestOptions,
request,
headers,
xhr;
if (me.fireEvent('beforerequest', me, options) !== false) {
requestOptions = me.setOptions(options, scope);
if (this.isFormUpload(options) === true) {
this.upload(options.form, requestOptions.url, requestOptions.data, options);
return null;
}
if (options.autoAbort === true || me.autoAbort) {
me.abort();
}
xhr = this.getXhrInstance();
async = options.async !== false ? (options.async || me.async) : false;
if (username) {
xhr.open(requestOptions.method, requestOptions.url, async, username, password);
} else {
xhr.open(requestOptions.method, requestOptions.url, async);
}
headers = me.setupHeaders(xhr, options, requestOptions.data, requestOptions.params);
request = {
id: ++Ext.data.Connection.requestId,
xhr: xhr,
headers: headers,
options: options,
async: async,
timeout: setTimeout(function() {
request.timedout = true;
me.abort(request);
}, options.timeout || me.timeout)
};
me.requests[request.id] = request;
if (async) {
xhr.onreadystatechange = Ext.Function.bind(me.onStateChange, me, [request]);
}
xhr.send(requestOptions.data);
if (!async) {
return this.onComplete(request);
}
return request;
} else {
Ext.callback(options.callback, options.scope, [options, undefined, undefined]);
return null;
}
},
upload: function(form, url, params, options){
form = Ext.getDom(form);
options = options || {};
var id = Ext.id(),
frame = document.createElement('iframe'),
hiddens = [],
encoding = 'multipart/form-data',
buf = {
target: form.target,
method: form.method,
encoding: form.encoding,
enctype: form.enctype,
action: form.action
}, hiddenItem;
Ext.fly(frame).set({
id: id,
name: id,
cls: Ext.baseCSSPrefix + 'hide-display',
src: Ext.SSL_SECURE_URL
});
document.body.appendChild(frame);
if (document.frames) {
document.frames[id].name = id;
}
Ext.fly(form).set({
target: id,
method: 'POST',
enctype: encoding,
encoding: encoding,
action: url || buf.action
});
if (params) {
Ext.iterate(Ext.Object.fromQueryString(params), function(name, value){
hiddenItem = document.createElement('input');
Ext.fly(hiddenItem).set({
type: 'hidden',
value: value,
name: name
});
form.appendChild(hiddenItem);
hiddens.push(hiddenItem);
});
}
Ext.fly(frame).on('load', Ext.Function.bind(this.onUploadComplete, this, [frame, options]), null, {single: true});
form.submit();
Ext.fly(form).set(buf);
Ext.each(hiddens, function(h) {
Ext.removeNode(h);
});
},
onUploadComplete: function(frame, options){
var me = this,
response = {
responseText: '',
responseXML: null
}, doc, firstChild;
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)) {
response.responseText = firstChild.value;
} else {
response.responseText = doc.body.innerHTML;
}
}
response.responseXML = doc.XMLDocument || doc;
}
} catch (e) {
}
me.fireEvent('requestcomplete', me, response, options);
Ext.callback(options.success, options.scope, [response, options]);
Ext.callback(options.callback, options.scope, [options, true, response]);
setTimeout(function(){
Ext.removeNode(frame);
}, 100);
},
isFormUpload: function(options){
var form = this.getForm(options);
if (form) {
return (options.isUpload || (/multipart\/form-data/i).test(form.getAttribute('enctype')));
}
return false;
},
getForm: function(options){
return Ext.getDom(options.form) || null;
},
setOptions: function(options, scope){
var me = this,
params = options.params || {},
extraParams = me.extraParams,
urlParams = options.urlParams,
url = options.url || me.url,
jsonData = options.jsonData,
method,
disableCache,
data;
if (Ext.isFunction(params)) {
params = params.call(scope, options);
}
if (Ext.isFunction(url)) {
url = url.call(scope, options);
}
url = this.setupUrl(options, url);
data = options.rawData || options.xmlData || jsonData || null;
if (jsonData && !Ext.isPrimitive(jsonData)) {
data = Ext.encode(data);
}
if (Ext.isObject(params)) {
params = Ext.Object.toQueryString(params);
}
if (Ext.isObject(extraParams)) {
extraParams = Ext.Object.toQueryString(extraParams);
}
params = params + ((extraParams) ? ((params) ? '&' : '') + extraParams : '');
urlParams = Ext.isObject(urlParams) ? Ext.Object.toQueryString(urlParams) : urlParams;
params = this.setupParams(options, params);
method = (options.method || me.method || ((params || data) ? 'POST' : 'GET')).toUpperCase();
this.setupMethod(options, method);
disableCache = options.disableCaching !== false ? (options.disableCaching || me.disableCaching) : false;
if (method === 'GET' && disableCache) {
url = Ext.urlAppend(url, (options.disableCachingParam || me.disableCachingParam) + '=' + (new Date().getTime()));
}
if ((method == 'GET' || data) && params) {
url = Ext.urlAppend(url, params);
params = null;
}
if (urlParams) {
url = Ext.urlAppend(url, urlParams);
}
return {
url: url,
method: method,
data: data || params || null
};
},
setupUrl: function(options, url){
var form = this.getForm(options);
if (form) {
url = url || form.action;
}
return url;
},
setupParams: function(options, params) {
var form = this.getForm(options),
serializedForm;
if (form && !this.isFormUpload(options)) {
serializedForm = Ext.core.Element.serializeForm(form);
params = params ? (params + '&' + serializedForm) : serializedForm;
}
return params;
},
setupMethod: function(options, method){
if (this.isFormUpload(options)) {
return 'POST';
}
return method;
},
setupHeaders: function(xhr, options, data, params){
var me = this,
headers = Ext.apply({}, options.headers || {}, me.defaultHeaders || {}),
contentType = me.defaultPostHeader,
jsonData = options.jsonData,
xmlData = options.xmlData,
key,
header;
if (!headers['Content-Type'] && (data || params)) {
if (data) {
if (options.rawData) {
contentType = 'text/plain';
} else {
if (xmlData && Ext.isDefined(xmlData)) {
contentType = 'text/xml';
} else if (jsonData && Ext.isDefined(jsonData)) {
contentType = 'application/json';
}
}
}
headers['Content-Type'] = contentType;
}
if (me.useDefaultXhrHeader && !headers['X-Requested-With']) {
headers['X-Requested-With'] = me.defaultXhrHeader;
}
try{
for (key in headers) {
if (headers.hasOwnProperty(key)) {
header = headers[key];
xhr.setRequestHeader(key, header);
}
}
} catch(e) {
me.fireEvent('exception', key, header);
}
return headers;
},
getXhrInstance: (function(){
var options = [function(){
return new XMLHttpRequest();
}, function(){
return new ActiveXObject('MSXML2.XMLHTTP.3.0');
}, function(){
return new ActiveXObject('MSXML2.XMLHTTP');
}, function(){
return new ActiveXObject('Microsoft.XMLHTTP');
}], i = 0,
len = options.length,
xhr;
for(; i < len; ++i) {
try{
xhr = options[i];
xhr();
break;
}catch(e){}
}
return xhr;
})(),
isLoading : function(request) {
if (!(request && request.xhr)) {
return false;
}
var state = request.xhr.readyState;
return !(state === 0 || state == 4);
},
abort : function(request) {
var me = this,
requests = me.requests,
id;
if (request && me.isLoading(request)) {
request.xhr.onreadystatechange = null;
request.xhr.abort();
me.clearTimeout(request);
if (!request.timedout) {
request.aborted = true;
}
me.onComplete(request);
me.cleanup(request);
} else if (!request) {
for(id in requests) {
if (requests.hasOwnProperty(id)) {
me.abort(requests[id]);
}
}
}
},
onStateChange : function(request) {
if (request.xhr.readyState == 4) {
this.clearTimeout(request);
this.onComplete(request);
this.cleanup(request);
}
},
clearTimeout: function(request){
clearTimeout(request.timeout);
delete request.timeout;
},
cleanup: function(request){
request.xhr = null;
delete request.xhr;
},
onComplete : function(request) {
var me = this,
options = request.options,
result,
success,
response;
try {
result = me.parseStatus(request.xhr.status);
} catch (e) {
result = {
success : false,
isException : false
};
}
success = result.success;
if (success) {
response = me.createResponse(request);
me.fireEvent('requestcomplete', me, response, options);
Ext.callback(options.success, options.scope, [response, options]);
} else {
if (result.isException || request.aborted || request.timedout) {
response = me.createException(request);
} else {
response = me.createResponse(request);
}
me.fireEvent('requestexception', me, response, options);
Ext.callback(options.failure, options.scope, [response, options]);
}
Ext.callback(options.callback, options.scope, [options, success, response]);
delete me.requests[request.id];
return response;
},
parseStatus: function(status) {
status = status == 1223 ? 204 : status;
var success = (status >= 200 && status < 300) || status == 304,
isException = false;
if (!success) {
switch (status) {
case 12002:
case 12029:
case 12030:
case 12031:
case 12152:
case 13030:
isException = true;
break;
}
}
return {
success: success,
isException: isException
};
},
createResponse : function(request) {
var xhr = request.xhr,
headers = {},
lines = xhr.getAllResponseHeaders().replace(/\r\n/g, '\n').split('\n'),
count = lines.length,
line, index, key, value, response;
while (count--) {
line = lines[count];
index = line.indexOf(':');
if(index >= 0) {
key = line.substr(0, index).toLowerCase();
if (line.charAt(index + 1) == ' ') {
++index;
}
headers[key] = line.substr(index + 1);
}
}
request.xhr = null;
delete request.xhr;
response = {
request: request,
requestId : request.id,
status : xhr.status,
statusText : xhr.statusText,
getResponseHeader : function(header){ return headers[header.toLowerCase()]; },
getAllResponseHeaders : function(){ return headers; },
responseText : xhr.responseText,
responseXML : xhr.responseXML
};
xhr = null;
return response;
},
createException : function(request) {
return {
request : request,
requestId : request.id,
status : request.aborted ? -1 : 0,
statusText : request.aborted ? 'transaction aborted' : 'communication failure',
aborted: request.aborted,
timedout: request.timedout
};
}
});
Ext.define('Ext.Ajax', {
extend: 'Ext.data.Connection',
singleton: true,
autoAbort : false
});
Ext.define('Ext.data.Association', {
primaryKey: 'id',
defaultReaderType: 'json',
statics: {
create: function(association){
if (!association.isAssociation) {
if (Ext.isString(association)) {
association = {
type: association
};
}
switch (association.type) {
case 'belongsTo':
return Ext.create('Ext.data.BelongsToAssociation', association);
case 'hasMany':
return Ext.create('Ext.data.HasManyAssociation', association);
default:
}
}
return association;
}
},
constructor: function(config) {
Ext.apply(this, config);
var types = Ext.ModelManager.types,
ownerName = config.ownerModel,
associatedName = config.associatedModel,
ownerModel = types[ownerName],
associatedModel = types[associatedName],
ownerProto;
this.ownerModel = ownerModel;
this.associatedModel = associatedModel;
Ext.applyIf(this, {
ownerName : ownerName,
associatedName: associatedName
});
},
getReader: function(){
var me = this,
reader = me.reader,
model = me.associatedModel;
if (reader) {
if (Ext.isString(reader)) {
reader = {
type: reader
};
}
if (reader.isReader) {
reader.setModel(model);
} else {
Ext.applyIf(reader, {
model: model,
type : me.defaultReaderType
});
}
me.reader = Ext.createByAlias('reader.' + reader.type, reader);
}
return me.reader || null;
}
});
Ext.define('Ext.ModelManager', {
extend: 'Ext.AbstractManager',
alternateClassName: 'Ext.ModelMgr',
requires: ['Ext.data.Association'],
singleton: true,
typeName: 'mtype',
associationStack: [],
registerType: function(name, config) {
var proto = config.prototype,
model;
if (proto && proto.isModel) {
model = config;
} else {
if (!config.extend) {
config.extend = 'Ext.data.Model';
}
model = Ext.define(name, config);
}
this.types[name] = model;
return model;
},
onModelDefined: function(model) {
var stack = this.associationStack,
length = stack.length,
create = [],
association, i, created;
for (i = 0; i < length; i++) {
association = stack[i];
if (association.associatedModel == model.modelName) {
create.push(association);
}
}
for (i = 0, length = create.length; i < length; i++) {
created = create[i];
this.types[created.ownerModel].prototype.associations.add(Ext.data.Association.create(created));
Ext.Array.remove(stack, created);
}
},
registerDeferredAssociation: function(association){
this.associationStack.push(association);
},
getModel: function(id) {
var model = id;
if (typeof model == 'string') {
model = this.types[model];
}
return model;
},
create: function(config, name, id) {
var con = typeof name == 'function' ? name : this.types[name || config.name];
return new con(config, id);
}
}, function() {
Ext.regModel = function() {
return this.ModelManager.registerType.apply(this.ModelManager, arguments);
};
});
Ext.define('Ext.app.Controller', {
mixins: {
observable: 'Ext.util.Observable'
},
onClassExtended: function(cls, data) {
var className = Ext.getClassName(cls),
match = className.match(/^(.*)\.controller\./);
if (match !== null) {
var namespace = Ext.Loader.getPrefix(className) || match[1],
onBeforeClassCreated = data.onBeforeClassCreated,
requires = [],
modules = ['model', 'view', 'store'],
prefix;
data.onBeforeClassCreated = function(cls, data) {
var i, ln, module,
items, j, subLn, item;
for (i = 0,ln = modules.length; i < ln; i++) {
module = modules[i];
items = Ext.Array.from(data[module + 's']);
for (j = 0,subLn = items.length; j < subLn; j++) {
item = items[j];
prefix = Ext.Loader.getPrefix(item);
if (prefix === '' || prefix === item) {
requires.push(namespace + '.' + module + '.' + item);
}
else {
requires.push(item);
}
}
}
Ext.require(requires, Ext.Function.pass(onBeforeClassCreated, arguments, this));
};
}
},
constructor: function(config) {
this.mixins.observable.constructor.call(this, config);
Ext.apply(this, config || {});
this.createGetters('model', this.models);
this.createGetters('store', this.stores);
this.createGetters('view', this.views);
if (this.refs) {
this.ref(this.refs);
}
},
init: function(application) {},
onLaunch: function(application) {},
createGetters: function(type, refs) {
type = Ext.String.capitalize(type);
Ext.Array.each(refs, function(ref) {
var fn = 'get',
parts = ref.split('.');
Ext.Array.each(parts, function(part) {
fn += Ext.String.capitalize(part);
});
fn += type;
if (!this[fn]) {
this[fn] = Ext.Function.pass(this['get' + type], [ref], this);
}
this[fn](ref);
},
this);
},
ref: function(refs) {
var me = this;
refs = Ext.Array.from(refs);
Ext.Array.each(refs, function(info) {
var ref = info.ref,
fn = 'get' + Ext.String.capitalize(ref);
if (!me[fn]) {
me[fn] = Ext.Function.pass(me.getRef, [ref, info], me);
}
});
},
getRef: function(ref, info, config) {
this.refCache = this.refCache || {};
info = info || {};
config = config || {};
Ext.apply(info, config);
if (info.forceCreate) {
return Ext.ComponentManager.create(info, 'component');
}
var me = this,
selector = info.selector,
cached = me.refCache[ref];
if (!cached) {
me.refCache[ref] = cached = Ext.ComponentQuery.query(info.selector)[0];
if (!cached && info.autoCreate) {
me.refCache[ref] = cached = Ext.ComponentManager.create(info, 'component');
}
if (cached) {
cached.on('beforedestroy', function() {
me.refCache[ref] = null;
});
}
}
return cached;
},
control: function(selectors, listeners) {
this.application.control(selectors, listeners, this);
},
getController: function(name) {
return this.application.getController(name);
},
getStore: function(name) {
return this.application.getStore(name);
},
getModel: function(model) {
return this.application.getModel(model);
},
getView: function(view) {
return this.application.getView(view);
}
});
Ext.define('Ext.data.SortTypes', {
singleton: true,
none : function(s) {
return s;
},
stripTagsRE : /<\/?[^>]+>/gi,
asText : function(s) {
return String(s).replace(this.stripTagsRE, "");
},
asUCText : function(s) {
return String(s).toUpperCase().replace(this.stripTagsRE, "");
},
asUCString : function(s) {
return String(s).toUpperCase();
},
asDate : function(s) {
if(!s){
return 0;
}
if(Ext.isDate(s)){
return s.getTime();
}
return Date.parse(String(s));
},
asFloat : function(s) {
var val = parseFloat(String(s).replace(/,/g, ""));
return isNaN(val) ? 0 : val;
},
asInt : function(s) {
var val = parseInt(String(s).replace(/,/g, ""), 10);
return isNaN(val) ? 0 : val;
}
});
Ext.define('Ext.data.Errors', {
extend: 'Ext.util.MixedCollection',
isValid: function() {
return this.length === 0;
},
getByField: function(fieldName) {
var errors = [],
error, field, i;
for (i = 0; i < this.length; i++) {
error = this.items[i];
if (error.field == fieldName) {
errors.push(error);
}
}
return errors;
}
});
Ext.define('Ext.data.Operation', {
synchronous: true,
action: undefined,
filters: undefined,
sorters: undefined,
group: undefined,
start: undefined,
limit: undefined,
batch: undefined,
started: false,
running: false,
complete: false,
success: undefined,
exception: false,
error: undefined,
constructor: function(config) {
Ext.apply(this, config || {});
},
setStarted: function() {
this.started = true;
this.running = true;
},
setCompleted: function() {
this.complete = true;
this.running = false;
},
setSuccessful: function() {
this.success = true;
},
setException: function(error) {
this.exception = true;
this.success = false;
this.running = false;
this.error = error;
},
hasException: function() {
return this.exception === true;
},
getError: function() {
return this.error;
},
getRecords: function() {
var resultSet = this.getResultSet();
return (resultSet === undefined ? this.records : resultSet.records);
},
getResultSet: function() {
return this.resultSet;
},
isStarted: function() {
return this.started === true;
},
isRunning: function() {
return this.running === true;
},
isComplete: function() {
return this.complete === true;
},
wasSuccessful: function() {
return this.isComplete() && this.success === true;
},
setBatch: function(batch) {
this.batch = batch;
},
allowWrite: function() {
return this.action != 'read';
}
});
Ext.define('Ext.data.validations', {
singleton: true,
presenceMessage: 'must be present',
lengthMessage: 'is the wrong length',
formatMessage: 'is the wrong format',
inclusionMessage: 'is not included in the list of acceptable values',
exclusionMessage: 'is not an acceptable value',
presence: function(config, value) {
if (value === undefined) {
value = config;
}
return !!value;
},
length: function(config, value) {
if (value === undefined) {
return false;
}
var length = value.length,
min = config.min,
max = config.max;
if ((min && length < min) || (max && length > max)) {
return false;
} else {
return true;
}
},
format: function(config, value) {
return !!(config.matcher && config.matcher.test(value));
},
inclusion: function(config, value) {
return config.list && Ext.Array.indexOf(config.list,value) != -1;
},
exclusion: function(config, value) {
return config.list && Ext.Array.indexOf(config.list,value) == -1;
}
});
Ext.define('Ext.data.ResultSet', {
loaded: true,
count: 0,
total: 0,
success: false,
constructor: function(config) {
Ext.apply(this, config);
this.totalRecords = this.total;
if (config.count === undefined) {
this.count = this.records.length;
}
}
});
Ext.define('Ext.data.writer.Writer', {
alias: 'writer.base',
alternateClassName: ['Ext.data.DataWriter', 'Ext.data.Writer'],
writeAllFields: true,
nameProperty: 'name',
constructor: function(config) {
Ext.apply(this, config);
},
write: function(request) {
var operation = request.operation,
records = operation.records || [],
len = records.length,
i = 0,
data = [];
for (; i < len; i++) {
data.push(this.getRecordData(records[i]));
}
return this.writeRecords(request, data);
},
getRecordData: function(record) {
var isPhantom = record.phantom === true,
writeAll = this.writeAllFields || isPhantom,
nameProperty = this.nameProperty,
fields = record.fields,
data = {},
changes,
name,
field,
key;
if (writeAll) {
fields.each(function(field){
if (field.persist) {
name = field[nameProperty] || field.name;
data[name] = record.get(field.name);
}
});
} else {
changes = record.getChanges();
for (key in changes) {
if (changes.hasOwnProperty(key)) {
field = fields.get(key);
name = field[nameProperty] || field.name;
data[name] = changes[key];
}
}
if (!isPhantom) {
data[record.idProperty] = record.getId();
}
}
return data;
}
});
Ext.define('Ext.util.Floating', {
uses: ['Ext.Layer', 'Ext.window.Window'],
focusOnToFront: true,
shadow: 'sides',
constructor: function(config) {
this.floating = true;
this.el = Ext.create('Ext.Layer', Ext.apply({}, config, {
hideMode: this.hideMode,
hidden: this.hidden,
shadow: Ext.isDefined(this.shadow) ? this.shadow : 'sides',
shadowOffset: this.shadowOffset,
constrain: false,
shim: this.shim === false ? false : undefined
}), this.el);
},
onFloatRender: function() {
var me = this;
me.zIndexParent = me.getZIndexParent();
me.setFloatParent(me.ownerCt);
delete me.ownerCt;
if (me.zIndexParent) {
me.zIndexParent.registerFloatingItem(me);
} else {
Ext.WindowManager.register(me);
}
},
setFloatParent: function(floatParent) {
var me = this;
if (me.floatParent) {
me.mun(me.floatParent, {
hide: me.onFloatParentHide,
show: me.onFloatParentShow,
scope: me
});
}
me.floatParent = floatParent;
if (floatParent) {
me.mon(me.floatParent, {
hide: me.onFloatParentHide,
show: me.onFloatParentShow,
scope: me
});
}
if ((me.constrain || me.constrainHeader) && !me.constrainTo) {
me.constrainTo = floatParent ? floatParent.getTargetEl() : me.container;
}
},
onFloatParentHide: function() {
if (this.hideOnParentHide !== false) {
this.showOnParentShow = this.isVisible();
this.hide();
}
},
onFloatParentShow: function() {
if (this.showOnParentShow) {
delete this.showOnParentShow;
this.show();
}
},
getZIndexParent: function() {
var p = this.ownerCt,
c;
if (p) {
while (p) {
c = p;
p = p.ownerCt;
}
if (c.floating) {
return c;
}
}
},
setZIndex: function(index) {
var me = this;
this.el.setZIndex(index);
index += 10;
if (me.floatingItems) {
index = Math.floor(me.floatingItems.setBase(index) / 100) * 100 + 10000;
}
return index;
},
doConstrain: function(constrainTo) {
var me = this,
vector = me.getConstrainVector(constrainTo),
xy;
if (vector) {
xy = me.getPosition();
xy[0] += vector[0];
xy[1] += vector[1];
me.setPosition(xy);
}
},
getConstrainVector: function(constrainTo){
var me = this,
el;
if (me.constrain || me.constrainHeader) {
el = me.constrainHeader ? me.header.el : me.el;
constrainTo = constrainTo || (me.floatParent && me.floatParent.getTargetEl()) || me.container;
return el.getConstrainVector(constrainTo);
}
},
alignTo: function(element, position, offsets) {
if (element.isComponent) {
element = element.getEl();
}
var xy = this.el.getAlignToXY(element, position, offsets);
this.setPagePosition(xy);
return this;
},
toFront: function(preventFocus) {
var me = this;
if (me.zIndexParent) {
me.zIndexParent.toFront(true);
}
if (me.zIndexManager.bringToFront(me)) {
if (!Ext.isDefined(preventFocus)) {
preventFocus = !me.focusOnToFront;
}
if (!preventFocus) {
me.focus(false, true);
}
}
return me;
},
setActive: function(active, newActive) {
if (active) {
if ((this instanceof Ext.window.Window) && !this.maximized) {
this.el.enableShadow(true);
}
this.fireEvent('activate', this);
} else {
if ((this instanceof Ext.window.Window) && (newActive instanceof Ext.window.Window)) {
this.el.disableShadow();
}
this.fireEvent('deactivate', this);
}
},
toBack: function() {
this.zIndexManager.sendToBack(this);
return this;
},
center: function() {
var xy = this.el.getAlignToXY(this.container, 'c-c');
this.setPagePosition(xy);
return this;
},
syncShadow : function(){
if (this.floating) {
this.el.sync(true);
}
},
fitContainer: function() {
var parent = this.floatParent,
container = parent ? parent.getTargetEl() : this.container,
size = container.getViewSize(false);
this.setSize(size);
}
});
Ext.define('Ext.layout.container.AbstractContainer', {
extend: 'Ext.layout.Layout',
type: 'container',
bindToOwnerCtComponent: false,
bindToOwnerCtContainer: false,
setItemSize: function(item, width, height) {
if (Ext.isObject(width)) {
height = width.height;
width = width.width;
}
item.setCalculatedSize(width, height, this.owner);
},
getLayoutItems: function() {
return this.owner && this.owner.items && this.owner.items.items || [];
},
afterLayout: function() {
this.owner.afterLayout(this);
},
getTarget: function() {
return this.owner.getTargetEl();
},
getRenderTarget: function() {
return this.owner.getTargetEl();
}
});
Ext.define('Ext.ZIndexManager', {
alternateClassName: 'Ext.WindowGroup',
statics: {
zBase : 9000
},
constructor: function(container) {
var me = this;
me.list = {};
me.zIndexStack = [];
me.front = null;
if (container) {
if (container.isContainer) {
container.on('resize', me._onContainerResize, me);
me.zseed = Ext.Number.from(container.getEl().getStyle('zIndex'), me.getNextZSeed());
me.targetEl = container.getTargetEl();
me.container = container;
}
else {
Ext.EventManager.onWindowResize(me._onContainerResize, me);
me.zseed = me.getNextZSeed();
me.targetEl = Ext.get(container);
}
}
else {
Ext.EventManager.onWindowResize(me._onContainerResize, me);
me.zseed = me.getNextZSeed();
Ext.onDocumentReady(function() {
me.targetEl = Ext.getBody();
});
}
},
getNextZSeed: function() {
return (Ext.ZIndexManager.zBase += 10000);
},
setBase: function(baseZIndex) {
this.zseed = baseZIndex;
return this.assignZIndices();
},
assignZIndices: function() {
var a = this.zIndexStack,
len = a.length,
i = 0,
zIndex = this.zseed,
comp;
for (; i < len; i++) {
comp = a[i];
if (comp && !comp.hidden) {
zIndex = comp.setZIndex(zIndex);
}
}
this._activateLast();
return zIndex;
},
_setActiveChild: function(comp) {
if (comp != this.front) {
if (this.front) {
this.front.setActive(false, comp);
}
this.front = comp;
if (comp) {
comp.setActive(true);
if (comp.modal) {
this._showModalMask(comp.el.getStyle('zIndex') - 4);
}
}
}
},
_activateLast: function(justHidden) {
var comp,
lastActivated = false,
i;
for (i = this.zIndexStack.length-1; i >= 0; --i) {
comp = this.zIndexStack[i];
if (!comp.hidden) {
if (!lastActivated) {
this._setActiveChild(comp);
lastActivated = true;
}
if (comp.modal) {
this._showModalMask(comp.el.getStyle('zIndex') - 4);
return;
}
}
}
this._hideModalMask();
if (!lastActivated) {
this._setActiveChild(null);
}
},
_showModalMask: function(zIndex) {
if (!this.mask) {
this.mask = this.targetEl.createChild({
cls: Ext.baseCSSPrefix + 'mask'
});
this.mask.setVisibilityMode(Ext.core.Element.DISPLAY);
this.mask.on('click', this._onMaskClick, this);
}
Ext.getBody().addCls(Ext.baseCSSPrefix + 'body-masked');
this.mask.setSize(this.targetEl.getViewSize(true));
this.mask.setStyle('zIndex', zIndex);
this.mask.show();
},
_hideModalMask: function() {
if (this.mask) {
Ext.getBody().removeCls(Ext.baseCSSPrefix + 'body-masked');
this.mask.hide();
}
},
_onMaskClick: function() {
if (this.front) {
this.front.focus();
}
},
_onContainerResize: function() {
if (this.mask && this.mask.isVisible()) {
this.mask.setSize(this.targetEl.getViewSize(true));
}
},
register : function(comp) {
if (comp.zIndexManager) {
comp.zIndexManager.unregister(comp);
}
comp.zIndexManager = this;
this.list[comp.id] = comp;
this.zIndexStack.push(comp);
comp.on('hide', this._activateLast, this);
},
unregister : function(comp) {
delete comp.zIndexManager;
if (this.list && this.list[comp.id]) {
delete this.list[comp.id];
comp.un('hide', this._activateLast);
Ext.Array.remove(this.zIndexStack, comp);
this._activateLast(comp);
}
},
get : function(id) {
return typeof id == "object" ? id : this.list[id];
},
bringToFront : function(comp) {
comp = this.get(comp);
if (comp != this.front) {
Ext.Array.remove(this.zIndexStack, comp);
this.zIndexStack.push(comp);
this.assignZIndices();
return true;
}
if (comp.modal) {
Ext.getBody().addCls(Ext.baseCSSPrefix + 'body-masked');
this.mask.setSize(Ext.core.Element.getViewWidth(true), Ext.core.Element.getViewHeight(true));
this.mask.show();
}
return false;
},
sendToBack : function(comp) {
comp = this.get(comp);
Ext.Array.remove(this.zIndexStack, comp);
this.zIndexStack.unshift(comp);
this.assignZIndices();
return comp;
},
hideAll : function() {
for (var id in this.list) {
if (this.list[id].isComponent && this.list[id].isVisible()) {
this.list[id].hide();
}
}
},
hide: function() {
var i = 0,
ln = this.zIndexStack.length,
comp;
this.tempHidden = [];
for (; i < ln; i++) {
comp = this.zIndexStack[i];
if (comp.isVisible()) {
this.tempHidden.push(comp);
comp.hide();
}
}
},
show: function() {
var i = 0,
ln = this.tempHidden.length,
comp,
x,
y;
for (; i < ln; i++) {
comp = this.tempHidden[i];
x = comp.x;
y = comp.y;
comp.show();
comp.setPosition(x, y);
}
delete this.tempHidden;
},
getActive : function() {
return this.front;
},
getBy : function(fn, scope) {
var r = [],
i = 0,
len = this.zIndexStack.length,
comp;
for (; i < len; i++) {
comp = this.zIndexStack[i];
if (fn.call(scope||comp, comp) !== false) {
r.push(comp);
}
}
return r;
},
each : function(fn, scope) {
var comp;
for (var id in this.list) {
comp = this.list[id];
if (comp.isComponent && fn.call(scope || comp, comp) === false) {
return;
}
}
},
eachBottomUp: function (fn, scope) {
var comp,
stack = this.zIndexStack,
i, n;
for (i = 0, n = stack.length ; i < n; i++) {
comp = stack[i];
if (comp.isComponent && fn.call(scope || comp, comp) === false) {
return;
}
}
},
eachTopDown: function (fn, scope) {
var comp,
stack = this.zIndexStack,
i;
for (i = stack.length ; i-- > 0; ) {
comp = stack[i];
if (comp.isComponent && fn.call(scope || comp, comp) === false) {
return;
}
}
},
destroy: function() {
delete this.zIndexStack;
delete this.list;
delete this.container;
delete this.targetEl;
}
}, function() {
Ext.WindowManager = Ext.WindowMgr = new this();
});
Ext.define('Ext.layout.container.boxOverflow.None', {
alternateClassName: 'Ext.layout.boxOverflow.None',
constructor: function(layout, config) {
this.layout = layout;
Ext.apply(this, config || {});
},
handleOverflow: Ext.emptyFn,
clearOverflow: Ext.emptyFn,
onRemove: Ext.emptyFn,
getItem: function(item) {
return this.layout.owner.getComponent(item);
},
onRemove: Ext.emptyFn
});
Ext.define('Ext.util.KeyMap', {
alternateClassName: 'Ext.KeyMap',
constructor: function(el, binding, eventName){
var me = this;
Ext.apply(me, {
el: Ext.get(el),
eventName: eventName || me.eventName,
bindings: []
});
if (binding) {
me.addBinding(binding);
}
me.enable();
},
eventName: 'keydown',
addBinding : function(binding){
if (Ext.isArray(binding)) {
Ext.each(binding, this.addBinding, this);
return;
}
var keyCode = binding.key,
processed = false,
key,
keys,
keyString,
i,
len;
if (Ext.isString(keyCode)) {
keys = [];
keyString = keyCode.toLowerCase();
for (i = 0, len = keyString.length; i < len; ++i){
keys.push(keyString.charCodeAt(i));
}
keyCode = keys;
processed = true;
}
if (!Ext.isArray(keyCode)) {
keyCode = [keyCode];
}
if (!processed) {
for (i = 0, len = keyCode.length; i < len; ++i) {
key = keyCode[i];
if (Ext.isString(key)) {
keyCode[i] = key.toLowerCase().charCodeAt(0);
}
}
}
this.bindings.push(Ext.apply({
keyCode: keyCode
}, binding));
},
handleKeyDown: function(event) {
if (this.enabled) {
var bindings = this.bindings,
i = 0,
len = bindings.length;
event = this.processEvent(event);
for(; i < len; ++i){
this.processBinding(bindings[i], event);
}
}
},
processEvent: function(event){
return event;
},
processBinding: function(binding, event){
if (this.checkModifiers(binding, event)) {
var key = event.getKey(),
handler = binding.fn || binding.handler,
scope = binding.scope || this,
keyCode = binding.keyCode,
defaultEventAction = binding.defaultEventAction,
i,
len,
keydownEvent = new Ext.EventObjectImpl(event);
for (i = 0, len = keyCode.length; i < len; ++i) {
if (key === keyCode[i]) {
if (handler.call(scope, key, event) !== true && defaultEventAction) {
keydownEvent[defaultEventAction]();
}
break;
}
}
}
},
checkModifiers: function(binding, e){
var keys = ['shift', 'ctrl', 'alt'],
i = 0,
len = keys.length,
val, key;
for (; i < len; ++i){
key = keys[i];
val = binding[key];
if (!(val === undefined || (val === e[key + 'Key']))) {
return false;
}
}
return true;
},
on: function(key, fn, scope) {
var keyCode, shift, ctrl, alt;
if (Ext.isObject(key) && !Ext.isArray(key)) {
keyCode = key.key;
shift = key.shift;
ctrl = key.ctrl;
alt = key.alt;
} else {
keyCode = key;
}
this.addBinding({
key: keyCode,
shift: shift,
ctrl: ctrl,
alt: alt,
fn: fn,
scope: scope
});
},
isEnabled : function(){
return this.enabled;
},
enable: function(){
if(!this.enabled){
this.el.on(this.eventName, this.handleKeyDown, this);
this.enabled = true;
}
},
disable: function(){
if(this.enabled){
this.el.removeListener(this.eventName, this.handleKeyDown, this);
this.enabled = false;
}
},
setDisabled : function(disabled){
if (disabled) {
this.disable();
} else {
this.enable();
}
},
destroy: function(removeEl){
var me = this;
me.bindings = [];
me.disable();
if (removeEl === true) {
me.el.remove();
}
delete me.el;
}
});
Ext.define('Ext.util.ClickRepeater', {
extend: 'Ext.util.Observable',
constructor : function(el, config){
this.el = Ext.get(el);
this.el.unselectable();
Ext.apply(this, config);
this.addEvents(
"mousedown",
"click",
"mouseup"
);
if(!this.disabled){
this.disabled = true;
this.enable();
}
if(this.handler){
this.on("click", this.handler, this.scope || this);
}
this.callParent();
},
interval : 20,
delay: 250,
preventDefault : true,
stopDefault : false,
timer : 0,
enable: function(){
if(this.disabled){
this.el.on('mousedown', this.handleMouseDown, this);
if (Ext.isIE){
this.el.on('dblclick', this.handleDblClick, this);
}
if(this.preventDefault || this.stopDefault){
this.el.on('click', this.eventOptions, this);
}
}
this.disabled = false;
},
disable: function( force){
if(force || !this.disabled){
clearTimeout(this.timer);
if(this.pressedCls){
this.el.removeCls(this.pressedCls);
}
Ext.getDoc().un('mouseup', this.handleMouseUp, this);
this.el.removeAllListeners();
}
this.disabled = true;
},
setDisabled: function(disabled){
this[disabled ? 'disable' : 'enable']();
},
eventOptions: function(e){
if(this.preventDefault){
e.preventDefault();
}
if(this.stopDefault){
e.stopEvent();
}
},
destroy : function() {
this.disable(true);
Ext.destroy(this.el);
this.clearListeners();
},
handleDblClick : function(e){
clearTimeout(this.timer);
this.el.blur();
this.fireEvent("mousedown", this, e);
this.fireEvent("click", this, e);
},
handleMouseDown : function(e){
clearTimeout(this.timer);
this.el.blur();
if(this.pressedCls){
this.el.addCls(this.pressedCls);
}
this.mousedownTime = new Date();
Ext.getDoc().on("mouseup", this.handleMouseUp, this);
this.el.on("mouseout", this.handleMouseOut, this);
this.fireEvent("mousedown", this, e);
this.fireEvent("click", this, e);
if (this.accelerate) {
this.delay = 400;
}
e = new Ext.EventObjectImpl(e);
this.timer = Ext.defer(this.click, this.delay || this.interval, this, [e]);
},
click : function(e){
this.fireEvent("click", this, e);
this.timer = Ext.defer(this.click, this.accelerate ?
this.easeOutExpo(Ext.Date.getElapsed(this.mousedownTime),
400,
-390,
12000) :
this.interval, this, [e]);
},
easeOutExpo : function (t, b, c, d) {
return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
},
handleMouseOut : function(){
clearTimeout(this.timer);
if(this.pressedCls){
this.el.removeCls(this.pressedCls);
}
this.el.on("mouseover", this.handleMouseReturn, this);
},
handleMouseReturn : function(){
this.el.un("mouseover", this.handleMouseReturn, this);
if(this.pressedCls){
this.el.addCls(this.pressedCls);
}
this.click();
},
handleMouseUp : function(e){
clearTimeout(this.timer);
this.el.un("mouseover", this.handleMouseReturn, this);
this.el.un("mouseout", this.handleMouseOut, this);
Ext.getDoc().un("mouseup", this.handleMouseUp, this);
if(this.pressedCls){
this.el.removeCls(this.pressedCls);
}
this.fireEvent("mouseup", this, e);
}
});
Ext.define('Ext.layout.component.Button', {
alias: ['layout.button'],
extend: 'Ext.layout.component.Component',
type: 'button',
cellClsRE: /-btn-(tl|br)\b/,
htmlRE: /<.*>/,
beforeLayout: function() {
return this.callParent(arguments) || this.lastText !== this.owner.text;
},
onLayout: function(width, height) {
var me = this,
isNum = Ext.isNumber,
owner = me.owner,
ownerEl = owner.el,
btnEl = owner.btnEl,
btnInnerEl = owner.btnInnerEl,
btnIconEl = owner.btnIconEl,
sizeIconEl = (owner.icon || owner.iconCls) && (owner.iconAlign == "top" || owner.iconAlign == "bottom"),
minWidth = owner.minWidth,
maxWidth = owner.maxWidth,
ownerWidth, btnFrameWidth, metrics;
me.getTargetInfo();
me.callParent(arguments);
btnInnerEl.unclip();
me.setTargetSize(width, height);
if (!isNum(width)) {
if (owner.text && Ext.isIE7 && Ext.isStrict && btnEl && btnEl.getWidth() > 20) {
btnFrameWidth = me.btnFrameWidth;
metrics = Ext.util.TextMetrics.measure(btnInnerEl, owner.text);
ownerEl.setWidth(metrics.width + btnFrameWidth + me.adjWidth);
btnEl.setWidth(metrics.width + btnFrameWidth);
btnInnerEl.setWidth(metrics.width + btnFrameWidth);
if (sizeIconEl) {
btnIconEl.setWidth(metrics.width + btnFrameWidth);
}
} else {
ownerEl.setWidth(null);
btnEl.setWidth(null);
btnInnerEl.setWidth(null);
btnIconEl.setWidth(null);
}
if (minWidth || maxWidth) {
ownerWidth = ownerEl.getWidth();
if (minWidth && (ownerWidth < minWidth)) {
me.setTargetSize(minWidth, height);
}
else if (maxWidth && (ownerWidth > maxWidth)) {
btnInnerEl.clip();
me.setTargetSize(maxWidth, height);
}
}
}
this.lastText = owner.text;
},
setTargetSize: function(width, height) {
var me = this,
owner = me.owner,
isNum = Ext.isNumber,
btnInnerEl = owner.btnInnerEl,
btnWidth = (isNum(width) ? width - me.adjWidth : width),
btnHeight = (isNum(height) ? height - me.adjHeight : height),
btnFrameHeight = me.btnFrameHeight,
text = owner.getText(),
textHeight;
me.callParent(arguments);
me.setElementSize(owner.btnEl, btnWidth, btnHeight);
me.setElementSize(btnInnerEl, btnWidth, btnHeight);
if (isNum(btnHeight)) {
btnInnerEl.setStyle('line-height', btnHeight - btnFrameHeight + 'px');
}
if (text && this.htmlRE.test(text)) {
btnInnerEl.setStyle('line-height', 'normal');
textHeight = Ext.util.TextMetrics.measure(btnInnerEl, text).height;
btnInnerEl.setStyle('padding-top', me.btnFrameTop + Math.max(btnInnerEl.getHeight() - btnFrameHeight - textHeight, 0) / 2 + 'px');
me.setElementSize(btnInnerEl, btnWidth, btnHeight);
}
},
getTargetInfo: function() {
var me = this,
owner = me.owner,
ownerEl = owner.el,
frameSize = me.frameSize,
frameBody = owner.frameBody,
btnWrap = owner.btnWrap,
innerEl = owner.btnInnerEl;
if (!('adjWidth' in me)) {
Ext.apply(me, {
adjWidth: frameSize.left + frameSize.right + ownerEl.getBorderWidth('lr') + ownerEl.getPadding('lr') +
btnWrap.getPadding('lr') + (frameBody ? frameBody.getFrameWidth('lr') : 0),
adjHeight: frameSize.top + frameSize.bottom + ownerEl.getBorderWidth('tb') + ownerEl.getPadding('tb') +
btnWrap.getPadding('tb') + (frameBody ? frameBody.getFrameWidth('tb') : 0),
btnFrameWidth: innerEl.getFrameWidth('lr'),
btnFrameHeight: innerEl.getFrameWidth('tb'),
btnFrameTop: innerEl.getFrameWidth('t')
});
}
return me.callParent();
}
});
Ext.define('Ext.util.TextMetrics', {
statics: {
shared: null,
measure: function(el, text, fixedWidth){
var me = this,
shared = me.shared;
if(!shared){
shared = me.shared = new me(el, fixedWidth);
}
shared.bind(el);
shared.setFixedWidth(fixedWidth || 'auto');
return shared.getSize(text);
},
destroy: function(){
var me = this;
Ext.destroy(me.shared);
me.shared = null;
}
},
constructor: function(bindTo, fixedWidth){
var measure = this.measure = Ext.getBody().createChild({
cls: 'x-textmetrics'
});
this.el = Ext.get(bindTo);
measure.position('absolute');
measure.setLeftTop(-1000, -1000);
measure.hide();
if (fixedWidth) {
measure.setWidth(fixedWidth);
}
},
getSize: function(text){
var measure = this.measure,
size;
measure.update(text);
size = measure.getSize();
measure.update('');
return size;
},
bind: function(el){
var me = this;
me.el = Ext.get(el);
me.measure.setStyle(
me.el.getStyles('font-size','font-style', 'font-weight', 'font-family','line-height', 'text-transform', 'letter-spacing')
);
},
setFixedWidth : function(width){
this.measure.setWidth(width);
},
getWidth : function(text){
this.measure.dom.style.width = 'auto';
return this.getSize(text).width;
},
getHeight : function(text){
return this.getSize(text).height;
},
destroy: function(){
var me = this;
me.measure.remove();
delete me.el;
delete me.measure;
}
}, function(){
Ext.core.Element.addMethods({
getTextWidth : function(text, min, max){
return Ext.Number.constrain(Ext.util.TextMetrics.measure(this.dom, Ext.value(text, this.dom.innerHTML, true)).width, min || 0, max || 1000000);
}
});
});
Ext.define('Ext.layout.container.boxOverflow.Scroller', {
extend: 'Ext.layout.container.boxOverflow.None',
requires: ['Ext.util.ClickRepeater', 'Ext.core.Element'],
alternateClassName: 'Ext.layout.boxOverflow.Scroller',
mixins: {
observable: 'Ext.util.Observable'
},
animateScroll: false,
scrollIncrement: 20,
wheelIncrement: 10,
scrollRepeatInterval: 60,
scrollDuration: 400,
scrollerCls: Ext.baseCSSPrefix + 'box-scroller',
constructor: function(layout, config) {
this.layout = layout;
Ext.apply(this, config || {});
this.addEvents(
'scroll'
);
},
initCSSClasses: function() {
var me = this,
layout = me.layout;
if (!me.CSSinitialized) {
me.beforeCtCls = me.beforeCtCls || Ext.baseCSSPrefix + 'box-scroller-' + layout.parallelBefore;
me.afterCtCls = me.afterCtCls || Ext.baseCSSPrefix + 'box-scroller-' + layout.parallelAfter;
me.beforeScrollerCls = me.beforeScrollerCls || Ext.baseCSSPrefix + layout.owner.getXType() + '-scroll-' + layout.parallelBefore;
me.afterScrollerCls = me.afterScrollerCls || Ext.baseCSSPrefix + layout.owner.getXType() + '-scroll-' + layout.parallelAfter;
me.CSSinitializes = true;
}
},
handleOverflow: function(calculations, targetSize) {
var me = this,
layout = me.layout,
methodName = 'get' + layout.parallelPrefixCap,
newSize = {};
me.initCSSClasses();
me.callParent(arguments);
this.createInnerElements();
this.showScrollers();
newSize[layout.perpendicularPrefix] = targetSize[layout.perpendicularPrefix];
newSize[layout.parallelPrefix] = targetSize[layout.parallelPrefix] - (me.beforeCt[methodName]() + me.afterCt[methodName]());
return { targetSize: newSize };
},
createInnerElements: function() {
var me = this,
target = me.layout.getRenderTarget();
if (!me.beforeCt) {
target.addCls(Ext.baseCSSPrefix + me.layout.direction + '-box-overflow-body');
me.beforeCt = target.insertSibling({cls: Ext.layout.container.Box.prototype.innerCls + ' ' + me.beforeCtCls}, 'before');
me.afterCt = target.insertSibling({cls: Ext.layout.container.Box.prototype.innerCls + ' ' + me.afterCtCls}, 'after');
me.createWheelListener();
}
},
createWheelListener: function() {
this.layout.innerCt.on({
scope : this,
mousewheel: function(e) {
e.stopEvent();
this.scrollBy(e.getWheelDelta() * this.wheelIncrement * -1, false);
}
});
},
clearOverflow: function() {
this.hideScrollers();
},
showScrollers: function() {
this.createScrollers();
this.beforeScroller.show();
this.afterScroller.show();
this.updateScrollButtons();
this.layout.owner.addClsWithUI('scroller');
},
hideScrollers: function() {
if (this.beforeScroller != undefined) {
this.beforeScroller.hide();
this.afterScroller.hide();
this.layout.owner.removeClsWithUI('scroller');
}
},
createScrollers: function() {
if (!this.beforeScroller && !this.afterScroller) {
var before = this.beforeCt.createChild({
cls: Ext.String.format("{0} {1} ", this.scrollerCls, this.beforeScrollerCls)
});
var after = this.afterCt.createChild({
cls: Ext.String.format("{0} {1}", this.scrollerCls, this.afterScrollerCls)
});
before.addClsOnOver(this.beforeScrollerCls + '-hover');
after.addClsOnOver(this.afterScrollerCls + '-hover');
before.setVisibilityMode(Ext.core.Element.DISPLAY);
after.setVisibilityMode(Ext.core.Element.DISPLAY);
this.beforeRepeater = Ext.create('Ext.util.ClickRepeater', before, {
interval: this.scrollRepeatInterval,
handler : this.scrollLeft,
scope : this
});
this.afterRepeater = Ext.create('Ext.util.ClickRepeater', after, {
interval: this.scrollRepeatInterval,
handler : this.scrollRight,
scope : this
});
this.beforeScroller = before;
this.afterScroller = after;
}
},
destroy: function() {
Ext.destroy(this.beforeRepeater, this.afterRepeater, this.beforeScroller, this.afterScroller, this.beforeCt, this.afterCt);
},
scrollBy: function(delta, animate) {
this.scrollTo(this.getScrollPosition() + delta, animate);
},
getScrollAnim: function() {
return {
duration: this.scrollDuration,
callback: this.updateScrollButtons,
scope : this
};
},
updateScrollButtons: function() {
if (this.beforeScroller == undefined || this.afterScroller == undefined) {
return;
}
var beforeMeth = this.atExtremeBefore() ? 'addCls' : 'removeCls',
afterMeth = this.atExtremeAfter() ? 'addCls' : 'removeCls',
beforeCls = this.beforeScrollerCls + '-disabled',
afterCls = this.afterScrollerCls + '-disabled';
this.beforeScroller[beforeMeth](beforeCls);
this.afterScroller[afterMeth](afterCls);
this.scrolling = false;
},
atExtremeBefore: function() {
return this.getScrollPosition() === 0;
},
scrollLeft: function() {
this.scrollBy(-this.scrollIncrement, false);
},
scrollRight: function() {
this.scrollBy(this.scrollIncrement, false);
},
getScrollPosition: function(){
var layout = this.layout;
return parseInt(layout.innerCt.dom['scroll' + layout.parallelBeforeCap], 10) || 0;
},
getMaxScrollPosition: function() {
var layout = this.layout;
return layout.innerCt.dom['scroll' + layout.parallelPrefixCap] - this.layout.innerCt['get' + layout.parallelPrefixCap]();
},
atExtremeAfter: function() {
return this.getScrollPosition() >= this.getMaxScrollPosition();
},
scrollTo: function(position, animate) {
var me = this,
layout = me.layout,
oldPosition = me.getScrollPosition(),
newPosition = Ext.Number.constrain(position, 0, me.getMaxScrollPosition());
if (newPosition != oldPosition && !me.scrolling) {
if (animate == undefined) {
animate = me.animateScroll;
}
layout.innerCt.scrollTo(layout.parallelBefore, newPosition, animate ? me.getScrollAnim() : false);
if (animate) {
me.scrolling = true;
} else {
me.scrolling = false;
me.updateScrollButtons();
}
me.fireEvent('scroll', me, newPosition, animate ? me.getScrollAnim() : false);
}
},
scrollToItem: function(item, animate) {
var me = this,
layout = me.layout,
visibility,
box,
newPos;
item = me.getItem(item);
if (item != undefined) {
visibility = this.getItemVisibility(item);
if (!visibility.fullyVisible) {
box = item.getBox(true, true);
newPos = box[layout.parallelPosition];
if (visibility.hiddenEnd) {
newPos -= (this.layout.innerCt['get' + layout.parallelPrefixCap]() - box[layout.parallelPrefix]);
}
this.scrollTo(newPos, animate);
}
}
},
getItemVisibility: function(item) {
var me = this,
box = me.getItem(item).getBox(true, true),
layout = me.layout,
itemStart = box[layout.parallelPosition],
itemEnd = itemStart + box[layout.parallelPrefix],
scrollStart = me.getScrollPosition(),
scrollEnd = scrollStart + layout.innerCt['get' + layout.parallelPrefixCap]();
return {
hiddenStart : itemStart < scrollStart,
hiddenEnd : itemEnd > scrollEnd,
fullyVisible: itemStart > scrollStart && itemEnd < scrollEnd
};
}
});
Ext.define('Ext.util.Offset', {
statics: {
fromObject: function(obj) {
return new this(obj.x, obj.y);
}
},
constructor: function(x, y) {
this.x = (x != null && !isNaN(x)) ? x : 0;
this.y = (y != null && !isNaN(y)) ? y : 0;
return this;
},
copy: function() {
return new Ext.util.Offset(this.x, this.y);
},
copyFrom: function(p) {
this.x = p.x;
this.y = p.y;
},
toString: function() {
return "Offset[" + this.x + "," + this.y + "]";
},
equals: function(offset) {
return (this.x == offset.x && this.y == offset.y);
},
round: function(to) {
if (!isNaN(to)) {
var factor = Math.pow(10, to);
this.x = Math.round(this.x * factor) / factor;
this.y = Math.round(this.y * factor) / factor;
} else {
this.x = Math.round(this.x);
this.y = Math.round(this.y);
}
},
isZero: function() {
return this.x == 0 && this.y == 0;
}
});
Ext.define('Ext.util.KeyNav', {
alternateClassName: 'Ext.KeyNav',
requires: ['Ext.util.KeyMap'],
statics: {
keyOptions: {
left: 37,
right: 39,
up: 38,
down: 40,
space: 32,
pageUp: 33,
pageDown: 34,
del: 46,
backspace: 8,
home: 36,
end: 35,
enter: 13,
esc: 27,
tab: 9
}
},
constructor: function(el, config){
this.setConfig(el, config || {});
},
setConfig: function(el, config) {
if (this.map) {
this.map.destroy();
}
var map = Ext.create('Ext.util.KeyMap', el, null, this.getKeyEvent('forceKeyDown' in config ? config.forceKeyDown : this.forceKeyDown)),
keys = Ext.util.KeyNav.keyOptions,
scope = config.scope || this,
key;
this.map = map;
for (key in keys) {
if (keys.hasOwnProperty(key)) {
if (config[key]) {
map.addBinding({
scope: scope,
key: keys[key],
handler: Ext.Function.bind(this.handleEvent, scope, [config[key]], true),
defaultEventAction: config.defaultEventAction || this.defaultEventAction
});
}
}
}
map.disable();
if (!config.disabled) {
map.enable();
}
},
handleEvent: function(map, event, handler){
return handler.call(this, event);
},
disabled: false,
defaultEventAction: "stopEvent",
forceKeyDown: false,
destroy: function(removeEl){
this.map.destroy(removeEl);
delete this.map;
},
enable: function() {
this.map.enable();
this.disabled = false;
},
disable: function() {
this.map.disable();
this.disabled = true;
},
setDisabled : function(disabled){
this.map.setDisabled(disabled);
this.disabled = disabled;
},
getKeyEvent: function(forceKeyDown){
return (forceKeyDown || Ext.EventManager.useKeyDown) ? 'keydown' : 'keypress';
}
});
Ext.define('Ext.fx.Queue', {
requires: ['Ext.util.HashMap'],
constructor: function() {
this.targets = Ext.create('Ext.util.HashMap');
this.fxQueue = {};
},
getFxDefaults: function(targetId) {
var target = this.targets.get(targetId);
if (target) {
return target.fxDefaults;
}
return {};
},
setFxDefaults: function(targetId, obj) {
var target = this.targets.get(targetId);
if (target) {
target.fxDefaults = Ext.apply(target.fxDefaults || {}, obj);
}
},
stopAnimation: function(targetId) {
var me = this,
queue = me.getFxQueue(targetId),
ln = queue.length;
while (ln) {
queue[ln - 1].end();
ln--;
}
},
getActiveAnimation: function(targetId) {
var queue = this.getFxQueue(targetId);
return (queue && !!queue.length) ? queue[0] : false;
},
hasFxBlock: function(targetId) {
var queue = this.getFxQueue(targetId);
return queue && queue[0] && queue[0].block;
},
getFxQueue: function(targetId) {
if (!targetId) {
return false;
}
var me = this,
queue = me.fxQueue[targetId],
target = me.targets.get(targetId);
if (!target) {
return false;
}
if (!queue) {
me.fxQueue[targetId] = [];
if (target.type != 'element') {
target.target.on('destroy', function() {
me.fxQueue[targetId] = [];
});
}
}
return me.fxQueue[targetId];
},
queueFx: function(anim) {
var me = this,
target = anim.target,
queue, ln;
if (!target) {
return;
}
queue = me.getFxQueue(target.getId());
ln = queue.length;
if (ln) {
if (anim.concurrent) {
anim.paused = false;
}
else {
queue[ln - 1].on('afteranimate', function() {
anim.paused = false;
});
}
}
else {
anim.paused = false;
}
anim.on('afteranimate', function() {
Ext.Array.remove(queue, anim);
if (anim.remove) {
if (target.type == 'element') {
var el = Ext.get(target.id);
if (el) {
el.remove();
}
}
}
}, this);
queue.push(anim);
}
});
Ext.define('Ext.fx.target.Target', {
isAnimTarget: true,
constructor: function(target) {
this.target = target;
this.id = this.getId();
},
getId: function() {
return this.target.id;
}
});
Ext.define('Ext.fx.target.Sprite', {
extend: 'Ext.fx.target.Target',
type: 'draw',
getFromPrim: function(sprite, attr) {
var o;
if (attr == 'translate') {
o = {
x: sprite.attr.translation.x || 0,
y: sprite.attr.translation.y || 0
};
}
else if (attr == 'rotate') {
o = {
degrees: sprite.attr.rotation.degrees || 0,
x: sprite.attr.rotation.x,
y: sprite.attr.rotation.y
};
}
else {
o = sprite.attr[attr];
}
return o;
},
getAttr: function(attr, val) {
return [[this.target, val != undefined ? val : this.getFromPrim(this.target, attr)]];
},
setAttr: function(targetData) {
var ln = targetData.length,
spriteArr = [],
attrs, attr, attrArr, attPtr, spritePtr, idx, value, i, j, x, y, ln2;
for (i = 0; i < ln; i++) {
attrs = targetData[i].attrs;
for (attr in attrs) {
attrArr = attrs[attr];
ln2 = attrArr.length;
for (j = 0; j < ln2; j++) {
spritePtr = attrArr[j][0];
attPtr = attrArr[j][1];
if (attr === 'translate') {
value = {
x: attPtr.x,
y: attPtr.y
};
}
else if (attr === 'rotate') {
x = attPtr.x;
if (isNaN(x)) {
x = null;
}
y = attPtr.y;
if (isNaN(y)) {
y = null;
}
value = {
degrees: attPtr.degrees,
x: x,
y: y
};
}
else if (attr === 'width' || attr === 'height' || attr === 'x' || attr === 'y') {
value = parseFloat(attPtr);
}
else {
value = attPtr;
}
idx = Ext.Array.indexOf(spriteArr, spritePtr);
if (idx == -1) {
spriteArr.push([spritePtr, {}]);
idx = spriteArr.length - 1;
}
spriteArr[idx][1][attr] = value;
}
}
}
ln = spriteArr.length;
for (i = 0; i < ln; i++) {
spritePtr = spriteArr[i];
spritePtr[0].setAttributes(spritePtr[1]);
}
this.target.redraw();
}
});
Ext.define('Ext.fx.target.CompositeSprite', {
extend: 'Ext.fx.target.Sprite',
getAttr: function(attr, val) {
var out = [],
target = this.target;
target.each(function(sprite) {
out.push([sprite, val != undefined ? val : this.getFromPrim(sprite, attr)]);
}, this);
return out;
}
});
Ext.define('Ext.fx.target.Component', {
extend: 'Ext.fx.target.Target',
type: 'component',
getPropMethod: {
top: function() {
return this.getPosition(true)[1];
},
left: function() {
return this.getPosition(true)[0];
},
x: function() {
return this.getPosition()[0];
},
y: function() {
return this.getPosition()[1];
},
height: function() {
return this.getHeight();
},
width: function() {
return this.getWidth();
},
opacity: function() {
return this.el.getStyle('opacity');
}
},
compMethod: {
top: 'setPosition',
left: 'setPosition',
x: 'setPagePosition',
y: 'setPagePosition',
height: 'setSize',
width: 'setSize',
opacity: 'setOpacity'
},
getAttr: function(attr, val) {
return [[this.target, val !== undefined ? val : this.getPropMethod[attr].call(this.target)]];
},
setAttr: function(targetData, isFirstFrame, isLastFrame) {
var me = this,
target = me.target,
ln = targetData.length,
attrs, attr, o, i, j, meth, targets, left, top, w, h;
for (i = 0; i < ln; i++) {
attrs = targetData[i].attrs;
for (attr in attrs) {
targets = attrs[attr].length;
meth = {
setPosition: {},
setPagePosition: {},
setSize: {},
setOpacity: {}
};
for (j = 0; j < targets; j++) {
o = attrs[attr][j];
meth[me.compMethod[attr]].target = o[0];
meth[me.compMethod[attr]][attr] = o[1];
}
if (meth.setPosition.target) {
o = meth.setPosition;
left = (o.left === undefined) ? undefined : parseInt(o.left, 10);
top = (o.top === undefined) ? undefined : parseInt(o.top, 10);
o.target.setPosition(left, top);
}
if (meth.setPagePosition.target) {
o = meth.setPagePosition;
o.target.setPagePosition(o.x, o.y);
}
if (meth.setSize.target) {
o = meth.setSize;
w = (o.width === undefined) ? o.target.getWidth() : parseInt(o.width, 10);
h = (o.height === undefined) ? o.target.getHeight() : parseInt(o.height, 10);
if (isLastFrame || me.dynamic) {
o.target.componentLayout.childrenChanged = true;
if (me.layoutAnimation) {
o.target.setCalculatedSize(w, h);
} else {
o.target.setSize(w, h);
}
}
else {
o.target.el.setSize(w, h);
}
}
if (meth.setOpacity.target) {
o = meth.setOpacity;
o.target.el.setStyle('opacity', o.opacity);
}
}
}
}
});
Ext.define('Ext.fx.CubicBezier', {
singleton: true,
cubicBezierAtTime: function(t, p1x, p1y, p2x, p2y, duration) {
var cx = 3 * p1x,
bx = 3 * (p2x - p1x) - cx,
ax = 1 - cx - bx,
cy = 3 * p1y,
by = 3 * (p2y - p1y) - cy,
ay = 1 - cy - by;
function sampleCurveX(t) {
return ((ax * t + bx) * t + cx) * t;
}
function solve(x, epsilon) {
var t = solveCurveX(x, epsilon);
return ((ay * t + by) * t + cy) * t;
}
function solveCurveX(x, epsilon) {
var t0, t1, t2, x2, d2, i;
for (t2 = x, i = 0; i < 8; i++) {
x2 = sampleCurveX(t2) - x;
if (Math.abs(x2) < epsilon) {
return t2;
}
d2 = (3 * ax * t2 + 2 * bx) * t2 + cx;
if (Math.abs(d2) < 1e-6) {
break;
}
t2 = t2 - x2 / d2;
}
t0 = 0;
t1 = 1;
t2 = x;
if (t2 < t0) {
return t0;
}
if (t2 > t1) {
return t1;
}
while (t0 < t1) {
x2 = sampleCurveX(t2);
if (Math.abs(x2 - x) < epsilon) {
return t2;
}
if (x > x2) {
t0 = t2;
} else {
t1 = t2;
}
t2 = (t1 - t0) / 2 + t0;
}
return t2;
}
return solve(t, 1 / (200 * duration));
},
cubicBezier: function(x1, y1, x2, y2) {
var fn = function(pos) {
return Ext.fx.CubicBezier.cubicBezierAtTime(pos, x1, y1, x2, y2, 1);
};
fn.toCSS3 = function() {
return 'cubic-bezier(' + [x1, y1, x2, y2].join(',') + ')';
};
fn.reverse = function() {
return Ext.fx.CubicBezier.cubicBezier(1 - x2, 1 - y2, 1 - x1, 1 - y1);
};
return fn;
}
});
Ext.define('Ext.draw.Color', {
colorToHexRe: /(.*?)rgb\((\d+),\s*(\d+),\s*(\d+)\)/,
rgbRe: /\s*rgb\s*\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)\s*/,
hexRe: /\s*#([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)([0-9a-fA-F][0-9a-fA-F]?)\s*/,
lightnessFactor: 0.2,
constructor : function(red, green, blue) {
var me = this,
clamp = Ext.Number.constrain;
me.r = clamp(red, 0, 255);
me.g = clamp(green, 0, 255);
me.b = clamp(blue, 0, 255);
},
getRed: function() {
return this.r;
},
getGreen: function() {
return this.g;
},
getBlue: function() {
return this.b;
},
getRGB: function() {
var me = this;
return [me.r, me.g, me.b];
},
getHSL: function() {
var me = this,
r = me.r / 255,
g = me.g / 255,
b = me.b / 255,
max = Math.max(r, g, b),
min = Math.min(r, g, b),
delta = max - min,
h,
s = 0,
l = 0.5 * (max + min);
if (min != max) {
s = (l < 0.5) ? delta / (max + min) : delta / (2 - max - min);
if (r == max) {
h = 60 * (g - b) / delta;
} else if (g == max) {
h = 120 + 60 * (b - r) / delta;
} else {
h = 240 + 60 * (r - g) / delta;
}
if (h < 0) {
h += 360;
}
if (h >= 360) {
h -= 360;
}
}
return [h, s, l];
},
getLighter: function(factor) {
var hsl = this.getHSL();
factor = factor || this.lightnessFactor;
hsl[2] = Ext.Number.constrain(hsl[2] + factor, 0, 1);
return this.fromHSL(hsl[0], hsl[1], hsl[2]);
},
getDarker: function(factor) {
factor = factor || this.lightnessFactor;
return this.getLighter(-factor);
},
toString: function() {
var me = this,
round = Math.round,
r = round(me.r).toString(16),
g = round(me.g).toString(16),
b = round(me.b).toString(16);
r = (r.length == 1) ? '0' + r : r;
g = (g.length == 1) ? '0' + g : g;
b = (b.length == 1) ? '0' + b : b;
return ['#', r, g, b].join('');
},
toHex: function(color) {
if (Ext.isArray(color)) {
color = color[0];
}
if (!Ext.isString(color)) {
return '';
}
if (color.substr(0, 1) === '#') {
return color;
}
var digits = this.colorToHexRe.exec(color);
if (Ext.isArray(digits)) {
var red = parseInt(digits[2], 10),
green = parseInt(digits[3], 10),
blue = parseInt(digits[4], 10),
rgb = blue | (green << 8) | (red << 16);
return digits[1] + '#' + ("000000" + rgb.toString(16)).slice(-6);
}
else {
return '';
}
},
fromString: function(str) {
var values, r, g, b,
parse = parseInt;
if ((str.length == 4 || str.length == 7) && str.substr(0, 1) === '#') {
values = str.match(this.hexRe);
if (values) {
r = parse(values[1], 16) >> 0;
g = parse(values[2], 16) >> 0;
b = parse(values[3], 16) >> 0;
if (str.length == 4) {
r += (r * 16);
g += (g * 16);
b += (b * 16);
}
}
}
else {
values = str.match(this.rgbRe);
if (values) {
r = values[1];
g = values[2];
b = values[3];
}
}
return (typeof r == 'undefined') ? undefined : Ext.create('Ext.draw.Color', r, g, b);
},
getGrayscale: function() {
return this.r * 0.3 + this.g * 0.59 + this.b * 0.11;
},
fromHSL: function(h, s, l) {
var C, X, m, i, rgb = [],
abs = Math.abs,
floor = Math.floor;
if (s == 0 || h == null) {
rgb = [l, l, l];
}
else {
h /= 60;
C = s * (1 - abs(2 * l - 1));
X = C * (1 - abs(h - 2 * floor(h / 2) - 1));
m = l - C / 2;
switch (floor(h)) {
case 0:
rgb = [C, X, 0];
break;
case 1:
rgb = [X, C, 0];
break;
case 2:
rgb = [0, C, X];
break;
case 3:
rgb = [0, X, C];
break;
case 4:
rgb = [X, 0, C];
break;
case 5:
rgb = [C, 0, X];
break;
}
rgb = [rgb[0] + m, rgb[1] + m, rgb[2] + m];
}
return Ext.create('Ext.draw.Color', rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
}
}, function() {
var prototype = this.prototype;
this.addStatics({
fromHSL: function() {
return prototype.fromHSL.apply(prototype, arguments);
},
fromString: function() {
return prototype.fromString.apply(prototype, arguments);
},
toHex: function() {
return prototype.toHex.apply(prototype, arguments);
}
});
});
Ext.define('Ext.dd.StatusProxy', {
animRepair: false,
constructor: function(config){
Ext.apply(this, config);
this.id = this.id || Ext.id();
this.proxy = Ext.createWidget('component', {
floating: true,
id: this.id,
html: '
' +
'
',
cls: Ext.baseCSSPrefix + 'dd-drag-proxy ' + this.dropNotAllowed,
shadow: !config || config.shadow !== false,
renderTo: document.body
});
this.el = this.proxy.el;
this.el.show();
this.el.setVisibilityMode(Ext.core.Element.VISIBILITY);
this.el.hide();
this.ghost = Ext.get(this.el.dom.childNodes[1]);
this.dropStatus = this.dropNotAllowed;
},
dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
setStatus : function(cssClass){
cssClass = cssClass || this.dropNotAllowed;
if(this.dropStatus != cssClass){
this.el.replaceCls(this.dropStatus, cssClass);
this.dropStatus = cssClass;
}
},
reset : function(clearGhost){
this.el.dom.className = Ext.baseCSSPrefix + 'dd-drag-proxy ' + this.dropNotAllowed;
this.dropStatus = this.dropNotAllowed;
if(clearGhost){
this.ghost.update("");
}
},
update : function(html){
if(typeof html == "string"){
this.ghost.update(html);
}else{
this.ghost.update("");
html.style.margin = "0";
this.ghost.dom.appendChild(html);
}
var el = this.ghost.dom.firstChild;
if(el){
Ext.fly(el).setStyle('float', 'none');
}
},
getEl : function(){
return this.el;
},
getGhost : function(){
return this.ghost;
},
hide : function(clear) {
this.proxy.hide();
if (clear) {
this.reset(true);
}
},
stop : function(){
if(this.anim && this.anim.isAnimated && this.anim.isAnimated()){
this.anim.stop();
}
},
show : function() {
this.proxy.show();
this.proxy.toFront();
},
sync : function(){
this.proxy.el.sync();
},
repair : function(xy, callback, scope){
this.callback = callback;
this.scope = scope;
if (xy && this.animRepair !== false) {
this.el.addCls(Ext.baseCSSPrefix + 'dd-drag-repair');
this.el.hideUnders(true);
this.anim = this.el.animate({
duration: this.repairDuration || 500,
easing: 'ease-out',
to: {
x: xy[0],
y: xy[1]
},
stopAnimation: true,
callback: this.afterRepair,
scope: this
});
} else {
this.afterRepair();
}
},
afterRepair : function(){
this.hide(true);
if(typeof this.callback == "function"){
this.callback.call(this.scope || this);
}
this.callback = null;
this.scope = null;
},
destroy: function(){
Ext.destroy(this.ghost, this.proxy, this.el);
}
});
Ext.define('Ext.panel.Proxy', {
alternateClassName: 'Ext.dd.PanelProxy',
constructor: function(panel, config){
this.panel = panel;
this.id = this.panel.id +'-ddproxy';
Ext.apply(this, config);
},
insertProxy: true,
setStatus: Ext.emptyFn,
reset: Ext.emptyFn,
update: Ext.emptyFn,
stop: Ext.emptyFn,
sync: Ext.emptyFn,
getEl: function(){
return this.ghost.el;
},
getGhost: function(){
return this.ghost;
},
getProxy: function(){
return this.proxy;
},
hide : function(){
if (this.ghost) {
if (this.proxy) {
this.proxy.remove();
delete this.proxy;
}
this.panel.unghost(null, false);
delete this.ghost;
}
},
show: function(){
if (!this.ghost) {
var panelSize = this.panel.getSize();
this.panel.el.setVisibilityMode(Ext.core.Element.DISPLAY);
this.ghost = this.panel.ghost();
if (this.insertProxy) {
this.proxy = this.panel.el.insertSibling({cls: Ext.baseCSSPrefix + 'panel-dd-spacer'});
this.proxy.setSize(panelSize);
}
}
},
repair: function(xy, callback, scope) {
this.hide();
if (typeof callback == "function") {
callback.call(scope || this);
}
},
moveProxy : function(parentNode, before){
if (this.proxy) {
parentNode.insertBefore(this.proxy.dom, before);
}
}
});
Ext.define('Ext.layout.component.AbstractDock', {
extend: 'Ext.layout.component.Component',
type: 'dock',
autoSizing: true,
beforeLayout: function() {
var returnValue = this.callParent(arguments);
if (returnValue !== false && (!this.initializedBorders || this.childrenChanged) && (!this.owner.border || this.owner.manageBodyBorders)) {
this.handleItemBorders();
this.initializedBorders = true;
}
return returnValue;
},
handleItemBorders: function() {
var owner = this.owner,
body = owner.body,
docked = this.getLayoutItems(),
borders = {
top: [],
right: [],
bottom: [],
left: []
},
oldBorders = this.borders,
opposites = {
top: 'bottom',
right: 'left',
bottom: 'top',
left: 'right'
},
i, ln, item, dock, side;
for (i = 0, ln = docked.length; i < ln; i++) {
item = docked[i];
dock = item.dock;
if (item.ignoreBorderManagement) {
continue;
}
if (!borders[dock].satisfied) {
borders[dock].push(item);
borders[dock].satisfied = true;
}
if (!borders.top.satisfied && opposites[dock] !== 'top') {
borders.top.push(item);
}
if (!borders.right.satisfied && opposites[dock] !== 'right') {
borders.right.push(item);
}
if (!borders.bottom.satisfied && opposites[dock] !== 'bottom') {
borders.bottom.push(item);
}
if (!borders.left.satisfied && opposites[dock] !== 'left') {
borders.left.push(item);
}
}
if (oldBorders) {
for (side in oldBorders) {
if (oldBorders.hasOwnProperty(side)) {
ln = oldBorders[side].length;
if (!owner.manageBodyBorders) {
for (i = 0; i < ln; i++) {
oldBorders[side][i].removeCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
}
if (!oldBorders[side].satisfied && !owner.bodyBorder) {
body.removeCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
}
}
else if (oldBorders[side].satisfied) {
body.setStyle('border-' + side + '-width', '');
}
}
}
}
for (side in borders) {
if (borders.hasOwnProperty(side)) {
ln = borders[side].length;
if (!owner.manageBodyBorders) {
for (i = 0; i < ln; i++) {
borders[side][i].addCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
}
if ((!borders[side].satisfied && !owner.bodyBorder) || owner.bodyBorder === false) {
body.addCls(Ext.baseCSSPrefix + 'docked-noborder-' + side);
}
}
else if (borders[side].satisfied) {
body.setStyle('border-' + side + '-width', '1px');
}
}
}
this.borders = borders;
},
onLayout: function(width, height) {
var me = this,
owner = me.owner,
body = owner.body,
layout = owner.layout,
target = me.getTarget(),
autoWidth = false,
autoHeight = false,
padding, border, frameSize;
var info = me.info = {
boxes: [],
size: {
width: width,
height: height
},
bodyBox: {}
};
delete layout.isAutoDock;
Ext.applyIf(info, me.getTargetInfo());
if (owner && owner.ownerCt && owner.ownerCt.layout && owner.ownerCt.layout.isLayout) {
if (!Ext.isNumber(owner.height) || !Ext.isNumber(owner.width)) {
owner.ownerCt.layout.bindToOwnerCtComponent = true;
}
else {
owner.ownerCt.layout.bindToOwnerCtComponent = false;
}
}
if (height === undefined || height === null || width === undefined || width === null) {
padding = info.padding;
border = info.border;
frameSize = me.frameSize;
if ((height === undefined || height === null) && (width === undefined || width === null)) {
autoHeight = true;
autoWidth = true;
me.setTargetSize(null);
me.setBodyBox({width: null, height: null});
}
else if (height === undefined || height === null) {
autoHeight = true;
me.setTargetSize(width);
me.setBodyBox({width: width - padding.left - border.left - padding.right - border.right - frameSize.left - frameSize.right, height: null});
}
else {
autoWidth = true;
me.setTargetSize(null, height);
me.setBodyBox({width: null, height: height - padding.top - padding.bottom - border.top - border.bottom - frameSize.top - frameSize.bottom});
}
if (layout && layout.isLayout) {
layout.bindToOwnerCtComponent = true;
layout.isAutoDock = layout.autoSize !== true;
layout.layout();
info.autoSizedCtLayout = layout.autoSize === true;
}
me.dockItems(autoWidth, autoHeight);
me.setTargetSize(info.size.width, info.size.height);
}
else {
me.setTargetSize(width, height);
me.dockItems();
}
me.callParent(arguments);
},
dockItems : function(autoWidth, autoHeight) {
this.calculateDockBoxes(autoWidth, autoHeight);
var info = this.info,
boxes = info.boxes,
ln = boxes.length,
dock, i;
for (i = 0; i < ln; i++) {
dock = boxes[i];
dock.item.setPosition(dock.x, dock.y);
if ((autoWidth || autoHeight) && dock.layout && dock.layout.isLayout) {
dock.layout.bindToOwnerCtComponent = true;
}
}
if (!info.autoSizedCtLayout) {
if (autoWidth) {
info.bodyBox.width = null;
}
if (autoHeight) {
info.bodyBox.height = null;
}
}
this.setBodyBox(info.bodyBox);
},
calculateDockBoxes : function(autoWidth, autoHeight) {
var me = this,
target = me.getTarget(),
items = me.getLayoutItems(),
owner = me.owner,
bodyEl = owner.body,
info = me.info,
size = info.size,
ln = items.length,
padding = info.padding,
border = info.border,
frameSize = me.frameSize,
item, i, box, rect;
if (autoHeight) {
size.height = bodyEl.getHeight() + padding.top + border.top + padding.bottom + border.bottom + frameSize.top + frameSize.bottom;
}
else {
size.height = target.getHeight();
}
if (autoWidth) {
size.width = bodyEl.getWidth() + padding.left + border.left + padding.right + border.right + frameSize.left + frameSize.right;
}
else {
size.width = target.getWidth();
}
info.bodyBox = {
x: padding.left + frameSize.left,
y: padding.top + frameSize.top,
width: size.width - padding.left - border.left - padding.right - border.right - frameSize.left - frameSize.right,
height: size.height - border.top - padding.top - border.bottom - padding.bottom - frameSize.top - frameSize.bottom
};
for (i = 0; i < ln; i++) {
item = items[i];
box = me.initBox(item);
if (autoHeight === true) {
box = me.adjustAutoBox(box, i);
}
else {
box = me.adjustSizedBox(box, i);
}
info.boxes.push(box);
}
},
adjustSizedBox : function(box, index) {
var bodyBox = this.info.bodyBox,
frameSize = this.frameSize,
info = this.info,
padding = info.padding,
pos = box.type,
border = info.border;
switch (pos) {
case 'top':
box.y = bodyBox.y;
break;
case 'left':
box.x = bodyBox.x;
break;
case 'bottom':
box.y = (bodyBox.y + bodyBox.height) - box.height;
break;
case 'right':
box.x = (bodyBox.x + bodyBox.width) - box.width;
break;
}
if (box.ignoreFrame) {
if (pos == 'bottom') {
box.y += (frameSize.bottom + padding.bottom + border.bottom);
}
else {
box.y -= (frameSize.top + padding.top + border.top);
}
if (pos == 'right') {
box.x += (frameSize.right + padding.right + border.right);
}
else {
box.x -= (frameSize.left + padding.left + border.left);
}
}
if (!box.overlay) {
switch (pos) {
case 'top':
bodyBox.y += box.height;
bodyBox.height -= box.height;
break;
case 'left':
bodyBox.x += box.width;
bodyBox.width -= box.width;
break;
case 'bottom':
bodyBox.height -= box.height;
break;
case 'right':
bodyBox.width -= box.width;
break;
}
}
return box;
},
adjustAutoBox : function (box, index) {
var info = this.info,
owner = this.owner,
bodyBox = info.bodyBox,
size = info.size,
boxes = info.boxes,
boxesLn = boxes.length,
pos = box.type,
frameSize = this.frameSize,
padding = info.padding,
border = info.border,
autoSizedCtLayout = info.autoSizedCtLayout,
ln = (boxesLn < index) ? boxesLn : index,
i, adjustBox;
if (pos == 'top' || pos == 'bottom') {
for (i = 0; i < ln; i++) {
adjustBox = boxes[i];
if (adjustBox.stretched && adjustBox.type == 'left' || adjustBox.type == 'right') {
adjustBox.height += box.height;
}
else if (adjustBox.type == 'bottom') {
adjustBox.y += box.height;
}
}
}
switch (pos) {
case 'top':
box.y = bodyBox.y;
if (!box.overlay) {
bodyBox.y += box.height;
if (owner.isFixedHeight()) {
bodyBox.height -= box.height;
} else {
size.height += box.height;
}
}
break;
case 'bottom':
if (!box.overlay) {
if (owner.isFixedHeight()) {
bodyBox.height -= box.height;
} else {
size.height += box.height;
}
}
box.y = (bodyBox.y + bodyBox.height);
break;
case 'left':
box.x = bodyBox.x;
if (!box.overlay) {
bodyBox.x += box.width;
if (owner.isFixedWidth()) {
bodyBox.width -= box.width;
} else {
size.width += box.width;
}
}
break;
case 'right':
if (!box.overlay) {
if (owner.isFixedWidth()) {
bodyBox.width -= box.width;
} else {
size.width += box.width;
}
}
box.x = (bodyBox.x + bodyBox.width);
break;
}
if (box.ignoreFrame) {
if (pos == 'bottom') {
box.y += (frameSize.bottom + padding.bottom + border.bottom);
}
else {
box.y -= (frameSize.top + padding.top + border.top);
}
if (pos == 'right') {
box.x += (frameSize.right + padding.right + border.right);
}
else {
box.x -= (frameSize.left + padding.left + border.left);
}
}
return box;
},
initBox : function(item) {
var me = this,
bodyBox = me.info.bodyBox,
horizontal = (item.dock == 'top' || item.dock == 'bottom'),
owner = me.owner,
frameSize = me.frameSize,
info = me.info,
padding = info.padding,
border = info.border,
box = {
item: item,
overlay: item.overlay,
type: item.dock,
offsets: Ext.core.Element.parseBox(item.offsets || {}),
ignoreFrame: item.ignoreParentFrame
};
if (item.stretch !== false) {
box.stretched = true;
if (horizontal) {
box.x = bodyBox.x + box.offsets.left;
box.width = bodyBox.width - (box.offsets.left + box.offsets.right);
if (box.ignoreFrame) {
box.width += (frameSize.left + frameSize.right + border.left + border.right + padding.left + padding.right);
}
item.setCalculatedSize(box.width - item.el.getMargin('lr'), undefined, owner);
}
else {
box.y = bodyBox.y + box.offsets.top;
box.height = bodyBox.height - (box.offsets.bottom + box.offsets.top);
if (box.ignoreFrame) {
box.height += (frameSize.top + frameSize.bottom + border.top + border.bottom + padding.top + padding.bottom);
}
item.setCalculatedSize(undefined, box.height - item.el.getMargin('tb'), owner);
if (!Ext.supports.ComputedStyle) {
item.el.repaint();
}
}
}
else {
item.doComponentLayout();
box.width = item.getWidth() - (box.offsets.left + box.offsets.right);
box.height = item.getHeight() - (box.offsets.bottom + box.offsets.top);
box.y += box.offsets.top;
if (horizontal) {
box.x = (item.align == 'right') ? bodyBox.width - box.width : bodyBox.x;
box.x += box.offsets.left;
}
}
if (box.width == undefined) {
box.width = item.getWidth() + item.el.getMargin('lr');
}
if (box.height == undefined) {
box.height = item.getHeight() + item.el.getMargin('tb');
}
return box;
},
getLayoutItems : function() {
var it = this.owner.getDockedItems(),
ln = it.length,
i = 0,
result = [];
for (; i < ln; i++) {
if (it[i].isVisible(true)) {
result.push(it[i]);
}
}
return result;
},
renderItems: function(items, target) {
var cns = target.dom.childNodes,
cnsLn = cns.length,
ln = items.length,
domLn = 0,
i, j, cn, item;
for (i = 0; i < cnsLn; i++) {
cn = Ext.get(cns[i]);
for (j = 0; j < ln; j++) {
item = items[j];
if (item.rendered && (cn.id == item.el.id || cn.down('#' + item.el.id))) {
break;
}
}
if (j === ln) {
domLn++;
}
}
for (i = 0, j = 0; i < ln; i++, j++) {
item = items[i];
if (i === j && (item.dock === 'right' || item.dock === 'bottom')) {
j += domLn;
}
if (item && !item.rendered) {
this.renderItem(item, target, j);
}
else if (!this.isValidParent(item, target, j)) {
this.moveItem(item, target, j);
}
}
},
setBodyBox : function(box) {
var me = this,
owner = me.owner,
body = owner.body,
info = me.info,
bodyMargin = info.bodyMargin,
padding = info.padding,
border = info.border,
frameSize = me.frameSize;
if (owner.collapsed) {
return;
}
if (Ext.isNumber(box.width)) {
box.width -= bodyMargin.left + bodyMargin.right;
}
if (Ext.isNumber(box.height)) {
box.height -= bodyMargin.top + bodyMargin.bottom;
}
me.setElementSize(body, box.width, box.height);
if (Ext.isNumber(box.x)) {
body.setLeft(box.x - padding.left - frameSize.left);
}
if (Ext.isNumber(box.y)) {
body.setTop(box.y - padding.top - frameSize.top);
}
},
configureItem : function(item, pos) {
this.callParent(arguments);
if (item.dock == 'top' || item.dock == 'bottom') {
item.layoutManagedWidth = 1;
item.layoutManagedHeight = 2;
} else {
item.layoutManagedWidth = 2;
item.layoutManagedHeight = 1;
}
item.addCls(Ext.baseCSSPrefix + 'docked');
item.addClsWithUI('docked-' + item.dock);
},
afterRemove : function(item) {
this.callParent(arguments);
if (this.itemCls) {
item.el.removeCls(this.itemCls + '-' + item.dock);
}
var dom = item.el.dom;
if (!item.destroying && dom) {
dom.parentNode.removeChild(dom);
}
this.childrenChanged = true;
}
});
Ext.define('Ext.util.Memento', function () {
function captureOne (src, target, prop) {
src[prop] = target[prop];
}
function removeOne (src, target, prop) {
delete src[prop];
}
function restoreOne (src, target, prop) {
var value = src[prop];
if (value || src.hasOwnProperty(prop)) {
restoreValue(target, prop, value);
}
}
function restoreValue (target, prop, value) {
if (Ext.isDefined(value)) {
target[prop] = value;
} else {
delete target[prop];
}
}
function doMany (doOne, src, target, props) {
if (src) {
if (Ext.isArray(props)) {
Ext.each(props, function (prop) {
doOne(src, target, prop);
});
} else {
doOne(src, target, props);
}
}
}
return {
data: null,
target: null,
constructor: function (target, props) {
if (target) {
this.target = target;
if (props) {
this.capture(props);
}
}
},
capture: function (props, target) {
doMany(captureOne, this.data || (this.data = {}), target || this.target, props);
},
remove: function (props) {
doMany(removeOne, this.data, null, props);
},
restore: function (props, clear, target) {
doMany(restoreOne, this.data, target || this.target, props);
if (clear !== false) {
this.remove(props);
}
},
restoreAll: function (clear, target) {
var me = this,
t = target || this.target;
Ext.Object.each(me.data, function (prop, value) {
restoreValue(t, prop, value);
});
if (clear !== false) {
delete me.data;
}
}
};
}());
Ext.define('Ext.app.EventBus', {
requires: [
'Ext.util.Event'
],
mixins: {
observable: 'Ext.util.Observable'
},
constructor: function() {
this.mixins.observable.constructor.call(this);
this.bus = {};
var me = this;
Ext.override(Ext.Component, {
fireEvent: function(ev) {
if (Ext.util.Observable.prototype.fireEvent.apply(this, arguments) !== false) {
return me.dispatch.call(me, ev, this, arguments);
}
return false;
}
});
},
dispatch: function(ev, target, args) {
var bus = this.bus,
selectors = bus[ev],
selector, controllers, id, events, event, i, ln;
if (selectors) {
for (selector in selectors) {
if (target.is(selector)) {
controllers = selectors[selector];
for (id in controllers) {
events = controllers[id];
for (i = 0, ln = events.length; i < ln; i++) {
event = events[i];
if (event.fire.apply(event, Array.prototype.slice.call(args, 1)) === false) {
return false;
};
}
}
}
}
}
},
control: function(selectors, listeners, controller) {
var bus = this.bus,
selector, fn;
if (Ext.isString(selectors)) {
selector = selectors;
selectors = {};
selectors[selector] = listeners;
this.control(selectors, null, controller);
return;
}
Ext.Object.each(selectors, function(selector, listeners) {
Ext.Object.each(listeners, function(ev, listener) {
var options = {},
scope = controller,
event = Ext.create('Ext.util.Event', controller, ev);
if (Ext.isObject(listener)) {
options = listener;
listener = options.fn;
scope = options.scope || controller;
delete options.fn;
delete options.scope;
}
event.addListener(listener, scope, options);
bus[ev] = bus[ev] || {};
bus[ev][selector] = bus[ev][selector] || {};
bus[ev][selector][controller.id] = bus[ev][selector][controller.id] || [];
bus[ev][selector][controller.id].push(event);
});
});
}
});
Ext.define('Ext.data.Types', {
singleton: true,
requires: ['Ext.data.SortTypes']
}, function() {
var st = Ext.data.SortTypes;
Ext.apply(Ext.data.Types, {
stripRe: /[\$,%]/g,
AUTO: {
convert: function(v) {
return v;
},
sortType: st.none,
type: 'auto'
},
STRING: {
convert: function(v) {
var defaultValue = this.useNull ? null : '';
return (v === undefined || v === null) ? defaultValue : String(v);
},
sortType: st.asUCString,
type: 'string'
},
INT: {
convert: function(v) {
return v !== undefined && v !== null && v !== '' ?
parseInt(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
},
sortType: st.none,
type: 'int'
},
FLOAT: {
convert: function(v) {
return v !== undefined && v !== null && v !== '' ?
parseFloat(String(v).replace(Ext.data.Types.stripRe, ''), 10) : (this.useNull ? null : 0);
},
sortType: st.none,
type: 'float'
},
BOOL: {
convert: function(v) {
if (this.useNull && v === undefined || v === null || v === '') {
return null;
}
return v === true || v === 'true' || v == 1;
},
sortType: st.none,
type: 'bool'
},
DATE: {
convert: function(v) {
var df = this.dateFormat;
if (!v) {
return null;
}
if (Ext.isDate(v)) {
return v;
}
if (df) {
if (df == 'timestamp') {
return new Date(v*1000);
}
if (df == 'time') {
return new Date(parseInt(v, 10));
}
return Ext.Date.parse(v, df);
}
var parsed = Date.parse(v);
return parsed ? new Date(parsed) : null;
},
sortType: st.asDate,
type: 'date'
}
});
Ext.apply(Ext.data.Types, {
BOOLEAN: this.BOOL,
INTEGER: this.INT,
NUMBER: this.FLOAT
});
});
Ext.define('Ext.data.Field', {
requires: ['Ext.data.Types', 'Ext.data.SortTypes'],
alias: 'data.field',
constructor : function(config) {
if (Ext.isString(config)) {
config = {name: config};
}
Ext.apply(this, config);
var types = Ext.data.Types,
st = this.sortType,
t;
if (this.type) {
if (Ext.isString(this.type)) {
this.type = types[this.type.toUpperCase()] || types.AUTO;
}
} else {
this.type = types.AUTO;
}
if (Ext.isString(st)) {
this.sortType = Ext.data.SortTypes[st];
} else if(Ext.isEmpty(st)) {
this.sortType = this.type.sortType;
}
if (!this.convert) {
this.convert = this.type.convert;
}
},
dateFormat: null,
useNull: false,
defaultValue: "",
mapping: null,
sortType : null,
sortDir : "ASC",
allowBlank : true,
persist: true
});
Ext.define('Ext.data.reader.Reader', {
requires: ['Ext.data.ResultSet'],
alternateClassName: ['Ext.data.Reader', 'Ext.data.DataReader'],
totalProperty: 'total',
successProperty: 'success',
root: '',
implicitIncludes: true,
isReader: true,
constructor: function(config) {
var me = this;
Ext.apply(me, config || {});
me.fieldCount = 0;
me.model = Ext.ModelManager.getModel(config.model);
if (me.model) {
me.buildExtractors();
}
},
setModel: function(model, setOnProxy) {
var me = this;
me.model = Ext.ModelManager.getModel(model);
me.buildExtractors(true);
if (setOnProxy && me.proxy) {
me.proxy.setModel(me.model, true);
}
},
read: function(response) {
var data = response;
if (response && response.responseText) {
data = this.getResponseData(response);
}
if (data) {
return this.readRecords(data);
} else {
return this.nullResultSet;
}
},
readRecords: function(data) {
var me = this;
if (me.fieldCount !== me.getFields().length) {
me.buildExtractors(true);
}
me.rawData = data;
data = me.getData(data);
var root = Ext.isArray(data) ? data : me.getRoot(data),
success = true,
recordCount = 0,
total, value, records, message;
if (root) {
total = root.length;
}
if (me.totalProperty) {
value = parseInt(me.getTotal(data), 10);
if (!isNaN(value)) {
total = value;
}
}
if (me.successProperty) {
value = me.getSuccess(data);
if (value === false || value === 'false') {
success = false;
}
}
if (me.messageProperty) {
message = me.getMessage(data);
}
if (root) {
records = me.extractData(root);
recordCount = records.length;
} else {
recordCount = 0;
records = [];
}
return Ext.create('Ext.data.ResultSet', {
total : total || recordCount,
count : recordCount,
records: records,
success: success,
message: message
});
},
extractData : function(root) {
var me = this,
values = [],
records = [],
Model = me.model,
i = 0,
length = root.length,
idProp = me.getIdProperty(),
node, id, record;
if (!root.length && Ext.isObject(root)) {
root = [root];
length = 1;
}
for (; i < length; i++) {
node = root[i];
values = me.extractValues(node);
id = me.getId(node);
record = new Model(values, id, node);
records.push(record);
if (me.implicitIncludes) {
me.readAssociated(record, node);
}
}
return records;
},
readAssociated: function(record, data) {
var associations = record.associations.items,
i = 0,
length = associations.length,
association, associationData, proxy, reader;
for (; i < length; i++) {
association = associations[i];
associationData = this.getAssociatedDataRoot(data, association.associationKey || association.name);
if (associationData) {
reader = association.getReader();
if (!reader) {
proxy = association.associatedModel.proxy;
if (proxy) {
reader = proxy.getReader();
} else {
reader = new this.constructor({
model: association.associatedName
});
}
}
association.read(record, reader, associationData);
}
}
},
getAssociatedDataRoot: function(data, associationName) {
return data[associationName];
},
getFields: function() {
return this.model.prototype.fields.items;
},
extractValues: function(data) {
var fields = this.getFields(),
i = 0,
length = fields.length,
output = {},
field, value;
for (; i < length; i++) {
field = fields[i];
value = this.extractorFunctions[i](data);
output[field.name] = value;
}
return output;
},
getData: function(data) {
return data;
},
getRoot: function(data) {
return data;
},
getResponseData: function(response) {
},
onMetaChange : function(meta) {
var fields = meta.fields,
newModel;
Ext.apply(this, meta);
if (fields) {
newModel = Ext.define("Ext.data.reader.Json-Model" + Ext.id(), {
extend: 'Ext.data.Model',
fields: fields
});
this.setModel(newModel, true);
} else {
this.buildExtractors(true);
}
},
getIdProperty: function(){
var prop = this.idProperty;
if (Ext.isEmpty(prop)) {
prop = this.model.prototype.idProperty;
}
return prop;
},
buildExtractors: function(force) {
var me = this,
idProp = me.getIdProperty(),
totalProp = me.totalProperty,
successProp = me.successProperty,
messageProp = me.messageProperty,
accessor;
if (force === true) {
delete me.extractorFunctions;
}
if (me.extractorFunctions) {
return;
}
if (totalProp) {
me.getTotal = me.createAccessor(totalProp);
}
if (successProp) {
me.getSuccess = me.createAccessor(successProp);
}
if (messageProp) {
me.getMessage = me.createAccessor(messageProp);
}
if (idProp) {
accessor = me.createAccessor(idProp);
me.getId = function(record) {
var id = accessor.call(me, record);
return (id === undefined || id === '') ? null : id;
};
} else {
me.getId = function() {
return null;
};
}
me.buildFieldExtractors();
},
buildFieldExtractors: function() {
var me = this,
fields = me.getFields(),
ln = fields.length,
i = 0,
extractorFunctions = [],
field, map;
for (; i < ln; i++) {
field = fields[i];
map = (field.mapping !== undefined && field.mapping !== null) ? field.mapping : field.name;
extractorFunctions.push(me.createAccessor(map));
}
me.fieldCount = ln;
me.extractorFunctions = extractorFunctions;
}
}, function() {
Ext.apply(this, {
nullResultSet: Ext.create('Ext.data.ResultSet', {
total : 0,
count : 0,
records: [],
success: true
})
});
});
Ext.define('Ext.data.reader.Json', {
extend: 'Ext.data.reader.Reader',
alternateClassName: 'Ext.data.JsonReader',
alias : 'reader.json',
root: '',
useSimpleAccessors: false,
readRecords: function(data) {
if (data.metaData) {
this.onMetaChange(data.metaData);
}
this.jsonData = data;
return this.callParent([data]);
},
getResponseData: function(response) {
try {
var data = Ext.decode(response.responseText);
}
catch (ex) {
Ext.Error.raise({
response: response,
json: response.responseText,
parseError: ex,
msg: 'Unable to parse the JSON returned by the server: ' + ex.toString()
});
}
return data;
},
buildExtractors : function() {
var me = this;
me.callParent(arguments);
if (me.root) {
me.getRoot = me.createAccessor(me.root);
} else {
me.getRoot = function(root) {
return root;
};
}
},
extractData: function(root) {
var recordName = this.record,
data = [],
length, i;
if (recordName) {
length = root.length;
for (i = 0; i < length; i++) {
data[i] = root[i][recordName];
}
} else {
data = root;
}
return this.callParent([data]);
},
createAccessor: function() {
var re = /[\[\.]/;
return function(expr) {
if (Ext.isEmpty(expr)) {
return Ext.emptyFn;
}
if (Ext.isFunction(expr)) {
return expr;
}
if (this.useSimpleAccessors !== true) {
var i = String(expr).search(re);
if (i >= 0) {
return Ext.functionFactory('obj', 'return obj' + (i > 0 ? '.' : '') + expr);
}
}
return function(obj) {
return obj[expr];
};
};
}()
});
Ext.define('Ext.data.writer.Json', {
extend: 'Ext.data.writer.Writer',
alternateClassName: 'Ext.data.JsonWriter',
alias: 'writer.json',
root: undefined,
encode: false,
allowSingle: true,
writeRecords: function(request, data) {
var root = this.root;
if (this.allowSingle && data.length == 1) {
data = data[0];
}
if (this.encode) {
if (root) {
request.params[root] = Ext.encode(data);
} else {
}
} else {
request.jsonData = request.jsonData || {};
if (root) {
request.jsonData[root] = data;
} else {
request.jsonData = data;
}
}
return request;
}
});
Ext.define('Ext.data.proxy.Proxy', {
alias: 'proxy.proxy',
alternateClassName: ['Ext.data.DataProxy', 'Ext.data.Proxy'],
requires: [
'Ext.data.reader.Json',
'Ext.data.writer.Json'
],
uses: [
'Ext.data.Batch',
'Ext.data.Operation',
'Ext.data.Model'
],
mixins: {
observable: 'Ext.util.Observable'
},
batchOrder: 'create,update,destroy',
batchActions: true,
defaultReaderType: 'json',
defaultWriterType: 'json',
isProxy: true,
constructor: function(config) {
config = config || {};
if (config.model === undefined) {
delete config.model;
}
this.mixins.observable.constructor.call(this, config);
if (this.model !== undefined && !(this.model instanceof Ext.data.Model)) {
this.setModel(this.model);
}
},
setModel: function(model, setOnStore) {
this.model = Ext.ModelManager.getModel(model);
var reader = this.reader,
writer = this.writer;
this.setReader(reader);
this.setWriter(writer);
if (setOnStore && this.store) {
this.store.setModel(this.model);
}
},
getModel: function() {
return this.model;
},
setReader: function(reader) {
var me = this;
if (reader === undefined || typeof reader == 'string') {
reader = {
type: reader
};
}
if (reader.isReader) {
reader.setModel(me.model);
} else {
Ext.applyIf(reader, {
proxy: me,
model: me.model,
type : me.defaultReaderType
});
reader = Ext.createByAlias('reader.' + reader.type, reader);
}
me.reader = reader;
return me.reader;
},
getReader: function() {
return this.reader;
},
setWriter: function(writer) {
if (writer === undefined || typeof writer == 'string') {
writer = {
type: writer
};
}
if (!(writer instanceof Ext.data.writer.Writer)) {
Ext.applyIf(writer, {
model: this.model,
type : this.defaultWriterType
});
writer = Ext.createByAlias('writer.' + writer.type, writer);
}
this.writer = writer;
return this.writer;
},
getWriter: function() {
return this.writer;
},
create: Ext.emptyFn,
read: Ext.emptyFn,
update: Ext.emptyFn,
destroy: Ext.emptyFn,
batch: function(operations, listeners) {
var me = this,
batch = Ext.create('Ext.data.Batch', {
proxy: me,
listeners: listeners || {}
}),
useBatch = me.batchActions,
records;
Ext.each(me.batchOrder.split(','), function(action) {
records = operations[action];
if (records) {
if (useBatch) {
batch.add(Ext.create('Ext.data.Operation', {
action: action,
records: records
}));
} else {
Ext.each(records, function(record){
batch.add(Ext.create('Ext.data.Operation', {
action : action,
records: [record]
}));
});
}
}
}, me);
batch.start();
return batch;
}
}, function() {
Ext.data.DataProxy = this;
});
Ext.define('Ext.data.proxy.Server', {
extend: 'Ext.data.proxy.Proxy',
alias : 'proxy.server',
alternateClassName: 'Ext.data.ServerProxy',
uses : ['Ext.data.Request'],
pageParam: 'page',
startParam: 'start',
limitParam: 'limit',
groupParam: 'group',
sortParam: 'sort',
filterParam: 'filter',
directionParam: 'dir',
simpleSortMode: false,
noCache : true,
cacheString: "_dc",
timeout : 30000,
constructor: function(config) {
var me = this;
config = config || {};
this.addEvents(
'exception'
);
me.callParent([config]);
me.extraParams = config.extraParams || {};
me.api = config.api || {};
me.nocache = me.noCache;
},
create: function() {
return this.doRequest.apply(this, arguments);
},
read: function() {
return this.doRequest.apply(this, arguments);
},
update: function() {
return this.doRequest.apply(this, arguments);
},
destroy: function() {
return this.doRequest.apply(this, arguments);
},
buildRequest: function(operation) {
var params = Ext.applyIf(operation.params || {}, this.extraParams || {}),
request;
params = Ext.applyIf(params, this.getParams(params, operation));
if (operation.id && !params.id) {
params.id = operation.id;
}
request = Ext.create('Ext.data.Request', {
params : params,
action : operation.action,
records : operation.records,
operation: operation,
url : operation.url
});
request.url = this.buildUrl(request);
operation.request = request;
return request;
},
processResponse: function(success, operation, request, response, callback, scope){
var me = this,
reader,
result,
records,
length,
mc,
record,
i;
if (success === true) {
reader = me.getReader();
result = reader.read(me.extractResponseData(response));
records = result.records;
length = records.length;
if (result.success !== false) {
mc = Ext.create('Ext.util.MixedCollection', true, function(r) {return r.getId();});
mc.addAll(operation.records);
for (i = 0; i < length; i++) {
record = mc.get(records[i].getId());
if (record) {
record.beginEdit();
record.set(record.data);
record.endEdit(true);
}
}
Ext.apply(operation, {
response: response,
resultSet: result
});
operation.setCompleted();
operation.setSuccessful();
} else {
operation.setException(result.message);
me.fireEvent('exception', this, response, operation);
}
} else {
me.setException(operation, response);
me.fireEvent('exception', this, response, operation);
}
if (typeof callback == 'function') {
callback.call(scope || me, operation);
}
me.afterRequest(request, success);
},
setException: function(operation, response){
operation.setException({
status: response.status,
statusText: response.statusText
});
},
extractResponseData: function(response){
return response;
},
applyEncoding: function(value){
return Ext.encode(value);
},
encodeSorters: function(sorters) {
var min = [],
length = sorters.length,
i = 0;
for (; i < length; i++) {
min[i] = {
property : sorters[i].property,
direction: sorters[i].direction
};
}
return this.applyEncoding(min);
},
encodeFilters: function(filters) {
var min = [],
length = filters.length,
i = 0;
for (; i < length; i++) {
min[i] = {
property: filters[i].property,
value : filters[i].value
};
}
return this.applyEncoding(min);
},
getParams: function(params, operation) {
params = params || {};
var me = this,
isDef = Ext.isDefined,
groupers = operation.groupers,
sorters = operation.sorters,
filters = operation.filters,
page = operation.page,
start = operation.start,
limit = operation.limit,
simpleSortMode = me.simpleSortMode,
pageParam = me.pageParam,
startParam = me.startParam,
limitParam = me.limitParam,
groupParam = me.groupParam,
sortParam = me.sortParam,
filterParam = me.filterParam,
directionParam = me.directionParam;
if (pageParam && isDef(page)) {
params[pageParam] = page;
}
if (startParam && isDef(start)) {
params[startParam] = start;
}
if (limitParam && isDef(limit)) {
params[limitParam] = limit;
}
if (groupParam && groupers && groupers.length > 0) {
params[groupParam] = me.encodeSorters(groupers);
}
if (sortParam && sorters && sorters.length > 0) {
if (simpleSortMode) {
params[sortParam] = sorters[0].property;
params[directionParam] = sorters[0].direction;
} else {
params[sortParam] = me.encodeSorters(sorters);
}
}
if (filterParam && filters && filters.length > 0) {
params[filterParam] = me.encodeFilters(filters);
}
return params;
},
buildUrl: function(request) {
var me = this,
url = me.getUrl(request);
if (me.noCache) {
url = Ext.urlAppend(url, Ext.String.format("{0}={1}", me.cacheString, Ext.Date.now()));
}
return url;
},
getUrl: function(request){
return request.url || this.api[request.action] || this.url;
},
doRequest: function(operation, callback, scope) {
},
afterRequest: Ext.emptyFn,
onDestroy: function() {
Ext.destroy(this.reader, this.writer);
}
});
Ext.define('Ext.data.proxy.Ajax', {
requires: ['Ext.util.MixedCollection', 'Ext.Ajax'],
extend: 'Ext.data.proxy.Server',
alias: 'proxy.ajax',
alternateClassName: ['Ext.data.HttpProxy', 'Ext.data.AjaxProxy'],
actionMethods: {
create : 'POST',
read : 'GET',
update : 'POST',
destroy: 'POST'
},
doRequest: function(operation, callback, scope) {
var writer = this.getWriter(),
request = this.buildRequest(operation, callback, scope);
if (operation.allowWrite()) {
request = writer.write(request);
}
Ext.apply(request, {
headers : this.headers,
timeout : this.timeout,
scope : this,
callback : this.createRequestCallback(request, operation, callback, scope),
method : this.getMethod(request),
disableCaching: false
});
Ext.Ajax.request(request);
return request;
},
getMethod: function(request) {
return this.actionMethods[request.action];
},
createRequestCallback: function(request, operation, callback, scope) {
var me = this;
return function(options, success, response) {
me.processResponse(success, operation, request, response, callback, scope);
};
}
}, function() {
Ext.data.HttpProxy = this;
});
Ext.define('Ext.data.Model', {
alternateClassName: 'Ext.data.Record',
mixins: {
observable: 'Ext.util.Observable'
},
requires: [
'Ext.ModelManager',
'Ext.data.Field',
'Ext.data.Errors',
'Ext.data.Operation',
'Ext.data.validations',
'Ext.data.proxy.Ajax',
'Ext.util.MixedCollection'
],
onClassExtended: function(cls, data) {
var onBeforeClassCreated = data.onBeforeClassCreated;
data.onBeforeClassCreated = function(cls, data) {
var me = this,
name = Ext.getClassName(cls),
prototype = cls.prototype,
superCls = cls.prototype.superclass,
validations = data.validations || [],
fields = data.fields || [],
associations = data.associations || [],
belongsTo = data.belongsTo,
hasMany = data.hasMany,
fieldsMixedCollection = new Ext.util.MixedCollection(false, function(field) {
return field.name;
}),
associationsMixedCollection = new Ext.util.MixedCollection(false, function(association) {
return association.name;
}),
superValidations = superCls.validations,
superFields = superCls.fields,
superAssociations = superCls.associations,
association, i, ln,
dependencies = [];
cls.modelName = name;
prototype.modelName = name;
if (superValidations) {
validations = superValidations.concat(validations);
}
data.validations = validations;
if (superFields) {
fields = superFields.items.concat(fields);
}
for (i = 0, ln = fields.length; i < ln; ++i) {
fieldsMixedCollection.add(new Ext.data.Field(fields[i]));
}
data.fields = fieldsMixedCollection;
if (belongsTo) {
belongsTo = Ext.Array.from(belongsTo);
for (i = 0, ln = belongsTo.length; i < ln; ++i) {
association = belongsTo[i];
if (!Ext.isObject(association)) {
association = {model: association};
}
association.type = 'belongsTo';
associations.push(association);
}
delete data.belongsTo;
}
if (hasMany) {
hasMany = Ext.Array.from(hasMany);
for (i = 0, ln = hasMany.length; i < ln; ++i) {
association = hasMany[i];
if (!Ext.isObject(association)) {
association = {model: association};
}
association.type = 'hasMany';
associations.push(association);
}
delete data.hasMany;
}
if (superAssociations) {
associations = superAssociations.items.concat(associations);
}
for (i = 0, ln = associations.length; i < ln; ++i) {
dependencies.push('association.' + associations[i].type.toLowerCase());
}
if (data.proxy) {
if (typeof data.proxy === 'string') {
dependencies.push('proxy.' + data.proxy);
}
else if (typeof data.proxy.type === 'string') {
dependencies.push('proxy.' + data.proxy.type);
}
}
Ext.require(dependencies, function() {
Ext.ModelManager.registerType(name, cls);
for (i = 0, ln = associations.length; i < ln; ++i) {
association = associations[i];
Ext.apply(association, {
ownerModel: name,
associatedModel: association.model
});
if (Ext.ModelManager.getModel(association.model) === undefined) {
Ext.ModelManager.registerDeferredAssociation(association);
} else {
associationsMixedCollection.add(Ext.data.Association.create(association));
}
}
data.associations = associationsMixedCollection;
onBeforeClassCreated.call(me, cls, data);
cls.setProxy(cls.prototype.proxy || cls.prototype.defaultProxyType);
Ext.ModelManager.onModelDefined(cls);
});
};
},
inheritableStatics: {
setProxy: function(proxy) {
if (!proxy.isProxy) {
if (typeof proxy == "string") {
proxy = {
type: proxy
};
}
proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
}
proxy.setModel(this);
this.proxy = this.prototype.proxy = proxy;
return proxy;
},
getProxy: function() {
return this.proxy;
},
load: function(id, config) {
config = Ext.apply({}, config);
config = Ext.applyIf(config, {
action: 'read',
id : id
});
var operation = Ext.create('Ext.data.Operation', config),
scope = config.scope || this,
record = null,
callback;
callback = function(operation) {
if (operation.wasSuccessful()) {
record = operation.getRecords()[0];
Ext.callback(config.success, scope, [record, operation]);
} else {
Ext.callback(config.failure, scope, [record, operation]);
}
Ext.callback(config.callback, scope, [record, operation]);
};
this.proxy.read(operation, callback, this);
}
},
statics: {
PREFIX : 'ext-record',
AUTO_ID: 1,
EDIT : 'edit',
REJECT : 'reject',
COMMIT : 'commit',
id: function(rec) {
var id = [this.PREFIX, '-', this.AUTO_ID++].join('');
rec.phantom = true;
rec.internalId = id;
return id;
}
},
editing : false,
dirty : false,
persistenceProperty: 'data',
evented: false,
isModel: true,
phantom : false,
idProperty: 'id',
defaultProxyType: 'ajax',
constructor: function(data, id, raw) {
data = data || {};
var me = this,
fields,
length,
field,
name,
i,
isArray = Ext.isArray(data),
newData = isArray ? {} : null;
me.internalId = (id || id === 0) ? id : Ext.data.Model.id(me);
me.raw = raw;
Ext.applyIf(me, {
data: {}
});
me.modified = {};
if (me.persistanceProperty) {
me.persistenceProperty = me.persistanceProperty;
}
me[me.persistenceProperty] = {};
me.mixins.observable.constructor.call(me);
fields = me.fields.items;
length = fields.length;
for (i = 0; i < length; i++) {
field = fields[i];
name = field.name;
if (isArray){
newData[name] = data[i];
}
else if (data[name] === undefined) {
data[name] = field.defaultValue;
}
}
me.set(newData || data);
me.dirty = false;
me.modified = {};
if (me.getId()) {
me.phantom = false;
}
if (typeof me.init == 'function') {
me.init();
}
me.id = me.modelName + '-' + me.internalId;
},
get: function(field) {
return this[this.persistenceProperty][field];
},
set: function(fieldName, value) {
var me = this,
fields = me.fields,
modified = me.modified,
convertFields = [],
field, key, i, currentValue;
if (arguments.length == 1 && Ext.isObject(fieldName)) {
for (key in fieldName) {
if (fieldName.hasOwnProperty(key)) {
field = fields.get(key);
if (field && field.convert !== field.type.convert) {
convertFields.push(key);
continue;
}
me.set(key, fieldName[key]);
}
}
for (i = 0; i < convertFields.length; i++) {
field = convertFields[i];
me.set(field, fieldName[field]);
}
} else {
if (fields) {
field = fields.get(fieldName);
if (field && field.convert) {
value = field.convert(value, me);
}
}
currentValue = me.get(fieldName);
me[me.persistenceProperty][fieldName] = value;
if (field && field.persist && !me.isEqual(currentValue, value)) {
if (me.isModified(fieldName)) {
if (me.isEqual(modified[fieldName], value)) {
delete modified[fieldName];
me.dirty = false;
for (key in modified) {
if (modified.hasOwnProperty(key)){
me.dirty = true;
break;
}
}
}
} else {
me.dirty = true;
modified[fieldName] = currentValue;
}
}
if (!me.editing) {
me.afterEdit();
}
}
},
isEqual: function(a, b){
if (Ext.isDate(a) && Ext.isDate(b)) {
return a.getTime() === b.getTime();
}
return a === b;
},
beginEdit : function(){
var me = this;
if (!me.editing) {
me.editing = true;
me.dirtySave = me.dirty;
me.dataSave = Ext.apply({}, me[me.persistenceProperty]);
me.modifiedSave = Ext.apply({}, me.modified);
}
},
cancelEdit : function(){
var me = this;
if (me.editing) {
me.editing = false;
me.modified = me.modifiedSave;
me[me.persistenceProperty] = me.dataSave;
me.dirty = me.dirtySave;
delete me.modifiedSave;
delete me.dataSave;
delete me.dirtySave;
}
},
endEdit : function(silent){
var me = this;
if (me.editing) {
me.editing = false;
delete me.modifiedSave;
delete me.dataSave;
delete me.dirtySave;
if (silent !== true && me.dirty) {
me.afterEdit();
}
}
},
getChanges : function(){
var modified = this.modified,
changes = {},
field;
for (field in modified) {
if (modified.hasOwnProperty(field)){
changes[field] = this.get(field);
}
}
return changes;
},
isModified : function(fieldName) {
return this.modified.hasOwnProperty(fieldName);
},
setDirty : function() {
var me = this,
name;
me.dirty = true;
me.fields.each(function(field) {
if (field.persist) {
name = field.name;
me.modified[name] = me.get(name);
}
}, me);
},
reject : function(silent) {
var me = this,
modified = me.modified,
field;
for (field in modified) {
if (modified.hasOwnProperty(field)) {
if (typeof modified[field] != "function") {
me[me.persistenceProperty][field] = modified[field];
}
}
}
me.dirty = false;
me.editing = false;
me.modified = {};
if (silent !== true) {
me.afterReject();
}
},
commit : function(silent) {
var me = this;
me.dirty = false;
me.editing = false;
me.modified = {};
if (silent !== true) {
me.afterCommit();
}
},
copy : function(newId) {
var me = this;
return new me.self(Ext.apply({}, me[me.persistenceProperty]), newId || me.internalId);
},
setProxy: function(proxy) {
if (!proxy.isProxy) {
if (typeof proxy === "string") {
proxy = {
type: proxy
};
}
proxy = Ext.createByAlias("proxy." + proxy.type, proxy);
}
proxy.setModel(this.self);
this.proxy = proxy;
return proxy;
},
getProxy: function() {
return this.proxy;
},
validate: function() {
var errors = Ext.create('Ext.data.Errors'),
validations = this.validations,
validators = Ext.data.validations,
length, validation, field, valid, type, i;
if (validations) {
length = validations.length;
for (i = 0; i < length; i++) {
validation = validations[i];
field = validation.field || validation.name;
type = validation.type;
valid = validators[type](validation, this.get(field));
if (!valid) {
errors.add({
field : field,
message: validation.message || validators[type + 'Message']
});
}
}
}
return errors;
},
isValid: function(){
return this.validate().isValid();
},
save: function(options) {
options = Ext.apply({}, options);
var me = this,
action = me.phantom ? 'create' : 'update',
record = null,
scope = options.scope || me,
operation,
callback;
Ext.apply(options, {
records: [me],
action : action
});
operation = Ext.create('Ext.data.Operation', options);
callback = function(operation) {
if (operation.wasSuccessful()) {
record = operation.getRecords()[0];
me.set(record.data);
record.dirty = false;
Ext.callback(options.success, scope, [record, operation]);
} else {
Ext.callback(options.failure, scope, [record, operation]);
}
Ext.callback(options.callback, scope, [record, operation]);
};
me.getProxy()[action](operation, callback, me);
return me;
},
destroy: function(options){
options = Ext.apply({}, options);
var me = this,
record = null,
scope = options.scope || me,
operation,
callback;
Ext.apply(options, {
records: [me],
action : 'destroy'
});
operation = Ext.create('Ext.data.Operation', options);
callback = function(operation) {
if (operation.wasSuccessful()) {
Ext.callback(options.success, scope, [record, operation]);
} else {
Ext.callback(options.failure, scope, [record, operation]);
}
Ext.callback(options.callback, scope, [record, operation]);
};
me.getProxy().destroy(operation, callback, me);
return me;
},
getId: function() {
return this.get(this.idProperty);
},
setId: function(id) {
this.set(this.idProperty, id);
},
join : function(store) {
this.store = store;
},
unjoin: function() {
delete this.store;
},
afterEdit : function() {
this.callStore('afterEdit');
},
afterReject : function() {
this.callStore("afterReject");
},
afterCommit: function() {
this.callStore('afterCommit');
},
callStore: function(fn) {
var store = this.store;
if (store !== undefined && typeof store[fn] == "function") {
store[fn](this);
}
},
getAssociatedData: function(){
return this.prepareAssociatedData(this, [], null);
},
prepareAssociatedData: function(record, ids, associationType) {
var associations = record.associations.items,
associationCount = associations.length,
associationData = {},
associatedStore, associatedName, associatedRecords, associatedRecord,
associatedRecordCount, association, id, i, j, type, allow;
for (i = 0; i < associationCount; i++) {
association = associations[i];
type = association.type;
allow = true;
if (associationType) {
allow = type == associationType;
}
if (allow && type == 'hasMany') {
associatedStore = record[association.storeName];
associationData[association.name] = [];
if (associatedStore && associatedStore.data.length > 0) {
associatedRecords = associatedStore.data.items;
associatedRecordCount = associatedRecords.length;
for (j = 0; j < associatedRecordCount; j++) {
associatedRecord = associatedRecords[j];
id = associatedRecord.id;
if (Ext.Array.indexOf(ids, id) == -1) {
ids.push(id);
associationData[association.name][j] = associatedRecord.data;
Ext.apply(associationData[association.name][j], this.prepareAssociatedData(associatedRecord, ids, type));
}
}
}
} else if (allow && type == 'belongsTo') {
associatedRecord = record[association.instanceName];
if (associatedRecord !== undefined) {
id = associatedRecord.id;
if (Ext.Array.indexOf(ids, id) == -1) {
ids.push(id);
associationData[association.name] = associatedRecord.data;
Ext.apply(associationData[association.name], this.prepareAssociatedData(associatedRecord, ids, type));
}
}
}
}
return associationData;
}
});
Ext.define('Ext.Component', {
alias: ['widget.component', 'widget.box'],
extend: 'Ext.AbstractComponent',
requires: [
'Ext.util.DelayedTask'
],
uses: [
'Ext.Layer',
'Ext.resizer.Resizer',
'Ext.util.ComponentDragger'
],
mixins: {
floating: 'Ext.util.Floating'
},
statics: {
DIRECTION_TOP: 'top',
DIRECTION_RIGHT: 'right',
DIRECTION_BOTTOM: 'bottom',
DIRECTION_LEFT: 'left',
VERTICAL_DIRECTION: /^(?:top|bottom)$/
},
resizeHandles: 'all',
floating: false,
toFrontOnShow: true,
hideMode: 'display',
hideParent: false,
ariaRole: 'presentation',
bubbleEvents: [],
actionMode: 'el',
monPropRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate)$/,
constructor: function(config) {
config = config || {};
if (config.initialConfig) {
if (config.isAction) {
this.baseAction = config;
}
config = config.initialConfig;
}
else if (config.tagName || config.dom || Ext.isString(config)) {
config = {
applyTo: config,
id: config.id || config
};
}
this.callParent([config]);
if (this.baseAction){
this.baseAction.addComponent(this);
}
},
initComponent: function() {
var me = this;
if (me.listeners) {
me.on(me.listeners);
delete me.listeners;
}
me.enableBubble(me.bubbleEvents);
me.mons = [];
},
afterRender: function() {
var me = this,
resizable = me.resizable;
if (me.floating) {
me.makeFloating(me.floating);
} else {
me.el.setVisibilityMode(Ext.core.Element[me.hideMode.toUpperCase()]);
}
if (Ext.isDefined(me.autoScroll)) {
me.setAutoScroll(me.autoScroll);
}
me.callParent();
if (!(me.x && me.y) && (me.pageX || me.pageY)) {
me.setPagePosition(me.pageX, me.pageY);
}
if (resizable) {
me.initResizable(resizable);
}
if (me.draggable) {
me.initDraggable();
}
me.initAria();
},
initAria: function() {
var actionEl = this.getActionEl(),
role = this.ariaRole;
if (role) {
actionEl.dom.setAttribute('role', role);
}
},
setAutoScroll : function(scroll){
var me = this,
targetEl;
scroll = !!scroll;
if (me.rendered) {
targetEl = me.getTargetEl();
targetEl.setStyle('overflow', scroll ? 'auto' : '');
if (scroll && (Ext.isIE6 || Ext.isIE7)) {
targetEl.position();
}
}
me.autoScroll = scroll;
return me;
},
makeFloating : function(cfg){
this.mixins.floating.constructor.call(this, cfg);
},
initResizable: function(resizable) {
resizable = Ext.apply({
target: this,
dynamic: false,
constrainTo: this.constrainTo,
handles: this.resizeHandles
}, resizable);
resizable.target = this;
this.resizer = Ext.create('Ext.resizer.Resizer', resizable);
},
getDragEl: function() {
return this.el;
},
initDraggable: function() {
var me = this,
ddConfig = Ext.applyIf({
el: this.getDragEl(),
constrainTo: me.constrainTo || (me.floatParent ? me.floatParent.getTargetEl() : me.el.dom.parentNode)
}, this.draggable);
if (me.constrain || me.constrainDelegate) {
ddConfig.constrain = me.constrain;
ddConfig.constrainDelegate = me.constrainDelegate;
}
this.dd = Ext.create('Ext.util.ComponentDragger', this, ddConfig);
},
setPosition: function(x, y, animate) {
var me = this,
el = me.el,
to = {},
adj, adjX, adjY, xIsNumber, yIsNumber;
if (Ext.isArray(x)) {
animate = y;
y = x[1];
x = x[0];
}
me.x = x;
me.y = y;
if (!me.rendered) {
return me;
}
adj = me.adjustPosition(x, y);
adjX = adj.x;
adjY = adj.y;
xIsNumber = Ext.isNumber(adjX);
yIsNumber = Ext.isNumber(adjY);
if (xIsNumber || yIsNumber) {
if (animate) {
if (xIsNumber) {
to.left = adjX;
}
if (yIsNumber) {
to.top = adjY;
}
me.stopAnimation();
me.animate(Ext.apply({
duration: 1000,
listeners: {
afteranimate: Ext.Function.bind(me.afterSetPosition, me, [adjX, adjY])
},
to: to
}, animate));
}
else {
if (!xIsNumber) {
el.setTop(adjY);
}
else if (!yIsNumber) {
el.setLeft(adjX);
}
else {
el.setLeftTop(adjX, adjY);
}
me.afterSetPosition(adjX, adjY);
}
}
return me;
},
afterSetPosition: function(ax, ay) {
this.onPosition(ax, ay);
this.fireEvent('move', this, ax, ay);
},
showAt: function(x, y, animate) {
if (this.floating) {
this.setPosition(x, y, animate);
} else {
this.setPagePosition(x, y, animate);
}
this.show();
},
setPagePosition: function(x, y, animate) {
var me = this,
p;
if (Ext.isArray(x)) {
y = x[1];
x = x[0];
}
me.pageX = x;
me.pageY = y;
if (me.floating && me.floatParent) {
p = me.floatParent.getTargetEl().getViewRegion();
if (Ext.isNumber(x) && Ext.isNumber(p.left)) {
x -= p.left;
}
if (Ext.isNumber(y) && Ext.isNumber(p.top)) {
y -= p.top;
}
me.setPosition(x, y, animate);
}
else {
p = me.el.translatePoints(x, y);
me.setPosition(p.left, p.top, animate);
}
return me;
},
getBox : function(local){
var pos = this.getPosition(local);
var s = this.getSize();
s.x = pos[0];
s.y = pos[1];
return s;
},
updateBox : function(box){
this.setSize(box.width, box.height);
this.setPagePosition(box.x, box.y);
return this;
},
getOuterSize: function() {
var el = this.el;
return {
width: el.getWidth() + el.getMargin('lr'),
height: el.getHeight() + el.getMargin('tb')
};
},
adjustSize: function(w, h) {
if (this.autoWidth) {
w = 'auto';
}
if (this.autoHeight) {
h = 'auto';
}
return {
width: w,
height: h
};
},
adjustPosition: function(x, y) {
if (this.floating && this.floatParent) {
var o = this.floatParent.getTargetEl().getViewRegion();
x += o.left;
y += o.top;
}
return {
x: x,
y: y
};
},
getPosition: function(local) {
var el = this.el,
xy;
if (local === true) {
return [el.getLeft(true), el.getTop(true)];
}
xy = this.xy || el.getXY();
if (this.floating && this.floatParent) {
var o = this.floatParent.getTargetEl().getViewRegion();
xy[0] -= o.left;
xy[1] -= o.top;
}
return xy;
},
getId: function() {
return this.id || (this.id = (this.getXType() || 'ext-comp') + '-' + this.getAutoId());
},
onEnable: function() {
var actionEl = this.getActionEl();
actionEl.dom.removeAttribute('aria-disabled');
actionEl.dom.disabled = false;
this.callParent();
},
onDisable: function() {
var actionEl = this.getActionEl();
actionEl.dom.setAttribute('aria-disabled', true);
actionEl.dom.disabled = true;
this.callParent();
},
show: function(animateTarget, cb, scope) {
if (this.rendered && this.isVisible()) {
if (this.toFrontOnShow && this.floating) {
this.toFront();
}
} else if (this.fireEvent('beforeshow', this) !== false) {
this.hidden = false;
if (!this.rendered && (this.autoRender || this.floating)) {
this.doAutoRender();
}
if (this.rendered) {
this.beforeShow();
this.onShow.apply(this, arguments);
if (this.ownerCt && !this.floating && !(this.ownerCt.suspendLayout || this.ownerCt.layout.layoutBusy)) {
this.ownerCt.doLayout();
}
this.afterShow.apply(this, arguments);
}
}
return this;
},
beforeShow: Ext.emptyFn,
onShow: function() {
var me = this;
me.el.show();
if (this.floating && this.constrain) {
this.doConstrain();
}
me.callParent(arguments);
},
afterShow: function(animateTarget, cb, scope) {
var me = this,
fromBox,
toBox,
ghostPanel;
animateTarget = animateTarget || me.animateTarget;
if (!me.ghost) {
animateTarget = null;
}
if (animateTarget) {
animateTarget = animateTarget.el ? animateTarget.el : Ext.get(animateTarget);
toBox = me.el.getBox();
fromBox = animateTarget.getBox();
fromBox.width += 'px';
fromBox.height += 'px';
toBox.width += 'px';
toBox.height += 'px';
me.el.addCls(Ext.baseCSSPrefix + 'hide-offsets');
ghostPanel = me.ghost();
ghostPanel.el.stopAnimation();
ghostPanel.el.animate({
from: fromBox,
to: toBox,
listeners: {
afteranimate: function() {
delete ghostPanel.componentLayout.lastComponentSize;
me.unghost();
me.el.removeCls(Ext.baseCSSPrefix + 'hide-offsets');
if (me.floating) {
me.toFront();
}
Ext.callback(cb, scope || me);
}
}
});
}
else {
if (me.floating) {
me.toFront();
}
Ext.callback(cb, scope || me);
}
me.fireEvent('show', me);
},
hide: function() {
this.showOnParentShow = false;
if (!(this.rendered && !this.isVisible()) && this.fireEvent('beforehide', this) !== false) {
this.hidden = true;
if (this.rendered) {
this.onHide.apply(this, arguments);
if (this.ownerCt && !this.floating && !(this.ownerCt.suspendLayout || this.ownerCt.layout.layoutBusy)) {
this.ownerCt.doLayout();
}
}
}
return this;
},
onHide: function(animateTarget, cb, scope) {
var me = this,
ghostPanel,
toBox;
animateTarget = animateTarget || me.animateTarget;
if (!me.ghost) {
animateTarget = null;
}
if (animateTarget) {
animateTarget = animateTarget.el ? animateTarget.el : Ext.get(animateTarget);
ghostPanel = me.ghost();
ghostPanel.el.stopAnimation();
toBox = animateTarget.getBox();
toBox.width += 'px';
toBox.height += 'px';
ghostPanel.el.animate({
to: toBox,
listeners: {
afteranimate: function() {
delete ghostPanel.componentLayout.lastComponentSize;
ghostPanel.el.hide();
me.afterHide(cb, scope);
}
}
});
}
me.el.hide();
if (!animateTarget) {
me.afterHide(cb, scope);
}
},
afterHide: function(cb, scope) {
Ext.callback(cb, scope || this);
this.fireEvent('hide', this);
},
onDestroy: function() {
var me = this;
if (me.rendered) {
Ext.destroy(
me.proxy,
me.resizer
);
if (me.actionMode == 'container' || me.removeMode == 'container') {
me.container.remove();
}
}
delete me.focusTask;
me.callParent();
},
deleteMembers: function() {
var args = arguments,
len = args.length,
i = 0;
for (; i < len; ++i) {
delete this[args[i]];
}
},
focus: function(selectText, delay) {
var me = this,
focusEl;
if (delay) {
if (!me.focusTask) {
me.focusTask = Ext.create('Ext.util.DelayedTask', me.focus);
}
me.focusTask.delay(Ext.isNumber(delay) ? delay : 10, null, me, [selectText, false]);
return me;
}
if (me.rendered && !me.isDestroyed) {
focusEl = me.getFocusEl();
focusEl.focus();
if (focusEl.dom && selectText === true) {
focusEl.dom.select();
}
if (me.floating) {
me.toFront(true);
}
}
return me;
},
getFocusEl: function() {
return this.el;
},
blur: function() {
if (this.rendered) {
this.getFocusEl().blur();
}
return this;
},
getEl: function() {
return this.el;
},
getResizeEl: function() {
return this.el;
},
getPositionEl: function() {
return this.el;
},
getActionEl: function() {
return this.el;
},
getVisibilityEl: function() {
return this.el;
},
onResize: Ext.emptyFn,
getBubbleTarget: function() {
return this.ownerCt;
},
getContentTarget: function() {
return this.el;
},
cloneConfig: function(overrides) {
overrides = overrides || {};
var id = overrides.id || Ext.id();
var cfg = Ext.applyIf(overrides, this.initialConfig);
cfg.id = id;
var self = Ext.getClass(this);
return new self(cfg);
},
getXType: function() {
return this.self.xtype;
},
findParentBy: function(fn) {
var p;
for (p = this.ownerCt; p && !fn(p, this); p = p.ownerCt);
return p || null;
},
findParentByType: function(xtype) {
return Ext.isFunction(xtype) ?
this.findParentBy(function(p) {
return p.constructor === xtype;
})
:
this.up(xtype);
},
bubble: function(fn, scope, args) {
var p = this;
while (p) {
if (fn.apply(scope || p, args || [p]) === false) {
break;
}
p = p.ownerCt;
}
return this;
},
getProxy: function() {
if (!this.proxy) {
this.proxy = this.el.createProxy(Ext.baseCSSPrefix + 'proxy-el', Ext.getBody(), true);
}
return this.proxy;
}
});
Ext.define('Ext.layout.container.Container', {
extend: 'Ext.layout.container.AbstractContainer',
alternateClassName: 'Ext.layout.ContainerLayout',
layoutItem: function(item, box) {
if (box) {
item.doComponentLayout(box.width, box.height);
} else {
item.doComponentLayout();
}
},
getLayoutTargetSize : function() {
var target = this.getTarget(),
ret;
if (target) {
ret = target.getViewSize();
if (Ext.isIE && ret.width == 0){
ret = target.getStyleSize();
}
ret.width -= target.getPadding('lr');
ret.height -= target.getPadding('tb');
}
return ret;
},
beforeLayout: function() {
if (this.owner.beforeLayout(arguments) !== false) {
return this.callParent(arguments);
}
else {
return false;
}
},
getRenderedItems: function() {
var me = this,
target = me.getTarget(),
items = me.getLayoutItems(),
ln = items.length,
renderedItems = [],
i, item;
for (i = 0; i < ln; i++) {
item = items[i];
if (item.rendered && me.isValidParent(item, target, i)) {
renderedItems.push(item);
}
}
return renderedItems;
},
getVisibleItems: function() {
var target = this.getTarget(),
items = this.getLayoutItems(),
ln = items.length,
visibleItems = [],
i, item;
for (i = 0; i < ln; i++) {
item = items[i];
if (item.rendered && this.isValidParent(item, target, i) && item.hidden !== true) {
visibleItems.push(item);
}
}
return visibleItems;
}
});
Ext.define('Ext.layout.container.Auto', {
alias: ['layout.auto', 'layout.autocontainer'],
extend: 'Ext.layout.container.Container',
type: 'autocontainer',
bindToOwnerCtComponent: true,
onLayout : function(owner, target) {
var me = this,
items = me.getLayoutItems(),
ln = items.length,
i;
if (ln) {
if (!me.clearEl) {
me.clearEl = me.getRenderTarget().createChild({
cls: Ext.baseCSSPrefix + 'clear',
role: 'presentation'
});
}
for (i = 0; i < ln; i++) {
me.setItemSize(items[i]);
}
}
},
configureItem: function(item) {
this.callParent(arguments);
item.layoutManagedHeight = 2;
item.layoutManagedWidth = 2;
}
});
Ext.define('Ext.container.AbstractContainer', {
extend: 'Ext.Component',
requires: [
'Ext.util.MixedCollection',
'Ext.layout.container.Auto',
'Ext.ZIndexManager'
],
suspendLayout : false,
autoDestroy : true,
defaultType: 'panel',
isContainer : true,
layoutCounter : 0,
baseCls: Ext.baseCSSPrefix + 'container',
bubbleEvents: ['add', 'remove'],
initComponent : function(){
var me = this;
me.addEvents(
'afterlayout',
'beforeadd',
'beforeremove',
'add',
'remove',
'beforecardswitch',
'cardswitch'
);
me.layoutOnShow = Ext.create('Ext.util.MixedCollection');
me.callParent();
me.initItems();
},
initItems : function() {
var me = this,
items = me.items;
me.items = Ext.create('Ext.util.MixedCollection', false, me.getComponentId);
if (items) {
if (!Ext.isArray(items)) {
items = [items];
}
me.add(items);
}
},
afterRender : function() {
this.getLayout();
this.callParent();
},
renderChildren: function () {
var me = this,
layout = me.getLayout();
me.callParent();
if (layout) {
me.suspendLayout = true;
layout.renderChildren();
delete me.suspendLayout;
}
},
setLayout : function(layout) {
var currentLayout = this.layout;
if (currentLayout && currentLayout.isLayout && currentLayout != layout) {
currentLayout.setOwner(null);
}
this.layout = layout;
layout.setOwner(this);
},
getLayout : function() {
var me = this;
if (!me.layout || !me.layout.isLayout) {
me.setLayout(Ext.layout.Layout.create(me.layout, 'autocontainer'));
}
return me.layout;
},
doLayout : function() {
var me = this,
layout = me.getLayout();
if (me.rendered && layout && !me.suspendLayout) {
if (!me.isFixedWidth() || !me.isFixedHeight()) {
if (me.componentLayout.layoutBusy !== true) {
me.doComponentLayout();
if (me.componentLayout.layoutCancelled === true) {
layout.layout();
}
}
}
else {
if (layout.layoutBusy !== true) {
layout.layout();
}
}
}
return me;
},
afterLayout : function(layout) {
++this.layoutCounter;
this.fireEvent('afterlayout', this, layout);
},
prepareItems : function(items, applyDefaults) {
if (!Ext.isArray(items)) {
items = [items];
}
var i = 0,
len = items.length,
item;
for (; i < len; i++) {
item = items[i];
if (applyDefaults) {
item = this.applyDefaults(item);
}
items[i] = this.lookupComponent(item);
}
return items;
},
applyDefaults : function(config) {
var defaults = this.defaults;
if (defaults) {
if (Ext.isFunction(defaults)) {
defaults = defaults.call(this, config);
}
if (Ext.isString(config)) {
config = Ext.ComponentManager.get(config);
Ext.applyIf(config, defaults);
} else if (!config.isComponent) {
Ext.applyIf(config, defaults);
} else {
Ext.applyIf(config, defaults);
}
}
return config;
},
lookupComponent : function(comp) {
return Ext.isString(comp) ? Ext.ComponentManager.get(comp) : this.createComponent(comp);
},
createComponent : function(config, defaultType) {
return Ext.ComponentManager.create(config, defaultType || this.defaultType);
},
getComponentId : function(comp) {
return comp.getItemId();
},
add : function() {
var me = this,
args = Array.prototype.slice.call(arguments),
hasMultipleArgs,
items,
results = [],
i,
ln,
item,
index = -1,
cmp;
if (typeof args[0] == 'number') {
index = args.shift();
}
hasMultipleArgs = args.length > 1;
if (hasMultipleArgs || Ext.isArray(args[0])) {
items = hasMultipleArgs ? args : args[0];
me.suspendLayout = true;
for (i = 0, ln = items.length; i < ln; i++) {
item = items[i];
if (index != -1) {
item = me.add(index + i, item);
} else {
item = me.add(item);
}
results.push(item);
}
me.suspendLayout = false;
me.doLayout();
return results;
}
cmp = me.prepareItems(args[0], true)[0];
if (cmp.floating) {
cmp.onAdded(me, index);
} else {
index = (index !== -1) ? index : me.items.length;
if (me.fireEvent('beforeadd', me, cmp, index) !== false && me.onBeforeAdd(cmp) !== false) {
me.items.insert(index, cmp);
cmp.onAdded(me, index);
me.onAdd(cmp, index);
me.fireEvent('add', me, cmp, index);
}
me.doLayout();
}
return cmp;
},
registerFloatingItem: function(cmp) {
var me = this;
if (!me.floatingItems) {
me.floatingItems = Ext.create('Ext.ZIndexManager', me);
}
me.floatingItems.register(cmp);
},
onAdd : Ext.emptyFn,
onRemove : Ext.emptyFn,
insert : function(index, comp) {
return this.add(index, comp);
},
move : function(fromIdx, toIdx) {
var items = this.items,
item;
item = items.removeAt(fromIdx);
if (item === false) {
return false;
}
items.insert(toIdx, item);
this.doLayout();
return item;
},
onBeforeAdd : function(item) {
var me = this;
if (item.ownerCt) {
item.ownerCt.remove(item, false);
}
if (me.border === false || me.border === 0) {
item.border = (item.border === true);
}
},
remove : function(comp, autoDestroy) {
var me = this,
c = me.getComponent(comp);
if (c && me.fireEvent('beforeremove', me, c) !== false) {
me.doRemove(c, autoDestroy);
me.fireEvent('remove', me, c);
}
return c;
},
doRemove : function(component, autoDestroy) {
var me = this,
layout = me.layout,
hasLayout = layout && me.rendered;
me.items.remove(component);
component.onRemoved();
if (hasLayout) {
layout.onRemove(component);
}
me.onRemove(component, autoDestroy);
if (autoDestroy === true || (autoDestroy !== false && me.autoDestroy)) {
component.destroy();
}
if (hasLayout && !autoDestroy) {
layout.afterRemove(component);
}
if (!me.destroying) {
me.doLayout();
}
},
removeAll : function(autoDestroy) {
var me = this,
removeItems = me.items.items.slice(),
items = [],
i = 0,
len = removeItems.length,
item;
me.suspendLayout = true;
for (; i < len; i++) {
item = removeItems[i];
me.remove(item, autoDestroy);
if (item.ownerCt !== me) {
items.push(item);
}
}
me.suspendLayout = false;
if (len) {
me.doLayout();
}
return items;
},
getRefItems : function(deep) {
var me = this,
items = me.items.items,
len = items.length,
i = 0,
item,
result = [];
for (; i < len; i++) {
item = items[i];
result.push(item);
if (deep && item.getRefItems) {
result.push.apply(result, item.getRefItems(true));
}
}
if (me.floatingItems && me.floatingItems.accessList) {
result.push.apply(result, me.floatingItems.accessList);
}
return result;
},
cascade : function(fn, scope, origArgs){
var me = this,
cs = me.items ? me.items.items : [],
len = cs.length,
i = 0,
c,
args = origArgs ? origArgs.concat(me) : [me],
componentIndex = args.length - 1;
if (fn.apply(scope || me, args) !== false) {
for(; i < len; i++){
c = cs[i];
if (c.cascade) {
c.cascade(fn, scope, origArgs);
} else {
args[componentIndex] = c;
fn.apply(scope || cs, args);
}
}
}
return this;
},
getComponent : function(comp) {
if (Ext.isObject(comp)) {
comp = comp.getItemId();
}
return this.items.get(comp);
},
query : function(selector) {
return Ext.ComponentQuery.query(selector, this);
},
child : function(selector) {
return this.query('> ' + selector)[0] || null;
},
down : function(selector) {
return this.query(selector)[0] || null;
},
show : function() {
this.callParent(arguments);
this.performDeferredLayouts();
return this;
},
performDeferredLayouts: function() {
var layoutCollection = this.layoutOnShow,
ln = layoutCollection.getCount(),
i = 0,
needsLayout,
item;
for (; i < ln; i++) {
item = layoutCollection.get(i);
needsLayout = item.needsLayout;
if (Ext.isObject(needsLayout)) {
item.doComponentLayout(needsLayout.width, needsLayout.height, needsLayout.isSetSize, needsLayout.ownerCt);
}
}
layoutCollection.clear();
},
//@private
onEnable: function() {
Ext.Array.each(this.query('[isFormField]'), function(item) {
if (item.resetDisable) {
item.enable();
delete item.resetDisable;
}
});
this.callParent();
},
onDisable: function() {
Ext.Array.each(this.query('[isFormField]'), function(item) {
if (item.resetDisable !== false && !item.disabled) {
item.disable();
item.resetDisable = true;
}
});
this.callParent();
},
beforeLayout: function() {
return true;
},
beforeDestroy : function() {
var me = this,
items = me.items,
c;
if (items) {
while ((c = items.first())) {
me.doRemove(c, true);
}
}
Ext.destroy(
me.layout,
me.floatingItems
);
me.callParent();
}
});
Ext.define('Ext.container.Container', {
extend: 'Ext.container.AbstractContainer',
alias: 'widget.container',
alternateClassName: 'Ext.Container',
getChildByElement: function(el) {
var item,
itemEl,
i = 0,
it = this.items.items,
ln = it.length;
el = Ext.getDom(el);
for (; i < ln; i++) {
item = it[i];
itemEl = item.getEl();
if ((itemEl.dom === el) || itemEl.contains(el)) {
return item;
}
}
return null;
}
});
Ext.define('Ext.toolbar.Fill', {
extend: 'Ext.Component',
alias: 'widget.tbfill',
alternateClassName: 'Ext.Toolbar.Fill',
isFill : true,
flex: 1
});
Ext.define('Ext.toolbar.Item', {
extend: 'Ext.Component',
alias: 'widget.tbitem',
alternateClassName: 'Ext.Toolbar.Item',
enable:Ext.emptyFn,
disable:Ext.emptyFn,
focus:Ext.emptyFn
});
Ext.define('Ext.toolbar.Separator', {
extend: 'Ext.toolbar.Item',
alias: 'widget.tbseparator',
alternateClassName: 'Ext.Toolbar.Separator',
baseCls: Ext.baseCSSPrefix + 'toolbar-separator',
focusable: false
});
Ext.define('Ext.menu.Manager', {
singleton: true,
requires: [
'Ext.util.MixedCollection',
'Ext.util.KeyMap'
],
alternateClassName: 'Ext.menu.MenuMgr',
uses: ['Ext.menu.Menu'],
menus: {},
groups: {},
attached: false,
lastShow: new Date(),
init: function() {
var me = this;
me.active = Ext.create('Ext.util.MixedCollection');
Ext.getDoc().addKeyListener(27, function() {
if (me.active.length > 0) {
me.hideAll();
}
}, me);
},
hideAll: function() {
var active = this.active,
c;
if (active && active.length > 0) {
c = active.clone();
c.each(function(m) {
m.hide();
});
return true;
}
return false;
},
onHide: function(m) {
var me = this,
active = me.active;
active.remove(m);
if (active.length < 1) {
Ext.getDoc().un('mousedown', me.onMouseDown, me);
me.attached = false;
}
},
onShow: function(m) {
var me = this,
active = me.active,
last = active.last(),
attached = me.attached,
menuEl = m.getEl(),
zIndex;
me.lastShow = new Date();
active.add(m);
if (!attached) {
Ext.getDoc().on('mousedown', me.onMouseDown, me);
me.attached = true;
}
m.toFront();
},
onBeforeHide: function(m) {
if (m.activeChild) {
m.activeChild.hide();
}
if (m.autoHideTimer) {
clearTimeout(m.autoHideTimer);
delete m.autoHideTimer;
}
},
onBeforeShow: function(m) {
var active = this.active,
parentMenu = m.parentMenu;
active.remove(m);
if (!parentMenu && !m.allowOtherMenus) {
this.hideAll();
}
else if (parentMenu && parentMenu.activeChild && m != parentMenu.activeChild) {
parentMenu.activeChild.hide();
}
},
onMouseDown: function(e) {
var me = this,
active = me.active,
lastShow = me.lastShow;
if (Ext.Date.getElapsed(lastShow) > 50 && active.length > 0 && !e.getTarget('.' + Ext.baseCSSPrefix + 'menu')) {
me.hideAll();
}
},
register: function(menu) {
var me = this;
if (!me.active) {
me.init();
}
if (menu.floating) {
me.menus[menu.id] = menu;
menu.on({
beforehide: me.onBeforeHide,
hide: me.onHide,
beforeshow: me.onBeforeShow,
show: me.onShow,
scope: me
});
}
},
get: function(menu) {
var menus = this.menus;
if (typeof menu == 'string') {
if (!menus) {
return null;
}
return menus[menu];
} else if (menu.isMenu) {
return menu;
} else if (Ext.isArray(menu)) {
return Ext.create('Ext.menu.Menu', {items:menu});
} else {
return Ext.ComponentManager.create(menu, 'menu');
}
},
unregister: function(menu) {
var me = this,
menus = me.menus,
active = me.active;
delete menus[menu.id];
active.remove(menu);
menu.un({
beforehide: me.onBeforeHide,
hide: me.onHide,
beforeshow: me.onBeforeShow,
show: me.onShow,
scope: me
});
},
registerCheckable: function(menuItem) {
var groups = this.groups,
groupId = menuItem.group;
if (groupId) {
if (!groups[groupId]) {
groups[groupId] = [];
}
groups[groupId].push(menuItem);
}
},
unregisterCheckable: function(menuItem) {
var groups = this.groups,
groupId = menuItem.group;
if (groupId) {
Ext.Array.remove(groups[groupId], menuItem);
}
},
onCheckChange: function(menuItem, state) {
var groups = this.groups,
groupId = menuItem.group,
i = 0,
group, ln, curr;
if (groupId && state) {
group = groups[groupId];
ln = group.length;
for (; i < ln; i++) {
curr = group[i];
if (curr != menuItem) {
curr.setChecked(false);
}
}
}
}
});
Ext.define('Ext.button.Button', {
alias: 'widget.button',
extend: 'Ext.Component',
requires: [
'Ext.menu.Manager',
'Ext.util.ClickRepeater',
'Ext.layout.component.Button',
'Ext.util.TextMetrics',
'Ext.util.KeyMap'
],
alternateClassName: 'Ext.Button',
isButton: true,
componentLayout: 'button',
hidden: false,
disabled: false,
pressed: false,
enableToggle: false,
menuAlign: 'tl-bl?',
type: 'button',
clickEvent: 'click',
preventDefault: true,
handleMouseEvents: true,
tooltipType: 'qtip',
baseCls: Ext.baseCSSPrefix + 'btn',
pressedCls: 'pressed',
overCls: 'over',
focusCls: 'focus',
menuActiveCls: 'menu-active',
ariaRole: 'button',
renderTpl:
'' +
'' +
' tabIndex="{tabIndex}" role="link">' +
'' +
'{text}' +
' ' +
'' +
' tabIndex="{tabIndex}" role="button" autocomplete="off">' +
'' +
'{text}' +
' ' +
' ' ,
scale: 'small',
allowedScales: ['small', 'medium', 'large'],
iconAlign: 'left',
arrowAlign: 'right',
arrowCls: 'arrow',
maskOnDisable: false,
initComponent: function() {
var me = this;
me.callParent(arguments);
me.addEvents(
'click',
'toggle',
'mouseover',
'mouseout',
'menushow',
'menuhide',
'menutriggerover',
'menutriggerout'
);
if (me.menu) {
me.split = true;
me.menu = Ext.menu.Manager.get(me.menu);
me.menu.ownerCt = me;
}
if (me.url) {
me.href = me.url;
}
if (me.href && !me.hasOwnProperty('preventDefault')) {
me.preventDefault = false;
}
if (Ext.isString(me.toggleGroup)) {
me.enableToggle = true;
}
},
initAria: function() {
this.callParent();
var actionEl = this.getActionEl();
if (this.menu) {
actionEl.dom.setAttribute('aria-haspopup', true);
}
},
getActionEl: function() {
return this.btnEl;
},
getFocusEl: function() {
return this.btnEl;
},
setButtonCls: function() {
var me = this,
el = me.el,
cls = [];
if (me.useSetClass) {
if (!Ext.isEmpty(me.oldCls)) {
me.removeClsWithUI(me.oldCls);
me.removeClsWithUI(me.pressedCls);
}
if (me.iconCls || me.icon) {
if (me.text) {
cls.push('icon-text-' + me.iconAlign);
} else {
cls.push('icon');
}
} else if (me.text) {
cls.push('noicon');
}
me.oldCls = cls;
me.addClsWithUI(cls);
me.addClsWithUI(me.pressed ? me.pressedCls : null);
}
},
onRender: function(ct, position) {
var me = this,
repeater, btn;
Ext.applyIf(me.renderData, me.getTemplateArgs());
Ext.applyIf(me.renderSelectors, {
btnEl : me.href ? 'a' : 'button',
btnWrap: 'em',
btnInnerEl: '.' + me.baseCls + '-inner',
btnIconEl: '.'+ me.baseCls + '-icon'
});
if (me.scale) {
me.ui = me.ui + '-' + me.scale;
}
me.callParent(arguments);
if (me.split && me.arrowTooltip) {
me.arrowEl.dom[me.tooltipType] = me.arrowTooltip;
}
me.mon(me.btnEl, {
scope: me,
focus: me.onFocus,
blur : me.onBlur
});
btn = me.el;
if (me.icon) {
me.setIcon(me.icon);
}
if (me.iconCls) {
me.setIconCls(me.iconCls);
}
if (me.tooltip) {
me.setTooltip(me.tooltip, true);
}
if (me.handleMouseEvents) {
me.mon(btn, {
scope: me,
mouseover: me.onMouseOver,
mouseout: me.onMouseOut,
mousedown: me.onMouseDown
});
if (me.split) {
me.mon(btn, {
mousemove: me.onMouseMove,
scope: me
});
}
}
if (me.menu) {
me.mon(me.menu, {
scope: me,
show: me.onMenuShow,
hide: me.onMenuHide
});
me.keyMap = Ext.create('Ext.util.KeyMap', me.el, {
key: Ext.EventObject.DOWN,
handler: me.onDownKey,
scope: me
});
}
if (me.repeat) {
repeater = Ext.create('Ext.util.ClickRepeater', btn, Ext.isObject(me.repeat) ? me.repeat: {});
me.mon(repeater, 'click', me.onRepeatClick, me);
} else {
me.mon(btn, me.clickEvent, me.onClick, me);
}
Ext.ButtonToggleManager.register(me);
},
getTemplateArgs: function() {
var me = this,
persistentPadding = me.getPersistentBtnPadding(),
innerSpanStyle = '';
if (Math.max.apply(Math, persistentPadding) > 0) {
innerSpanStyle = 'margin:' + Ext.Array.map(persistentPadding, function(pad) {
return -pad + 'px';
}).join(' ');
}
return {
href : me.getHref(),
target : me.target || '_blank',
type : me.type,
splitCls : me.getSplitCls(),
cls : me.cls,
text : me.text || ' ',
tabIndex : me.tabIndex,
innerSpanStyle: innerSpanStyle
};
},
getHref: function() {
var me = this,
params = Ext.apply({}, me.baseParams);
params = Ext.apply(params, me.params);
return me.href ? Ext.urlAppend(me.href, Ext.Object.toQueryString(params)) : false;
},
setParams: function(params) {
this.params = params;
this.btnEl.dom.href = this.getHref();
},
getSplitCls: function() {
var me = this;
return me.split ? (me.baseCls + '-' + me.arrowCls) + ' ' + (me.baseCls + '-' + me.arrowCls + '-' + me.arrowAlign) : '';
},
afterRender: function() {
var me = this;
me.useSetClass = true;
me.setButtonCls();
me.doc = Ext.getDoc();
this.callParent(arguments);
},
setIconCls: function(cls) {
var me = this,
btnIconEl = me.btnIconEl;
if (btnIconEl) {
btnIconEl.removeCls(me.iconCls);
btnIconEl.addCls(cls || '');
me.setButtonCls();
}
me.iconCls = cls;
return me;
},
setTooltip: function(tooltip, initial) {
var me = this;
if (me.rendered) {
if (!initial) {
me.clearTip();
}
if (Ext.isObject(tooltip)) {
Ext.tip.QuickTipManager.register(Ext.apply({
target: me.btnEl.id
},
tooltip));
me.tooltip = tooltip;
} else {
me.btnEl.dom.setAttribute('data-' + this.tooltipType, tooltip);
}
} else {
me.tooltip = tooltip;
}
return me;
},
getRefItems: function(deep){
var menu = this.menu,
items;
if (menu) {
items = menu.getRefItems(deep);
items.unshift(menu);
}
return items || [];
},
clearTip: function() {
if (Ext.isObject(this.tooltip)) {
Ext.tip.QuickTipManager.unregister(this.btnEl);
}
},
beforeDestroy: function() {
var me = this;
if (me.rendered) {
me.clearTip();
}
if (me.menu && me.destroyMenu !== false) {
Ext.destroy(me.btnEl, me.btnInnerEl, me.menu);
}
Ext.destroy(me.repeater);
},
onDestroy: function() {
var me = this;
if (me.rendered) {
me.doc.un('mouseover', me.monitorMouseOver, me);
me.doc.un('mouseup', me.onMouseUp, me);
delete me.doc;
delete me.btnEl;
delete me.btnInnerEl;
Ext.ButtonToggleManager.unregister(me);
Ext.destroy(me.keyMap);
delete me.keyMap;
}
me.callParent();
},
setHandler: function(handler, scope) {
this.handler = handler;
this.scope = scope;
return this;
},
setText: function(text) {
var me = this;
me.text = text;
if (me.el) {
me.btnInnerEl.update(text || ' ');
me.setButtonCls();
}
me.doComponentLayout();
return me;
},
setIcon: function(icon) {
var me = this,
btnInnerEl = me.btnInnerEl;
me.icon = icon;
if (btnInnerEl) {
btnInnerEl.setStyle('background-image', icon ? 'url(' + icon + ')': '');
me.setButtonCls();
}
return me;
},
getText: function() {
return this.text;
},
toggle: function(state, suppressEvent) {
var me = this;
state = state === undefined ? !me.pressed: !!state;
if (state !== me.pressed) {
if (me.rendered) {
me[state ? 'addClsWithUI': 'removeClsWithUI'](me.pressedCls);
}
me.btnEl.dom.setAttribute('aria-pressed', state);
me.pressed = state;
if (!suppressEvent) {
me.fireEvent('toggle', me, state);
Ext.callback(me.toggleHandler, me.scope || me, [me, state]);
}
}
return me;
},
showMenu: function() {
var me = this;
if (me.rendered && me.menu) {
if (me.tooltip) {
Ext.tip.QuickTipManager.getQuickTip().cancelShow(me.btnEl);
}
if (me.menu.isVisible()) {
me.menu.hide();
}
me.menu.showBy(me.el, me.menuAlign);
}
return me;
},
hideMenu: function() {
if (this.hasVisibleMenu()) {
this.menu.hide();
}
return this;
},
hasVisibleMenu: function() {
var menu = this.menu;
return menu && menu.rendered && menu.isVisible();
},
onRepeatClick: function(repeat, e) {
this.onClick(e);
},
onClick: function(e) {
var me = this;
if (me.preventDefault || (me.disabled && me.getHref()) && e) {
e.preventDefault();
}
if (e.button !== 0) {
return;
}
if (!me.disabled) {
if (me.enableToggle && (me.allowDepress !== false || !me.pressed)) {
me.toggle();
}
if (me.menu && !me.hasVisibleMenu() && !me.ignoreNextClick) {
me.showMenu();
}
me.fireEvent('click', me, e);
if (me.handler) {
me.handler.call(me.scope || me, me, e);
}
me.onBlur();
}
},
onMouseOver: function(e) {
var me = this;
if (!me.disabled && !e.within(me.el, true, true)) {
me.onMouseEnter(e);
}
},
onMouseOut: function(e) {
var me = this;
if (!e.within(me.el, true, true)) {
if (me.overMenuTrigger) {
me.onMenuTriggerOut(e);
}
me.onMouseLeave(e);
}
},
onMouseMove: function(e) {
var me = this,
el = me.el,
over = me.overMenuTrigger,
overlap, btnSize;
if (me.split) {
if (me.arrowAlign === 'right') {
overlap = e.getX() - el.getX();
btnSize = el.getWidth();
} else {
overlap = e.getY() - el.getY();
btnSize = el.getHeight();
}
if (overlap > (btnSize - me.getTriggerSize())) {
if (!over) {
me.onMenuTriggerOver(e);
}
} else {
if (over) {
me.onMenuTriggerOut(e);
}
}
}
},
getTriggerSize: function() {
var me = this,
size = me.triggerSize,
side, sideFirstLetter, undef;
if (size === undef) {
side = me.arrowAlign;
sideFirstLetter = side.charAt(0);
size = me.triggerSize = me.el.getFrameWidth(sideFirstLetter) + me.btnWrap.getFrameWidth(sideFirstLetter) + (me.frameSize && me.frameSize[side] || 0);
}
return size;
},
onMouseEnter: function(e) {
var me = this;
me.addClsWithUI(me.overCls);
me.fireEvent('mouseover', me, e);
},
onMouseLeave: function(e) {
var me = this;
me.removeClsWithUI(me.overCls);
me.fireEvent('mouseout', me, e);
},
onMenuTriggerOver: function(e) {
var me = this;
me.overMenuTrigger = true;
me.fireEvent('menutriggerover', me, me.menu, e);
},
onMenuTriggerOut: function(e) {
var me = this;
delete me.overMenuTrigger;
me.fireEvent('menutriggerout', me, me.menu, e);
},
enable : function(silent) {
var me = this;
me.callParent(arguments);
me.removeClsWithUI('disabled');
return me;
},
disable : function(silent) {
var me = this;
me.callParent(arguments);
me.addClsWithUI('disabled');
return me;
},
setScale: function(scale) {
var me = this,
ui = me.ui.replace('-' + me.scale, '');
if (!Ext.Array.contains(me.allowedScales, scale)) {
throw('#setScale: scale must be an allowed scale (' + me.allowedScales.join(', ') + ')');
}
me.scale = scale;
me.setUI(ui);
},
setUI: function(ui) {
var me = this;
if (me.scale && !ui.match(me.scale)) {
ui = ui + '-' + me.scale;
}
me.callParent([ui]);
},
onFocus: function(e) {
var me = this;
if (!me.disabled) {
me.addClsWithUI(me.focusCls);
}
},
onBlur: function(e) {
var me = this;
me.removeClsWithUI(me.focusCls);
},
onMouseDown: function(e) {
var me = this;
if (!me.disabled && e.button === 0) {
me.addClsWithUI(me.pressedCls);
me.doc.on('mouseup', me.onMouseUp, me);
}
},
onMouseUp: function(e) {
var me = this;
if (e.button === 0) {
if (!me.pressed) {
me.removeClsWithUI(me.pressedCls);
}
me.doc.un('mouseup', me.onMouseUp, me);
}
},
onMenuShow: function(e) {
var me = this;
me.ignoreNextClick = 0;
me.addClsWithUI(me.menuActiveCls);
me.fireEvent('menushow', me, me.menu);
},
onMenuHide: function(e) {
var me = this;
me.removeClsWithUI(me.menuActiveCls);
me.ignoreNextClick = Ext.defer(me.restoreClick, 250, me);
me.fireEvent('menuhide', me, me.menu);
},
restoreClick: function() {
this.ignoreNextClick = 0;
},
onDownKey: function() {
var me = this;
if (!me.disabled) {
if (me.menu) {
me.showMenu();
}
}
},
getPersistentBtnPadding: function() {
var cls = Ext.button.Button,
padding = cls.persistentPadding,
btn, leftTop, btnEl, btnInnerEl;
if (!padding) {
padding = cls.persistentPadding = [0, 0, 0, 0];
if (!Ext.isIE) {
btn = Ext.create('Ext.button.Button', {
renderTo: Ext.getBody(),
text: 'test',
style: 'position:absolute;top:-999px;'
});
btnEl = btn.btnEl;
btnInnerEl = btn.btnInnerEl;
btnEl.setSize(null, null);
leftTop = btnInnerEl.getOffsetsTo(btnEl);
padding[0] = leftTop[1];
padding[1] = btnEl.getWidth() - btnInnerEl.getWidth() - leftTop[0];
padding[2] = btnEl.getHeight() - btnInnerEl.getHeight() - leftTop[1];
padding[3] = leftTop[0];
btn.destroy();
}
}
return padding;
}
}, function() {
var groups = {},
g, i, l;
function toggleGroup(btn, state) {
if (state) {
g = groups[btn.toggleGroup];
for (i = 0, l = g.length; i < l; i++) {
if (g[i] !== btn) {
g[i].toggle(false);
}
}
}
}
Ext.ButtonToggleManager = {
register: function(btn) {
if (!btn.toggleGroup) {
return;
}
var group = groups[btn.toggleGroup];
if (!group) {
group = groups[btn.toggleGroup] = [];
}
group.push(btn);
btn.on('toggle', toggleGroup);
},
unregister: function(btn) {
if (!btn.toggleGroup) {
return;
}
var group = groups[btn.toggleGroup];
if (group) {
Ext.Array.remove(group, btn);
btn.un('toggle', toggleGroup);
}
},
getPressed: function(group) {
var g = groups[group],
i = 0,
len;
if (g) {
for (len = g.length; i < len; i++) {
if (g[i].pressed === true) {
return g[i];
}
}
}
return null;
}
};
});
Ext.define('Ext.layout.container.boxOverflow.Menu', {
extend: 'Ext.layout.container.boxOverflow.None',
requires: ['Ext.toolbar.Separator', 'Ext.button.Button'],
alternateClassName: 'Ext.layout.boxOverflow.Menu',
noItemsMenuText : '(None)
',
constructor: function(layout) {
var me = this;
me.callParent(arguments);
layout.beforeLayout = Ext.Function.createInterceptor(layout.beforeLayout, this.clearOverflow, this);
me.afterCtCls = me.afterCtCls || Ext.baseCSSPrefix + 'box-menu-' + layout.parallelAfter;
me.menuItems = [];
},
onRemove: function(comp){
Ext.Array.remove(this.menuItems, comp);
},
handleOverflow: function(calculations, targetSize) {
var me = this,
layout = me.layout,
methodName = 'get' + layout.parallelPrefixCap,
newSize = {},
posArgs = [null, null];
me.callParent(arguments);
this.createMenu(calculations, targetSize);
newSize[layout.perpendicularPrefix] = targetSize[layout.perpendicularPrefix];
newSize[layout.parallelPrefix] = targetSize[layout.parallelPrefix] - me.afterCt[methodName]();
posArgs[layout.perpendicularSizeIndex] = (calculations.meta.maxSize - me.menuTrigger['get' + layout.perpendicularPrefixCap]()) / 2;
me.menuTrigger.setPosition.apply(me.menuTrigger, posArgs);
return { targetSize: newSize };
},
clearOverflow: function(calculations, targetSize) {
var me = this,
newWidth = targetSize ? targetSize.width + (me.afterCt ? me.afterCt.getWidth() : 0) : 0,
items = me.menuItems,
i = 0,
length = items.length,
item;
me.hideTrigger();
for (; i < length; i++) {
items[i].show();
}
items.length = 0;
return targetSize ? {
targetSize: {
height: targetSize.height,
width : newWidth
}
} : null;
},
showTrigger: function() {
this.menuTrigger.show();
},
hideTrigger: function() {
if (this.menuTrigger !== undefined) {
this.menuTrigger.hide();
}
},
beforeMenuShow: function(menu) {
var me = this,
items = me.menuItems,
i = 0,
len = items.length,
item,
prev;
var needsSep = function(group, prev){
return group.isXType('buttongroup') && !(prev instanceof Ext.toolbar.Separator);
};
me.clearMenu();
menu.removeAll();
for (; i < len; i++) {
item = items[i];
if (!i && (item instanceof Ext.toolbar.Separator)) {
continue;
}
if (prev && (needsSep(item, prev) || needsSep(prev, item))) {
menu.add('-');
}
me.addComponentToMenu(menu, item);
prev = item;
}
if (menu.items.length < 1) {
menu.add(me.noItemsMenuText);
}
},
createMenuConfig : function(component, hideOnClick) {
var config = Ext.apply({}, component.initialConfig),
group = component.toggleGroup;
Ext.copyTo(config, component, [
'iconCls', 'icon', 'itemId', 'disabled', 'handler', 'scope', 'menu'
]);
Ext.apply(config, {
text : component.overflowText || component.text,
hideOnClick: hideOnClick,
destroyMenu: false
});
if (group || component.enableToggle) {
Ext.apply(config, {
group : group,
checked: component.pressed,
listeners: {
checkchange: function(item, checked){
component.toggle(checked);
}
}
});
}
delete config.ownerCt;
delete config.xtype;
delete config.id;
return config;
},
addComponentToMenu : function(menu, component) {
var me = this;
if (component instanceof Ext.toolbar.Separator) {
menu.add('-');
} else if (component.isComponent) {
if (component.isXType('splitbutton')) {
menu.add(me.createMenuConfig(component, true));
} else if (component.isXType('button')) {
menu.add(me.createMenuConfig(component, !component.menu));
} else if (component.isXType('buttongroup')) {
component.items.each(function(item){
me.addComponentToMenu(menu, item);
});
} else {
menu.add(Ext.create(Ext.getClassName(component), me.createMenuConfig(component)));
}
}
},
clearMenu : function() {
var menu = this.moreMenu;
if (menu && menu.items) {
menu.items.each(function(item) {
if (item.menu) {
delete item.menu;
}
});
}
},
createMenu: function(calculations, targetSize) {
var me = this,
layout = me.layout,
startProp = layout.parallelBefore,
sizeProp = layout.parallelPrefix,
available = targetSize[sizeProp],
boxes = calculations.boxes,
i = 0,
len = boxes.length,
box;
if (!me.menuTrigger) {
me.createInnerElements();
me.menu = Ext.create('Ext.menu.Menu', {
listeners: {
scope: me,
beforeshow: me.beforeMenuShow
}
});
me.menuTrigger = Ext.create('Ext.button.Button', {
ownerCt : me.layout.owner,
iconCls : Ext.baseCSSPrefix + layout.owner.getXType() + '-more-icon',
ui : layout.owner instanceof Ext.toolbar.Toolbar ? 'default-toolbar' : 'default',
menu : me.menu,
getSplitCls: function() { return '';},
renderTo: me.afterCt
});
}
me.showTrigger();
available -= me.afterCt.getWidth();
me.menuItems.length = 0;
for (; i < len; i++) {
box = boxes[i];
if (box[startProp] + box[sizeProp] > available) {
me.menuItems.push(box.component);
box.component.hide();
}
}
},
createInnerElements: function() {
var me = this,
target = me.layout.getRenderTarget();
if (!this.afterCt) {
target.addCls(Ext.baseCSSPrefix + me.layout.direction + '-box-overflow-body');
this.afterCt = target.insertSibling({cls: Ext.layout.container.Box.prototype.innerCls + ' ' + this.afterCtCls}, 'before');
}
},
destroy: function() {
Ext.destroy(this.menu, this.menuTrigger);
}
});
Ext.define('Ext.util.Region', {
requires: ['Ext.util.Offset'],
statics: {
getRegion: function(el) {
return Ext.fly(el).getPageBox(true);
},
from: function(o) {
return new this(o.top, o.right, o.bottom, o.left);
}
},
constructor : function(t, r, b, l) {
var me = this;
me.y = me.top = me[1] = t;
me.right = r;
me.bottom = b;
me.x = me.left = me[0] = l;
},
contains : function(region) {
var me = this;
return (region.x >= me.x &&
region.right <= me.right &&
region.y >= me.y &&
region.bottom <= me.bottom);
},
intersect : function(region) {
var me = this,
t = Math.max(me.y, region.y),
r = Math.min(me.right, region.right),
b = Math.min(me.bottom, region.bottom),
l = Math.max(me.x, region.x);
if (b > t && r > l) {
return new this.self(t, r, b, l);
}
else {
return false;
}
},
union : function(region) {
var me = this,
t = Math.min(me.y, region.y),
r = Math.max(me.right, region.right),
b = Math.max(me.bottom, region.bottom),
l = Math.min(me.x, region.x);
return new this.self(t, r, b, l);
},
constrainTo : function(r) {
var me = this,
constrain = Ext.Number.constrain;
me.top = me.y = constrain(me.top, r.y, r.bottom);
me.bottom = constrain(me.bottom, r.y, r.bottom);
me.left = me.x = constrain(me.left, r.x, r.right);
me.right = constrain(me.right, r.x, r.right);
return me;
},
adjust : function(t, r, b, l) {
var me = this;
me.top = me.y += t;
me.left = me.x += l;
me.right += r;
me.bottom += b;
return me;
},
getOutOfBoundOffset: function(axis, p) {
if (!Ext.isObject(axis)) {
if (axis == 'x') {
return this.getOutOfBoundOffsetX(p);
} else {
return this.getOutOfBoundOffsetY(p);
}
} else {
p = axis;
var d = Ext.create('Ext.util.Offset');
d.x = this.getOutOfBoundOffsetX(p.x);
d.y = this.getOutOfBoundOffsetY(p.y);
return d;
}
},
getOutOfBoundOffsetX: function(p) {
if (p <= this.x) {
return this.x - p;
} else if (p >= this.right) {
return this.right - p;
}
return 0;
},
getOutOfBoundOffsetY: function(p) {
if (p <= this.y) {
return this.y - p;
} else if (p >= this.bottom) {
return this.bottom - p;
}
return 0;
},
isOutOfBound: function(axis, p) {
if (!Ext.isObject(axis)) {
if (axis == 'x') {
return this.isOutOfBoundX(p);
} else {
return this.isOutOfBoundY(p);
}
} else {
p = axis;
return (this.isOutOfBoundX(p.x) || this.isOutOfBoundY(p.y));
}
},
isOutOfBoundX: function(p) {
return (p < this.x || p > this.right);
},
isOutOfBoundY: function(p) {
return (p < this.y || p > this.bottom);
},
restrict: function(axis, p, factor) {
if (Ext.isObject(axis)) {
var newP;
factor = p;
p = axis;
if (p.copy) {
newP = p.copy();
}
else {
newP = {
x: p.x,
y: p.y
};
}
newP.x = this.restrictX(p.x, factor);
newP.y = this.restrictY(p.y, factor);
return newP;
} else {
if (axis == 'x') {
return this.restrictX(p, factor);
} else {
return this.restrictY(p, factor);
}
}
},
restrictX : function(p, factor) {
if (!factor) {
factor = 1;
}
if (p <= this.x) {
p -= (p - this.x) * factor;
}
else if (p >= this.right) {
p -= (p - this.right) * factor;
}
return p;
},
restrictY : function(p, factor) {
if (!factor) {
factor = 1;
}
if (p <= this.y) {
p -= (p - this.y) * factor;
}
else if (p >= this.bottom) {
p -= (p - this.bottom) * factor;
}
return p;
},
getSize: function() {
return {
width: this.right - this.x,
height: this.bottom - this.y
};
},
copy: function() {
return new this.self(this.y, this.right, this.bottom, this.x);
},
copyFrom: function(p) {
var me = this;
me.top = me.y = me[1] = p.y;
me.right = p.right;
me.bottom = p.bottom;
me.left = me.x = me[0] = p.x;
return this;
},
toString: function() {
return "Region[" + this.top + "," + this.right + "," + this.bottom + "," + this.left + "]";
},
translateBy: function(x, y) {
if (arguments.length == 1) {
y = x.y;
x = x.x;
}
var me = this;
me.top = me.y += y;
me.right += x;
me.bottom += y;
me.left = me.x += x;
return me;
},
round: function() {
var me = this;
me.top = me.y = Math.round(me.y);
me.right = Math.round(me.right);
me.bottom = Math.round(me.bottom);
me.left = me.x = Math.round(me.x);
return me;
},
equals: function(region) {
return (this.top == region.top && this.right == region.right && this.bottom == region.bottom && this.left == region.left);
}
});
Ext.define('Ext.dd.DragDropManager', {
singleton: true,
requires: ['Ext.util.Region'],
uses: ['Ext.tip.QuickTipManager'],
alternateClassName: ['Ext.dd.DragDropMgr', 'Ext.dd.DDM'],
ids: {},
handleIds: {},
dragCurrent: null,
dragOvers: {},
deltaX: 0,
deltaY: 0,
preventDefault: true,
stopPropagation: true,
initialized: false,
locked: false,
init: function() {
this.initialized = true;
},
POINT: 0,
INTERSECT: 1,
mode: 0,
_execOnAll: function(sMethod, args) {
for (var i in this.ids) {
for (var j in this.ids[i]) {
var oDD = this.ids[i][j];
if (! this.isTypeOfDD(oDD)) {
continue;
}
oDD[sMethod].apply(oDD, args);
}
}
},
_onLoad: function() {
this.init();
var Event = Ext.EventManager;
Event.on(document, "mouseup", this.handleMouseUp, this, true);
Event.on(document, "mousemove", this.handleMouseMove, this, true);
Event.on(window, "unload", this._onUnload, this, true);
Event.on(window, "resize", this._onResize, this, true);
},
_onResize: function(e) {
this._execOnAll("resetConstraints", []);
},
lock: function() { this.locked = true; },
unlock: function() { this.locked = false; },
isLocked: function() { return this.locked; },
locationCache: {},
useCache: true,
clickPixelThresh: 3,
clickTimeThresh: 350,
dragThreshMet: false,
clickTimeout: null,
startX: 0,
startY: 0,
regDragDrop: function(oDD, sGroup) {
if (!this.initialized) { this.init(); }
if (!this.ids[sGroup]) {
this.ids[sGroup] = {};
}
this.ids[sGroup][oDD.id] = oDD;
},
removeDDFromGroup: function(oDD, sGroup) {
if (!this.ids[sGroup]) {
this.ids[sGroup] = {};
}
var obj = this.ids[sGroup];
if (obj && obj[oDD.id]) {
delete obj[oDD.id];
}
},
_remove: function(oDD) {
for (var g in oDD.groups) {
if (g && this.ids[g] && this.ids[g][oDD.id]) {
delete this.ids[g][oDD.id];
}
}
delete this.handleIds[oDD.id];
},
regHandle: function(sDDId, sHandleId) {
if (!this.handleIds[sDDId]) {
this.handleIds[sDDId] = {};
}
this.handleIds[sDDId][sHandleId] = sHandleId;
},
isDragDrop: function(id) {
return ( this.getDDById(id) ) ? true : false;
},
getRelated: function(p_oDD, bTargetsOnly) {
var oDDs = [];
for (var i in p_oDD.groups) {
for (var j in this.ids[i]) {
var dd = this.ids[i][j];
if (! this.isTypeOfDD(dd)) {
continue;
}
if (!bTargetsOnly || dd.isTarget) {
oDDs[oDDs.length] = dd;
}
}
}
return oDDs;
},
isLegalTarget: function (oDD, oTargetDD) {
var targets = this.getRelated(oDD, true);
for (var i=0, len=targets.length;i this.clickPixelThresh ||
diffY > this.clickPixelThresh) {
this.startDrag(this.startX, this.startY);
}
}
if (this.dragThreshMet) {
this.dragCurrent.b4Drag(e);
this.dragCurrent.onDrag(e);
if(!this.dragCurrent.moveOnly){
this.fireEvents(e, false);
}
}
this.stopEvent(e);
return true;
},
fireEvents: function(e, isDrop) {
var dc = this.dragCurrent;
if (!dc || dc.isLocked()) {
return;
}
var pt = e.getPoint();
var oldOvers = [];
var outEvts = [];
var overEvts = [];
var dropEvts = [];
var enterEvts = [];
for (var i in this.dragOvers) {
var ddo = this.dragOvers[i];
if (! this.isTypeOfDD(ddo)) {
continue;
}
if (! this.isOverTarget(pt, ddo, this.mode)) {
outEvts.push( ddo );
}
oldOvers[i] = true;
delete this.dragOvers[i];
}
for (var sGroup in dc.groups) {
if ("string" != typeof sGroup) {
continue;
}
for (i in this.ids[sGroup]) {
var oDD = this.ids[sGroup][i];
if (! this.isTypeOfDD(oDD)) {
continue;
}
if (oDD.isTarget && !oDD.isLocked() && ((oDD != dc) || (dc.ignoreSelf === false))) {
if (this.isOverTarget(pt, oDD, this.mode)) {
if (isDrop) {
dropEvts.push( oDD );
} else {
if (!oldOvers[oDD.id]) {
enterEvts.push( oDD );
} else {
overEvts.push( oDD );
}
this.dragOvers[oDD.id] = oDD;
}
}
}
}
}
if (this.mode) {
if (outEvts.length) {
dc.b4DragOut(e, outEvts);
dc.onDragOut(e, outEvts);
}
if (enterEvts.length) {
dc.onDragEnter(e, enterEvts);
}
if (overEvts.length) {
dc.b4DragOver(e, overEvts);
dc.onDragOver(e, overEvts);
}
if (dropEvts.length) {
dc.b4DragDrop(e, dropEvts);
dc.onDragDrop(e, dropEvts);
}
} else {
var len = 0;
for (i=0, len=outEvts.length; i 2000) {
} else {
setTimeout(this._addListeners, 10);
if (document && document.body) {
this._timeoutCount += 1;
}
}
}
},
handleWasClicked: function(node, id) {
if (this.isHandle(id, node.id)) {
return true;
} else {
var p = node.parentNode;
while (p) {
if (this.isHandle(id, p.id)) {
return true;
} else {
p = p.parentNode;
}
}
}
return false;
}
}, function() {
this._addListeners();
});
Ext.define('Ext.layout.container.Box', {
alias: ['layout.box'],
extend: 'Ext.layout.container.Container',
alternateClassName: 'Ext.layout.BoxLayout',
requires: [
'Ext.layout.container.boxOverflow.None',
'Ext.layout.container.boxOverflow.Menu',
'Ext.layout.container.boxOverflow.Scroller',
'Ext.util.Format',
'Ext.dd.DragDropManager'
],
defaultMargins: {
top: 0,
right: 0,
bottom: 0,
left: 0
},
padding: '0',
pack: 'start',
type: 'box',
scrollOffset: 0,
itemCls: Ext.baseCSSPrefix + 'box-item',
targetCls: Ext.baseCSSPrefix + 'box-layout-ct',
innerCls: Ext.baseCSSPrefix + 'box-inner',
bindToOwnerCtContainer: true,
availableSpaceOffset: 0,
reserveOffset: true,
clearInnerCtOnLayout: false,
flexSortFn: function (a, b) {
var maxParallelPrefix = 'max' + this.parallelPrefixCap,
infiniteValue = Infinity;
a = a.component[maxParallelPrefix] || infiniteValue;
b = b.component[maxParallelPrefix] || infiniteValue;
if (!isFinite(a) && !isFinite(b)) {
return false;
}
return a - b;
},
minSizeSortFn: function(a, b) {
return b.available - a.available;
},
constructor: function(config) {
var me = this;
me.callParent(arguments);
me.flexSortFn = Ext.Function.bind(me.flexSortFn, me);
me.initOverflowHandler();
},
getChildBox: function(child) {
child = child.el || this.owner.getComponent(child).el;
var size = child.getBox(false, true);
return {
left: size.left,
top: size.top,
width: size.width,
height: size.height
};
},
calculateChildBox: function(child) {
var me = this,
boxes = me.calculateChildBoxes(me.getVisibleItems(), me.getLayoutTargetSize()).boxes,
ln = boxes.length,
i = 0;
child = me.owner.getComponent(child);
for (; i < ln; i++) {
if (boxes[i].component === child) {
return boxes[i];
}
}
},
calculateChildBoxes: function(visibleItems, targetSize) {
var me = this,
math = Math,
mmax = math.max,
infiniteValue = Infinity,
undefinedValue,
parallelPrefix = me.parallelPrefix,
parallelPrefixCap = me.parallelPrefixCap,
perpendicularPrefix = me.perpendicularPrefix,
perpendicularPrefixCap = me.perpendicularPrefixCap,
parallelMinString = 'min' + parallelPrefixCap,
perpendicularMinString = 'min' + perpendicularPrefixCap,
perpendicularMaxString = 'max' + perpendicularPrefixCap,
parallelSize = targetSize[parallelPrefix] - me.scrollOffset,
perpendicularSize = targetSize[perpendicularPrefix],
padding = me.padding,
parallelOffset = padding[me.parallelBefore],
paddingParallel = parallelOffset + padding[me.parallelAfter],
perpendicularOffset = padding[me.perpendicularLeftTop],
paddingPerpendicular = perpendicularOffset + padding[me.perpendicularRightBottom],
availPerpendicularSize = mmax(0, perpendicularSize - paddingPerpendicular),
innerCtBorderWidth = me.innerCt.getBorderWidth(me.perpendicularLT + me.perpendicularRB),
isStart = me.pack == 'start',
isCenter = me.pack == 'center',
isEnd = me.pack == 'end',
constrain = Ext.Number.constrain,
visibleCount = visibleItems.length,
nonFlexSize = 0,
totalFlex = 0,
desiredSize = 0,
minimumSize = 0,
maxSize = 0,
boxes = [],
minSizes = [],
calculatedWidth,
i, child, childParallel, childPerpendicular, childMargins, childSize, minParallel, tmpObj, shortfall,
tooNarrow, availableSpace, minSize, item, length, itemIndex, box, oldSize, newSize, reduction, diff,
flexedBoxes, remainingSpace, remainingFlex, flexedSize, parallelMargins, calcs, offset,
perpendicularMargins, stretchSize;
for (i = 0; i < visibleCount; i++) {
child = visibleItems[i];
childPerpendicular = child[perpendicularPrefix];
if (!child.flex || !(me.align == 'stretch' || me.align == 'stretchmax')) {
if (child.componentLayout.initialized !== true) {
me.layoutItem(child);
}
}
childMargins = child.margins;
parallelMargins = childMargins[me.parallelBefore] + childMargins[me.parallelAfter];
tmpObj = {
component: child,
margins: childMargins
};
if (child.flex) {
totalFlex += child.flex;
childParallel = undefinedValue;
}
else {
if (!(child[parallelPrefix] && childPerpendicular)) {
childSize = child.getSize();
}
childParallel = child[parallelPrefix] || childSize[parallelPrefix];
childPerpendicular = childPerpendicular || childSize[perpendicularPrefix];
}
nonFlexSize += parallelMargins + (childParallel || 0);
desiredSize += parallelMargins + (child.flex ? child[parallelMinString] || 0 : childParallel);
minimumSize += parallelMargins + (child[parallelMinString] || childParallel || 0);
if (typeof childPerpendicular != 'number') {
childPerpendicular = child['get' + perpendicularPrefixCap]();
}
maxSize = mmax(maxSize, childPerpendicular + childMargins[me.perpendicularLeftTop] + childMargins[me.perpendicularRightBottom]);
tmpObj[parallelPrefix] = childParallel || undefinedValue;
tmpObj[perpendicularPrefix] = childPerpendicular || undefinedValue;
boxes.push(tmpObj);
}
shortfall = desiredSize - parallelSize;
tooNarrow = minimumSize > parallelSize;
availableSpace = mmax(0, parallelSize - nonFlexSize - paddingParallel - (me.reserveOffset ? me.availableSpaceOffset : 0));
if (tooNarrow) {
for (i = 0; i < visibleCount; i++) {
box = boxes[i];
minSize = visibleItems[i][parallelMinString] || visibleItems[i][parallelPrefix] || box[parallelPrefix];
box.dirtySize = box.dirtySize || box[parallelPrefix] != minSize;
box[parallelPrefix] = minSize;
}
}
else {
if (shortfall > 0) {
for (i = 0; i < visibleCount; i++) {
item = visibleItems[i];
minSize = item[parallelMinString] || 0;
if (item.flex) {
box = boxes[i];
box.dirtySize = box.dirtySize || box[parallelPrefix] != minSize;
box[parallelPrefix] = minSize;
}
else {
minSizes.push({
minSize: minSize,
available: boxes[i][parallelPrefix] - minSize,
index: i
});
}
}
Ext.Array.sort(minSizes, me.minSizeSortFn);
for (i = 0, length = minSizes.length; i < length; i++) {
itemIndex = minSizes[i].index;
if (itemIndex == undefinedValue) {
continue;
}
item = visibleItems[itemIndex];
minSize = minSizes[i].minSize;
box = boxes[itemIndex];
oldSize = box[parallelPrefix];
newSize = mmax(minSize, oldSize - math.ceil(shortfall / (length - i)));
reduction = oldSize - newSize;
box.dirtySize = box.dirtySize || box[parallelPrefix] != newSize;
box[parallelPrefix] = newSize;
shortfall -= reduction;
}
}
else {
remainingSpace = availableSpace;
remainingFlex = totalFlex;
flexedBoxes = [];
for (i = 0; i < visibleCount; i++) {
child = visibleItems[i];
if (isStart && child.flex) {
flexedBoxes.push(boxes[Ext.Array.indexOf(visibleItems, child)]);
}
}
Ext.Array.sort(flexedBoxes, me.flexSortFn);
for (i = 0; i < flexedBoxes.length; i++) {
calcs = flexedBoxes[i];
child = calcs.component;
childMargins = calcs.margins;
flexedSize = math.ceil((child.flex / remainingFlex) * remainingSpace);
flexedSize = Math.max(child['min' + parallelPrefixCap] || 0, math.min(child['max' + parallelPrefixCap] || infiniteValue, flexedSize));
remainingSpace -= flexedSize;
remainingFlex -= child.flex;
calcs.dirtySize = calcs.dirtySize || calcs[parallelPrefix] != flexedSize;
calcs[parallelPrefix] = flexedSize;
}
}
}
if (isCenter) {
parallelOffset += availableSpace / 2;
}
else if (isEnd) {
parallelOffset += availableSpace;
}
if (me.owner.dock && (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) && !me.owner.width && me.direction == 'vertical') {
calculatedWidth = maxSize + me.owner.el.getPadding('lr') + me.owner.el.getBorderWidth('lr');
if (me.owner.frameSize) {
calculatedWidth += me.owner.frameSize.left + me.owner.frameSize.right;
}
availPerpendicularSize = Math.min(availPerpendicularSize, targetSize.width = maxSize + padding.left + padding.right);
}
for (i = 0; i < visibleCount; i++) {
child = visibleItems[i];
calcs = boxes[i];
childMargins = calcs.margins;
perpendicularMargins = childMargins[me.perpendicularLeftTop] + childMargins[me.perpendicularRightBottom];
parallelOffset += childMargins[me.parallelBefore];
calcs[me.parallelBefore] = parallelOffset;
calcs[me.perpendicularLeftTop] = perpendicularOffset + childMargins[me.perpendicularLeftTop];
if (me.align == 'stretch') {
stretchSize = constrain(availPerpendicularSize - perpendicularMargins, child[perpendicularMinString] || 0, child[perpendicularMaxString] || infiniteValue);
calcs.dirtySize = calcs.dirtySize || calcs[perpendicularPrefix] != stretchSize;
calcs[perpendicularPrefix] = stretchSize;
}
else if (me.align == 'stretchmax') {
stretchSize = constrain(maxSize - perpendicularMargins, child[perpendicularMinString] || 0, child[perpendicularMaxString] || infiniteValue);
calcs.dirtySize = calcs.dirtySize || calcs[perpendicularPrefix] != stretchSize;
calcs[perpendicularPrefix] = stretchSize;
}
else if (me.align == me.alignCenteringString) {
diff = mmax(availPerpendicularSize, maxSize) - innerCtBorderWidth - calcs[perpendicularPrefix];
if (diff > 0) {
calcs[me.perpendicularLeftTop] = perpendicularOffset + Math.round(diff / 2);
}
}
parallelOffset += (calcs[parallelPrefix] || 0) + childMargins[me.parallelAfter];
}
return {
boxes: boxes,
meta : {
calculatedWidth: calculatedWidth,
maxSize: maxSize,
nonFlexSize: nonFlexSize,
desiredSize: desiredSize,
minimumSize: minimumSize,
shortfall: shortfall,
tooNarrow: tooNarrow
}
};
},
onRemove: function(comp){
this.callParent(arguments);
if (this.overflowHandler) {
this.overflowHandler.onRemove(comp);
}
},
initOverflowHandler: function() {
var handler = this.overflowHandler;
if (typeof handler == 'string') {
handler = {
type: handler
};
}
var handlerType = 'None';
if (handler && handler.type !== undefined) {
handlerType = handler.type;
}
var constructor = Ext.layout.container.boxOverflow[handlerType];
if (constructor[this.type]) {
constructor = constructor[this.type];
}
this.overflowHandler = Ext.create('Ext.layout.container.boxOverflow.' + handlerType, this, handler);
},
onLayout: function() {
this.callParent();
if (this.clearInnerCtOnLayout === true && this.adjustmentPass !== true) {
this.innerCt.setSize(null, null);
}
var me = this,
targetSize = me.getLayoutTargetSize(),
items = me.getVisibleItems(),
calcs = me.calculateChildBoxes(items, targetSize),
boxes = calcs.boxes,
meta = calcs.meta,
handler, method, results;
if (me.autoSize && calcs.meta.desiredSize) {
targetSize[me.parallelPrefix] = calcs.meta.desiredSize;
}
if (meta.shortfall > 0) {
handler = me.overflowHandler;
method = meta.tooNarrow ? 'handleOverflow': 'clearOverflow';
results = handler[method](calcs, targetSize);
if (results) {
if (results.targetSize) {
targetSize = results.targetSize;
}
if (results.recalculate) {
items = me.getVisibleItems();
calcs = me.calculateChildBoxes(items, targetSize);
boxes = calcs.boxes;
}
}
} else {
me.overflowHandler.clearOverflow();
}
me.layoutTargetLastSize = targetSize;
me.childBoxCache = calcs;
me.updateInnerCtSize(targetSize, calcs);
me.updateChildBoxes(boxes);
me.handleTargetOverflow(targetSize);
},
updateChildBoxes: function(boxes) {
var me = this,
i = 0,
length = boxes.length,
animQueue = [],
dd = Ext.dd.DDM.getDDById(me.innerCt.id),
oldBox, newBox, changed, comp, boxAnim, animCallback;
for (; i < length; i++) {
newBox = boxes[i];
comp = newBox.component;
if (dd && (dd.getDragEl() === comp.el.dom)) {
continue;
}
changed = false;
oldBox = me.getChildBox(comp);
if (me.animate) {
animCallback = me.animate.callback || me.animate;
boxAnim = {
layoutAnimation: true,
target: comp,
from: {},
to: {},
listeners: {}
};
if (!isNaN(newBox.width) && (newBox.width != oldBox.width)) {
changed = true;
boxAnim.to.width = newBox.width;
}
if (!isNaN(newBox.height) && (newBox.height != oldBox.height)) {
changed = true;
boxAnim.to.height = newBox.height;
}
if (!isNaN(newBox.left) && (newBox.left != oldBox.left)) {
changed = true;
boxAnim.to.left = newBox.left;
}
if (!isNaN(newBox.top) && (newBox.top != oldBox.top)) {
changed = true;
boxAnim.to.top = newBox.top;
}
if (changed) {
animQueue.push(boxAnim);
}
} else {
if (newBox.dirtySize) {
if (newBox.width !== oldBox.width || newBox.height !== oldBox.height) {
me.setItemSize(comp, newBox.width, newBox.height);
}
}
if (isNaN(newBox.left) || isNaN(newBox.top)) {
continue;
}
comp.setPosition(newBox.left, newBox.top);
}
}
length = animQueue.length;
if (length) {
var afterAnimate = function(anim) {
length -= 1;
if (!length) {
me.layoutBusy = false;
if (Ext.isFunction(animCallback)) {
animCallback();
}
}
};
var beforeAnimate = function() {
me.layoutBusy = true;
};
for (i = 0, length = animQueue.length; i < length; i++) {
boxAnim = animQueue[i];
boxAnim.listeners.afteranimate = afterAnimate;
if (!i) {
boxAnim.listeners.beforeanimate = beforeAnimate;
}
if (me.animate.duration) {
boxAnim.duration = me.animate.duration;
}
comp = boxAnim.target;
delete boxAnim.target;
comp.stopAnimation();
comp.animate(boxAnim);
}
}
},
updateInnerCtSize: function(tSize, calcs) {
var me = this,
mmax = Math.max,
align = me.align,
padding = me.padding,
width = tSize.width,
height = tSize.height,
meta = calcs.meta,
innerCtWidth,
innerCtHeight;
if (me.direction == 'horizontal') {
innerCtWidth = width;
innerCtHeight = meta.maxSize + padding.top + padding.bottom + me.innerCt.getBorderWidth('tb');
if (align == 'stretch') {
innerCtHeight = height;
}
else if (align == 'middle') {
innerCtHeight = mmax(height, innerCtHeight);
}
} else {
innerCtHeight = height;
innerCtWidth = meta.maxSize + padding.left + padding.right + me.innerCt.getBorderWidth('lr');
if (align == 'stretch') {
innerCtWidth = width;
}
else if (align == 'center') {
innerCtWidth = mmax(width, innerCtWidth);
}
}
me.getRenderTarget().setSize(innerCtWidth || undefined, innerCtHeight || undefined);
if (meta.calculatedWidth && me.owner.el.getWidth() > meta.calculatedWidth) {
me.owner.el.setWidth(meta.calculatedWidth);
}
if (me.innerCt.dom.scrollTop) {
me.innerCt.dom.scrollTop = 0;
}
},
handleTargetOverflow: function(previousTargetSize) {
var target = this.getTarget(),
overflow = target.getStyle('overflow'),
newTargetSize;
if (overflow && overflow != 'hidden' && !this.adjustmentPass) {
newTargetSize = this.getLayoutTargetSize();
if (newTargetSize.width != previousTargetSize.width || newTargetSize.height != previousTargetSize.height) {
this.adjustmentPass = true;
this.onLayout();
return true;
}
}
delete this.adjustmentPass;
},
isValidParent : function(item, target, position) {
var itemEl = item.el ? item.el.dom : Ext.getDom(item);
return (itemEl && this.innerCt && itemEl.parentNode === this.innerCt.dom) || false;
},
getRenderTarget: function() {
if (!this.innerCt) {
this.innerCt = this.getTarget().createChild({
cls: this.innerCls,
role: 'presentation'
});
this.padding = Ext.util.Format.parseBox(this.padding);
}
return this.innerCt;
},
renderItem: function(item, target) {
this.callParent(arguments);
var me = this,
itemEl = item.getEl(),
style = itemEl.dom.style,
margins = item.margins || item.margin;
if (margins) {
if (Ext.isString(margins) || Ext.isNumber(margins)) {
margins = Ext.util.Format.parseBox(margins);
} else {
Ext.applyIf(margins, {top: 0, right: 0, bottom: 0, left: 0});
}
} else {
margins = Ext.apply({}, me.defaultMargins);
}
margins.top += itemEl.getMargin('t');
margins.right += itemEl.getMargin('r');
margins.bottom += itemEl.getMargin('b');
margins.left += itemEl.getMargin('l');
style.marginTop = style.marginRight = style.marginBottom = style.marginLeft = '0';
item.margins = margins;
},
destroy: function() {
Ext.destroy(this.overflowHandler);
this.callParent(arguments);
}
});
Ext.define('Ext.layout.container.HBox', {
alias: ['layout.hbox'],
extend: 'Ext.layout.container.Box',
alternateClassName: 'Ext.layout.HBoxLayout',
align: 'top',
//@private
alignCenteringString: 'middle',
type : 'hbox',
direction: 'horizontal',
parallelSizeIndex: 0,
perpendicularSizeIndex: 1,
parallelPrefix: 'width',
parallelPrefixCap: 'Width',
parallelLT: 'l',
parallelRB: 'r',
parallelBefore: 'left',
parallelBeforeCap: 'Left',
parallelAfter: 'right',
parallelPosition: 'x',
perpendicularPrefix: 'height',
perpendicularPrefixCap: 'Height',
perpendicularLT: 't',
perpendicularRB: 'b',
perpendicularLeftTop: 'top',
perpendicularRightBottom: 'bottom',
perpendicularPosition: 'y',
configureItem: function(item) {
if (item.flex) {
item.layoutManagedWidth = 1;
} else {
item.layoutManagedWidth = 2;
}
if (this.align === 'stretch' || this.align === 'stretchmax') {
item.layoutManagedHeight = 1;
} else {
item.layoutManagedHeight = 2;
}
this.callParent(arguments);
}
});
Ext.define('Ext.layout.container.VBox', {
alias: ['layout.vbox'],
extend: 'Ext.layout.container.Box',
alternateClassName: 'Ext.layout.VBoxLayout',
align : 'left',
//@private
alignCenteringString: 'center',
type: 'vbox',
direction: 'vertical',
parallelSizeIndex: 1,
perpendicularSizeIndex: 0,
parallelPrefix: 'height',
parallelPrefixCap: 'Height',
parallelLT: 't',
parallelRB: 'b',
parallelBefore: 'top',
parallelBeforeCap: 'Top',
parallelAfter: 'bottom',
parallelPosition: 'y',
perpendicularPrefix: 'width',
perpendicularPrefixCap: 'Width',
perpendicularLT: 'l',
perpendicularRB: 'r',
perpendicularLeftTop: 'left',
perpendicularRightBottom: 'right',
perpendicularPosition: 'x',
configureItem: function(item) {
if (item.flex) {
item.layoutManagedHeight = 1;
} else {
item.layoutManagedHeight = 2;
}
if (this.align === 'stretch' || this.align === 'stretchmax') {
item.layoutManagedWidth = 1;
} else {
item.layoutManagedWidth = 2;
}
this.callParent(arguments);
}
});
Ext.define('Ext.FocusManager', {
singleton: true,
alternateClassName: 'Ext.FocusMgr',
mixins: {
observable: 'Ext.util.Observable'
},
requires: [
'Ext.ComponentManager',
'Ext.ComponentQuery',
'Ext.util.HashMap',
'Ext.util.KeyNav'
],
enabled: false,
focusElementCls: Ext.baseCSSPrefix + 'focus-element',
focusFrameCls: Ext.baseCSSPrefix + 'focus-frame',
whitelist: [
'textfield'
],
tabIndexWhitelist: [
'a',
'button',
'embed',
'frame',
'iframe',
'img',
'input',
'object',
'select',
'textarea'
],
constructor: function() {
var me = this,
CQ = Ext.ComponentQuery;
me.addEvents(
'beforecomponentfocus',
'componentfocus',
'disable',
'enable'
);
me.keyNav = Ext.create('Ext.util.KeyNav', Ext.getDoc(), {
disabled: true,
scope: me,
backspace: me.focusLast,
enter: me.navigateIn,
esc: me.navigateOut,
tab: me.navigateSiblings
});
me.focusData = {};
me.subscribers = Ext.create('Ext.util.HashMap');
me.focusChain = {};
Ext.apply(CQ.pseudos, {
focusable: function(cmps) {
var len = cmps.length,
results = [],
i = 0,
c,
isFocusable = function(x) {
return x && x.focusable !== false && CQ.is(x, '[rendered]:not([destroying]):not([isDestroyed]):not([disabled]){isVisible(true)}{el && c.el.dom && c.el.isVisible()}');
};
for (; i < len; i++) {
c = cmps[i];
if (isFocusable(c)) {
results.push(c);
}
}
return results;
},
nextFocus: function(cmps, idx, step) {
step = step || 1;
idx = parseInt(idx, 10);
var len = cmps.length,
i = idx + step,
c;
for (; i != idx; i += step) {
if (i >= len) {
i = 0;
} else if (i < 0) {
i = len - 1;
}
c = cmps[i];
if (CQ.is(c, ':focusable')) {
return [c];
} else if (c.placeholder && CQ.is(c.placeholder, ':focusable')) {
return [c.placeholder];
}
}
return [];
},
prevFocus: function(cmps, idx) {
return this.nextFocus(cmps, idx, -1);
},
root: function(cmps) {
var len = cmps.length,
results = [],
i = 0,
c;
for (; i < len; i++) {
c = cmps[i];
if (!c.ownerCt) {
results.push(c);
}
}
return results;
}
});
},
addXTypeToWhitelist: function(xtype) {
var me = this;
if (Ext.isArray(xtype)) {
Ext.Array.forEach(xtype, me.addXTypeToWhitelist, me);
return;
}
if (!Ext.Array.contains(me.whitelist, xtype)) {
me.whitelist.push(xtype);
}
},
clearComponent: function(cmp) {
clearTimeout(this.cmpFocusDelay);
if (!cmp.isDestroyed) {
cmp.blur();
}
},
disable: function() {
var me = this;
if (!me.enabled) {
return;
}
delete me.options;
me.enabled = false;
Ext.ComponentManager.all.un('add', me.onComponentCreated, me);
me.removeDOM();
me.keyNav.disable();
me.setFocusAll(false);
me.fireEvent('disable', me);
},
enable: function(options) {
var me = this;
if (options === true) {
options = { focusFrame: true };
}
me.options = options = options || {};
if (me.enabled) {
return;
}
Ext.ComponentManager.all.on('add', me.onComponentCreated, me);
me.initDOM(options);
me.keyNav.enable();
me.setFocusAll(true, options);
me.focusEl.focus();
delete me.focusedCmp;
me.enabled = true;
me.fireEvent('enable', me);
},
focusLast: function(e) {
var me = this;
if (me.isWhitelisted(me.focusedCmp)) {
return true;
}
if (me.previousFocusedCmp) {
me.previousFocusedCmp.focus();
}
},
getRootComponents: function() {
var me = this,
CQ = Ext.ComponentQuery,
inline = CQ.query(':focusable:root:not([floating])'),
floating = CQ.query(':focusable:root[floating]');
floating.sort(function(a, b) {
return a.el.getZIndex() > b.el.getZIndex();
});
return floating.concat(inline);
},
initDOM: function(options) {
var me = this,
sp = ' ',
cls = me.focusFrameCls;
if (!Ext.isReady) {
Ext.onReady(me.initDOM, me);
return;
}
if (!me.focusEl) {
me.focusEl = Ext.getBody().createChild({
tabIndex: '-1',
cls: me.focusElementCls,
html: sp
});
}
if (!me.focusFrame && options.focusFrame) {
me.focusFrame = Ext.getBody().createChild({
cls: cls,
children: [
{ cls: cls + '-top' },
{ cls: cls + '-bottom' },
{ cls: cls + '-left' },
{ cls: cls + '-right' }
],
style: 'top: -100px; left: -100px;'
});
me.focusFrame.setVisibilityMode(Ext.core.Element.DISPLAY);
me.focusFrameWidth = me.focusFrame.child('.' + cls + '-top').getHeight();
me.focusFrame.hide().setLeftTop(0, 0);
}
},
isWhitelisted: function(cmp) {
return cmp && Ext.Array.some(this.whitelist, function(x) {
return cmp.isXType(x);
});
},
navigateIn: function(e) {
var me = this,
focusedCmp = me.focusedCmp,
rootCmps,
firstChild;
if (!focusedCmp) {
rootCmps = me.getRootComponents();
if (rootCmps.length) {
rootCmps[0].focus();
}
} else {
firstChild = Ext.ComponentQuery.query('>:focusable', focusedCmp)[0];
if (firstChild) {
firstChild.focus();
} else {
if (Ext.isFunction(focusedCmp.onClick)) {
e.button = 0;
focusedCmp.onClick(e);
focusedCmp.focus();
}
}
}
},
navigateOut: function(e) {
var me = this,
parent;
if (!me.focusedCmp || !(parent = me.focusedCmp.up(':focusable'))) {
me.focusEl.focus();
} else {
parent.focus();
}
return true;
},
navigateSiblings: function(e, source, parent) {
var me = this,
src = source || me,
key = e.getKey(),
EO = Ext.EventObject,
goBack = e.shiftKey || key == EO.LEFT || key == EO.UP,
checkWhitelist = key == EO.LEFT || key == EO.RIGHT || key == EO.UP || key == EO.DOWN,
nextSelector = goBack ? 'prev' : 'next',
idx, next, focusedCmp;
focusedCmp = (src.focusedCmp && src.focusedCmp.comp) || src.focusedCmp;
if (!focusedCmp && !parent) {
return;
}
if (checkWhitelist && me.isWhitelisted(focusedCmp)) {
return true;
}
parent = parent || focusedCmp.up();
if (parent) {
idx = focusedCmp ? Ext.Array.indexOf(parent.getRefItems(), focusedCmp) : -1;
next = Ext.ComponentQuery.query('>:' + nextSelector + 'Focus(' + idx + ')', parent)[0];
if (next && focusedCmp !== next) {
next.focus();
return next;
}
}
},
onComponentBlur: function(cmp, e) {
var me = this;
if (me.focusedCmp === cmp) {
me.previousFocusedCmp = cmp;
delete me.focusedCmp;
}
if (me.focusFrame) {
me.focusFrame.hide();
}
},
onComponentCreated: function(hash, id, cmp) {
this.setFocus(cmp, true, this.options);
},
onComponentDestroy: function(cmp) {
this.setFocus(cmp, false);
},
onComponentFocus: function(cmp, e) {
var me = this,
chain = me.focusChain;
if (!Ext.ComponentQuery.is(cmp, ':focusable')) {
me.clearComponent(cmp);
if (chain[cmp.id]) {
return;
}
var parent = cmp.up();
if (parent) {
chain[cmp.id] = true;
parent.focus();
}
return;
}
me.focusChain = {};
clearTimeout(me.cmpFocusDelay);
if (arguments.length !== 2) {
me.cmpFocusDelay = Ext.defer(me.onComponentFocus, 90, me, [cmp, e]);
return;
}
if (me.fireEvent('beforecomponentfocus', me, cmp, me.previousFocusedCmp) === false) {
me.clearComponent(cmp);
return;
}
me.focusedCmp = cmp;
if (me.shouldShowFocusFrame(cmp)) {
var cls = '.' + me.focusFrameCls + '-',
ff = me.focusFrame,
fw = me.focusFrameWidth,
box = cmp.el.getPageBox(),
bt = box.top,
bl = box.left,
bw = box.width,
bh = box.height,
ft = ff.child(cls + 'top'),
fb = ff.child(cls + 'bottom'),
fl = ff.child(cls + 'left'),
fr = ff.child(cls + 'right');
ft.setWidth(bw - 2).setLeftTop(bl + 1, bt);
fb.setWidth(bw - 2).setLeftTop(bl + 1, bt + bh - fw);
fl.setHeight(bh - 2).setLeftTop(bl, bt + 1);
fr.setHeight(bh - 2).setLeftTop(bl + bw - fw, bt + 1);
ff.show();
}
me.fireEvent('componentfocus', me, cmp, me.previousFocusedCmp);
},
onComponentHide: function(cmp) {
var me = this,
CQ = Ext.ComponentQuery,
cmpHadFocus = false,
focusedCmp,
parent;
if (me.focusedCmp) {
focusedCmp = CQ.query('[id=' + me.focusedCmp.id + ']', cmp)[0];
cmpHadFocus = me.focusedCmp.id === cmp.id || focusedCmp;
if (focusedCmp) {
me.clearComponent(focusedCmp);
}
}
me.clearComponent(cmp);
if (cmpHadFocus) {
parent = CQ.query('^:focusable', cmp)[0];
if (parent) {
parent.focus();
}
}
},
removeDOM: function() {
var me = this;
if (me.enabled || me.subscribers.length) {
return;
}
Ext.destroy(
me.focusEl,
me.focusFrame
);
delete me.focusEl;
delete me.focusFrame;
delete me.focusFrameWidth;
},
removeXTypeFromWhitelist: function(xtype) {
var me = this;
if (Ext.isArray(xtype)) {
Ext.Array.forEach(xtype, me.removeXTypeFromWhitelist, me);
return;
}
Ext.Array.remove(me.whitelist, xtype);
},
setFocus: function(cmp, focusable, options) {
var me = this,
el, dom, data,
needsTabIndex = function(n) {
return !Ext.Array.contains(me.tabIndexWhitelist, n.tagName.toLowerCase())
&& n.tabIndex <= 0;
};
options = options || {};
if (!cmp.rendered) {
cmp.on('afterrender', Ext.pass(me.setFocus, arguments, me), me, { single: true });
return;
}
el = cmp.getFocusEl();
dom = el.dom;
if ((focusable && !me.focusData[cmp.id]) || (!focusable && me.focusData[cmp.id])) {
if (focusable) {
data = {
focusFrame: options.focusFrame
};
if (needsTabIndex(dom)) {
data.tabIndex = dom.tabIndex;
dom.tabIndex = -1;
}
el.on({
focus: data.focusFn = Ext.bind(me.onComponentFocus, me, [cmp], 0),
blur: data.blurFn = Ext.bind(me.onComponentBlur, me, [cmp], 0),
scope: me
});
cmp.on({
hide: me.onComponentHide,
close: me.onComponentHide,
beforedestroy: me.onComponentDestroy,
scope: me
});
me.focusData[cmp.id] = data;
} else {
data = me.focusData[cmp.id];
if ('tabIndex' in data) {
dom.tabIndex = data.tabIndex;
}
el.un('focus', data.focusFn, me);
el.un('blur', data.blurFn, me);
cmp.un('hide', me.onComponentHide, me);
cmp.un('close', me.onComponentHide, me);
cmp.un('beforedestroy', me.onComponentDestroy, me);
delete me.focusData[cmp.id];
}
}
},
setFocusAll: function(focusable, options) {
var me = this,
cmps = Ext.ComponentManager.all.getArray(),
len = cmps.length,
cmp,
i = 0;
for (; i < len; i++) {
me.setFocus(cmps[i], focusable, options);
}
},
setupSubscriberKeys: function(container, keys) {
var me = this,
el = container.getFocusEl(),
scope = keys.scope,
handlers = {
backspace: me.focusLast,
enter: me.navigateIn,
esc: me.navigateOut,
scope: me
},
navSiblings = function(e) {
if (me.focusedCmp === container) {
return me.navigateSiblings(e, me, container);
} else {
return me.navigateSiblings(e);
}
};
Ext.iterate(keys, function(key, cb) {
handlers[key] = function(e) {
var ret = navSiblings(e);
if (Ext.isFunction(cb) && cb.call(scope || container, e, ret) === true) {
return true;
}
return ret;
};
}, me);
return Ext.create('Ext.util.KeyNav', el, handlers);
},
shouldShowFocusFrame: function(cmp) {
var me = this,
opts = me.options || {};
if (!me.focusFrame || !cmp) {
return false;
}
if (opts.focusFrame) {
return true;
}
if (me.focusData[cmp.id].focusFrame) {
return true;
}
return false;
},
subscribe: function(container, options) {
var me = this,
EA = Ext.Array,
data = {},
subs = me.subscribers,
safeSetFocus = function(cmp) {
if (cmp.isContainer && !subs.containsKey(cmp.id)) {
EA.forEach(cmp.query('>'), safeSetFocus);
me.setFocus(cmp, true, options);
cmp.on('add', data.onAdd, me);
} else if (!cmp.isContainer) {
me.setFocus(cmp, true, options);
}
};
if (!container || !container.isContainer) {
return;
}
if (!container.rendered) {
container.on('afterrender', Ext.pass(me.subscribe, arguments, me), me, { single: true });
return;
}
me.initDOM(options);
data.keyNav = me.setupSubscriberKeys(container, options.keys);
data.onAdd = function(ct, cmp, idx) {
safeSetFocus(cmp);
};
container.on('beforedestroy', me.unsubscribe, me);
safeSetFocus(container);
subs.add(container.id, data);
},
unsubscribe: function(container) {
var me = this,
EA = Ext.Array,
subs = me.subscribers,
data,
safeSetFocus = function(cmp) {
if (cmp.isContainer && !subs.containsKey(cmp.id)) {
EA.forEach(cmp.query('>'), safeSetFocus);
me.setFocus(cmp, false);
cmp.un('add', data.onAdd, me);
} else if (!cmp.isContainer) {
me.setFocus(cmp, false);
}
};
if (!container || !subs.containsKey(container.id)) {
return;
}
data = subs.get(container.id);
data.keyNav.destroy();
container.un('beforedestroy', me.unsubscribe, me);
subs.removeAtKey(container.id);
safeSetFocus(container);
me.removeDOM();
}
});
Ext.define('Ext.toolbar.Toolbar', {
extend: 'Ext.container.Container',
requires: [
'Ext.toolbar.Fill',
'Ext.layout.container.HBox',
'Ext.layout.container.VBox',
'Ext.FocusManager'
],
uses: [
'Ext.toolbar.Separator'
],
alias: 'widget.toolbar',
alternateClassName: 'Ext.Toolbar',
isToolbar: true,
baseCls : Ext.baseCSSPrefix + 'toolbar',
ariaRole : 'toolbar',
defaultType: 'button',
vertical: false,
enableOverflow: false,
trackMenus: true,
itemCls: Ext.baseCSSPrefix + 'toolbar-item',
initComponent: function() {
var me = this,
keys;
if (!me.layout && me.enableOverflow) {
me.layout = { overflowHandler: 'Menu' };
}
if (me.dock === 'right' || me.dock === 'left') {
me.vertical = true;
}
me.layout = Ext.applyIf(Ext.isString(me.layout) ? {
type: me.layout
} : me.layout || {}, {
type: me.vertical ? 'vbox' : 'hbox',
align: me.vertical ? 'stretchmax' : 'middle',
clearInnerCtOnLayout: true
});
if (me.vertical) {
me.addClsWithUI('vertical');
}
if (me.ui === 'footer') {
me.ignoreBorderManagement = true;
}
me.callParent();
me.addEvents('overflowchange');
keys = me.vertical ? ['up', 'down'] : ['left', 'right'];
Ext.FocusManager.subscribe(me, {
keys: keys
});
},
lookupComponent: function(c) {
if (Ext.isString(c)) {
var shortcut = Ext.toolbar.Toolbar.shortcuts[c];
if (shortcut) {
c = {
xtype: shortcut
};
} else {
c = {
xtype: 'tbtext',
text: c
};
}
this.applyDefaults(c);
}
return this.callParent(arguments);
},
applyDefaults: function(c) {
if (!Ext.isString(c)) {
c = this.callParent(arguments);
var d = this.internalDefaults;
if (c.events) {
Ext.applyIf(c.initialConfig, d);
Ext.apply(c, d);
} else {
Ext.applyIf(c, d);
}
}
return c;
},
trackMenu: function(item, remove) {
if (this.trackMenus && item.menu) {
var method = remove ? 'mun' : 'mon',
me = this;
me[method](item, 'menutriggerover', me.onButtonTriggerOver, me);
me[method](item, 'menushow', me.onButtonMenuShow, me);
me[method](item, 'menuhide', me.onButtonMenuHide, me);
}
},
constructButton: function(item) {
return item.events ? item : this.createComponent(item, item.split ? 'splitbutton' : this.defaultType);
},
onBeforeAdd: function(component) {
if (component.is('field') || (component.is('button') && this.ui != 'footer')) {
component.ui = component.ui + '-toolbar';
}
if (component instanceof Ext.toolbar.Separator) {
component.setUI((this.vertical) ? 'vertical' : 'horizontal');
}
this.callParent(arguments);
},
onAdd: function(component) {
this.callParent(arguments);
this.trackMenu(component);
if (this.disabled) {
component.disable();
}
},
onRemove: function(c) {
this.callParent(arguments);
this.trackMenu(c, true);
},
onButtonTriggerOver: function(btn){
if (this.activeMenuBtn && this.activeMenuBtn != btn) {
this.activeMenuBtn.hideMenu();
btn.showMenu();
this.activeMenuBtn = btn;
}
},
onButtonMenuShow: function(btn) {
this.activeMenuBtn = btn;
},
onButtonMenuHide: function(btn) {
delete this.activeMenuBtn;
}
}, function() {
this.shortcuts = {
'-' : 'tbseparator',
' ' : 'tbspacer',
'->': 'tbfill'
};
});
Ext.define('Ext.panel.AbstractPanel', {
extend: 'Ext.container.Container',
requires: ['Ext.util.MixedCollection', 'Ext.core.Element', 'Ext.toolbar.Toolbar'],
baseCls : Ext.baseCSSPrefix + 'panel',
isPanel: true,
componentLayout: 'dock',
defaultDockWeights: { top: 1, left: 3, right: 5, bottom: 7 },
renderTpl: [' {bodyCls} {baseCls}-body-{ui} {parent.baseCls}-body-{parent.ui}-{.} style="{bodyStyle}" >
'],
border: true,
initComponent : function() {
var me = this;
me.addEvents(
'bodyresize'
);
Ext.applyIf(me.renderSelectors, {
body: '.' + me.baseCls + '-body'
});
if (me.frame && me.border && me.bodyBorder === undefined) {
me.bodyBorder = false;
}
if (me.frame && me.border && (me.bodyBorder === false || me.bodyBorder === 0)) {
me.manageBodyBorders = true;
}
me.callParent();
},
initItems : function() {
var me = this,
items = me.dockedItems;
me.callParent();
me.dockedItems = Ext.create('Ext.util.MixedCollection', false, me.getComponentId);
if (items) {
me.addDocked(items);
}
},
getDockedComponent: function(comp) {
if (Ext.isObject(comp)) {
comp = comp.getItemId();
}
return this.dockedItems.get(comp);
},
getComponent: function(comp) {
var component = this.callParent(arguments);
if (component === undefined && !Ext.isNumber(comp)) {
component = this.getDockedComponent(comp);
}
return component;
},
initBodyStyles: function() {
var me = this,
bodyStyle = me.bodyStyle,
styles = [],
Element = Ext.core.Element,
prop;
if (Ext.isFunction(bodyStyle)) {
bodyStyle = bodyStyle();
}
if (Ext.isString(bodyStyle)) {
styles = bodyStyle.split(';');
} else {
for (prop in bodyStyle) {
if (bodyStyle.hasOwnProperty(prop)) {
styles.push(prop + ':' + bodyStyle[prop]);
}
}
}
if (me.bodyPadding !== undefined) {
styles.push('padding: ' + Element.unitizeBox((me.bodyPadding === true) ? 5 : me.bodyPadding));
}
if (me.frame && me.bodyBorder) {
if (!Ext.isNumber(me.bodyBorder)) {
me.bodyBorder = 1;
}
styles.push('border-width: ' + Element.unitizeBox(me.bodyBorder));
}
delete me.bodyStyle;
return styles.length ? styles.join(';') : undefined;
},
initBodyCls: function() {
var me = this,
cls = '',
bodyCls = me.bodyCls;
if (bodyCls) {
Ext.each(bodyCls, function(v) {
cls += " " + v;
});
delete me.bodyCls;
}
return cls.length > 0 ? cls : undefined;
},
initRenderData: function() {
return Ext.applyIf(this.callParent(), {
bodyStyle: this.initBodyStyles(),
bodyCls: this.initBodyCls()
});
},
addDocked : function(items, pos) {
var me = this,
i = 0,
item, length;
items = me.prepareItems(items);
length = items.length;
for (; i < length; i++) {
item = items[i];
item.dock = item.dock || 'top';
if (me.border === false) {
}
if (pos !== undefined) {
me.dockedItems.insert(pos + i, item);
}
else {
me.dockedItems.add(item);
}
item.onAdded(me, i);
me.onDockedAdd(item);
}
me.componentLayout.childrenChanged = true;
if (me.rendered && !me.suspendLayout) {
me.doComponentLayout();
}
return items;
},
onDockedAdd : Ext.emptyFn,
onDockedRemove : Ext.emptyFn,
insertDocked : function(pos, items) {
this.addDocked(items, pos);
},
removeDocked : function(item, autoDestroy) {
var me = this,
layout,
hasLayout;
if (!me.dockedItems.contains(item)) {
return item;
}
layout = me.componentLayout;
hasLayout = layout && me.rendered;
if (hasLayout) {
layout.onRemove(item);
}
me.dockedItems.remove(item);
item.onRemoved();
me.onDockedRemove(item);
if (autoDestroy === true || (autoDestroy !== false && me.autoDestroy)) {
item.destroy();
}
if (hasLayout && !autoDestroy) {
layout.afterRemove(item);
}
me.componentLayout.childrenChanged = true;
if (!me.destroying && !me.suspendLayout) {
me.doComponentLayout();
}
return item;
},
getDockedItems : function(cqSelector) {
var me = this,
defaultWeight = me.defaultDockWeights,
dockedItems;
if (me.dockedItems && me.dockedItems.items.length) {
if (cqSelector) {
dockedItems = Ext.ComponentQuery.query(cqSelector, me.dockedItems.items);
} else {
dockedItems = me.dockedItems.items.slice();
}
Ext.Array.sort(dockedItems, function(a, b) {
var aw = a.weight || defaultWeight[a.dock],
bw = b.weight || defaultWeight[b.dock];
if (Ext.isNumber(aw) && Ext.isNumber(bw)) {
return aw - bw;
}
return 0;
});
return dockedItems;
}
return [];
},
addUIClsToElement: function(cls, force) {
var me = this,
result = me.callParent(arguments),
classes = [Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
array, i;
if (!force && me.rendered) {
if (me.bodyCls) {
me.body.addCls(me.bodyCls);
} else {
me.body.addCls(classes);
}
} else {
if (me.bodyCls) {
array = me.bodyCls.split(' ');
for (i = 0; i < classes.length; i++) {
if (!Ext.Array.contains(array, classes[i])) {
array.push(classes[i]);
}
}
me.bodyCls = array.join(' ');
} else {
me.bodyCls = classes.join(' ');
}
}
return result;
},
removeUIClsFromElement: function(cls, force) {
var me = this,
result = me.callParent(arguments),
classes = [Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
array, i;
if (!force && me.rendered) {
if (me.bodyCls) {
me.body.removeCls(me.bodyCls);
} else {
me.body.removeCls(classes);
}
} else {
if (me.bodyCls) {
array = me.bodyCls.split(' ');
for (i = 0; i < classes.length; i++) {
Ext.Array.remove(array, classes[i]);
}
me.bodyCls = array.join(' ');
}
}
return result;
},
addUIToElement: function(force) {
var me = this,
cls = me.baseCls + '-body-' + me.ui,
array;
me.callParent(arguments);
if (!force && me.rendered) {
if (me.bodyCls) {
me.body.addCls(me.bodyCls);
} else {
me.body.addCls(cls);
}
} else {
if (me.bodyCls) {
array = me.bodyCls.split(' ');
if (!Ext.Array.contains(array, cls)) {
array.push(cls);
}
me.bodyCls = array.join(' ');
} else {
me.bodyCls = cls;
}
}
},
removeUIFromElement: function() {
var me = this,
cls = me.baseCls + '-body-' + me.ui,
array;
me.callParent(arguments);
if (me.rendered) {
if (me.bodyCls) {
me.body.removeCls(me.bodyCls);
} else {
me.body.removeCls(cls);
}
} else {
if (me.bodyCls) {
array = me.bodyCls.split(' ');
Ext.Array.remove(array, cls);
me.bodyCls = array.join(' ');
} else {
me.bodyCls = cls;
}
}
},
getTargetEl : function() {
return this.body;
},
getRefItems: function(deep) {
var items = this.callParent(arguments),
dockedItems = this.getDockedItems(deep ? '*,* *' : undefined),
ln = dockedItems.length,
i = 0,
item;
for (; i < ln; i++) {
item = dockedItems[i];
if (item.dock === 'right' || item.dock === 'bottom') {
break;
}
}
return Ext.Array.splice(dockedItems, 0, i).concat(items).concat(dockedItems);
},
beforeDestroy: function(){
var docked = this.dockedItems,
c;
if (docked) {
while ((c = docked.first())) {
this.removeDocked(c, true);
}
}
this.callParent();
},
setBorder: function(border) {
var me = this;
me.border = (border !== undefined) ? border : true;
if (me.rendered) {
me.doComponentLayout();
}
}
});
Ext.define('Ext.panel.Header', {
extend: 'Ext.container.Container',
uses: ['Ext.panel.Tool', 'Ext.draw.Component', 'Ext.util.CSS'],
alias: 'widget.header',
isHeader : true,
defaultType : 'tool',
indicateDrag : false,
weight : -1,
renderTpl: [' {bodyCls} {parent.baseCls}-body-{parent.ui}-{.} style="{bodyStyle}" >
'],
initComponent: function() {
var me = this,
rule,
style,
titleTextEl,
ui;
me.indicateDragCls = me.baseCls + '-draggable';
me.title = me.title || ' ';
me.tools = me.tools || [];
me.items = me.items || [];
me.orientation = me.orientation || 'horizontal';
me.dock = (me.dock) ? me.dock : (me.orientation == 'horizontal') ? 'top' : 'left';
me.addClsWithUI(me.orientation);
me.addClsWithUI(me.dock);
Ext.applyIf(me.renderSelectors, {
body: '.' + me.baseCls + '-body'
});
if (!Ext.isEmpty(me.iconCls)) {
me.initIconCmp();
me.items.push(me.iconCmp);
}
if (me.orientation == 'vertical') {
if (Ext.isIE6 || Ext.isIE7) {
me.width = this.width || 24;
} else if (Ext.isIEQuirks) {
me.width = this.width || 25;
}
me.layout = {
type : 'vbox',
align: 'center',
clearInnerCtOnLayout: true,
bindToOwnerCtContainer: false
};
me.textConfig = {
cls: me.baseCls + '-text',
type: 'text',
text: me.title,
rotate: {
degrees: 90
}
};
ui = me.ui;
if (Ext.isArray(ui)) {
ui = ui[0];
}
rule = Ext.util.CSS.getRule('.' + me.baseCls + '-text-' + ui);
if (rule) {
style = rule.style;
}
if (style) {
Ext.apply(me.textConfig, {
'font-family': style.fontFamily,
'font-weight': style.fontWeight,
'font-size': style.fontSize,
fill: style.color
});
}
me.titleCmp = Ext.create('Ext.draw.Component', {
ariaRole : 'heading',
focusable: false,
viewBox: false,
flex : 1,
autoSize: true,
margins: '5 0 0 0',
items: [ me.textConfig ],
renderSelectors: {
textEl: '.' + me.baseCls + '-text'
}
});
} else {
me.layout = {
type : 'hbox',
align: 'middle',
clearInnerCtOnLayout: true,
bindToOwnerCtContainer: false
};
me.titleCmp = Ext.create('Ext.Component', {
xtype : 'component',
ariaRole : 'heading',
focusable: false,
flex : 1,
renderTpl : ['{title} '],
renderData: {
title: me.title,
cls : me.baseCls,
ui : me.ui
},
renderSelectors: {
textEl: '.' + me.baseCls + '-text'
}
});
}
me.items.push(me.titleCmp);
me.items = me.items.concat(me.tools);
this.callParent();
},
initIconCmp: function() {
this.iconCmp = Ext.create('Ext.Component', {
focusable: false,
renderTpl : ['= this.minX; i = i - iTickSize) {
if (!tickMap[i]) {
this.xTicks[this.xTicks.length] = i;
tickMap[i] = true;
}
}
for (i = this.initPageX; i <= this.maxX; i = i + iTickSize) {
if (!tickMap[i]) {
this.xTicks[this.xTicks.length] = i;
tickMap[i] = true;
}
}
Ext.Array.sort(this.xTicks, this.DDMInstance.numericSort);
},
setYTicks: function(iStartY, iTickSize) {
this.yTicks = [];
this.yTickSize = iTickSize;
var tickMap = {};
for (var i = this.initPageY; i >= this.minY; i = i - iTickSize) {
if (!tickMap[i]) {
this.yTicks[this.yTicks.length] = i;
tickMap[i] = true;
}
}
for (i = this.initPageY; i <= this.maxY; i = i + iTickSize) {
if (!tickMap[i]) {
this.yTicks[this.yTicks.length] = i;
tickMap[i] = true;
}
}
Ext.Array.sort(this.yTicks, this.DDMInstance.numericSort);
},
setXConstraint: function(iLeft, iRight, iTickSize) {
this.leftConstraint = iLeft;
this.rightConstraint = iRight;
this.minX = this.initPageX - iLeft;
this.maxX = this.initPageX + iRight;
if (iTickSize) { this.setXTicks(this.initPageX, iTickSize); }
this.constrainX = true;
},
clearConstraints: function() {
this.constrainX = false;
this.constrainY = false;
this.clearTicks();
},
clearTicks: function() {
this.xTicks = null;
this.yTicks = null;
this.xTickSize = 0;
this.yTickSize = 0;
},
setYConstraint: function(iUp, iDown, iTickSize) {
this.topConstraint = iUp;
this.bottomConstraint = iDown;
this.minY = this.initPageY - iUp;
this.maxY = this.initPageY + iDown;
if (iTickSize) { this.setYTicks(this.initPageY, iTickSize); }
this.constrainY = true;
},
resetConstraints: function() {
if (this.initPageX || this.initPageX === 0) {
var dx = (this.maintainOffset) ? this.lastPageX - this.initPageX : 0;
var dy = (this.maintainOffset) ? this.lastPageY - this.initPageY : 0;
this.setInitPosition(dx, dy);
} else {
this.setInitPosition();
}
if (this.constrainX) {
this.setXConstraint( this.leftConstraint,
this.rightConstraint,
this.xTickSize );
}
if (this.constrainY) {
this.setYConstraint( this.topConstraint,
this.bottomConstraint,
this.yTickSize );
}
},
getTick: function(val, tickArray) {
if (!tickArray) {
return val;
} else if (tickArray[0] >= val) {
return tickArray[0];
} else {
for (var i=0, len=tickArray.length; i= val) {
var diff1 = val - tickArray[i];
var diff2 = tickArray[next] - val;
return (diff2 > diff1) ? tickArray[i] : tickArray[next];
}
}
return tickArray[tickArray.length - 1];
}
},
toString: function() {
return ("DragDrop " + this.id);
}
});
Ext.define('Ext.dd.DD', {
extend: 'Ext.dd.DragDrop',
requires: ['Ext.dd.DragDropManager'],
constructor: function(id, sGroup, config) {
if (id) {
this.init(id, sGroup, config);
}
},
scroll: true,
autoOffset: function(iPageX, iPageY) {
var x = iPageX - this.startPageX;
var y = iPageY - this.startPageY;
this.setDelta(x, y);
},
setDelta: function(iDeltaX, iDeltaY) {
this.deltaX = iDeltaX;
this.deltaY = iDeltaY;
},
setDragElPos: function(iPageX, iPageY) {
var el = this.getDragEl();
this.alignElWithMouse(el, iPageX, iPageY);
},
alignElWithMouse: function(el, iPageX, iPageY) {
var oCoord = this.getTargetCoord(iPageX, iPageY),
fly = el.dom ? el : Ext.fly(el, '_dd'),
elSize = fly.getSize(),
EL = Ext.core.Element,
vpSize;
if (!this.deltaSetXY) {
vpSize = this.cachedViewportSize = { width: EL.getDocumentWidth(), height: EL.getDocumentHeight() };
var aCoord = [
Math.max(0, Math.min(oCoord.x, vpSize.width - elSize.width)),
Math.max(0, Math.min(oCoord.y, vpSize.height - elSize.height))
];
fly.setXY(aCoord);
var newLeft = fly.getLeft(true);
var newTop = fly.getTop(true);
this.deltaSetXY = [newLeft - oCoord.x, newTop - oCoord.y];
} else {
vpSize = this.cachedViewportSize;
fly.setLeftTop(
Math.max(0, Math.min(oCoord.x + this.deltaSetXY[0], vpSize.width - elSize.width)),
Math.max(0, Math.min(oCoord.y + this.deltaSetXY[1], vpSize.height - elSize.height))
);
}
this.cachePosition(oCoord.x, oCoord.y);
this.autoScroll(oCoord.x, oCoord.y, el.offsetHeight, el.offsetWidth);
return oCoord;
},
cachePosition: function(iPageX, iPageY) {
if (iPageX) {
this.lastPageX = iPageX;
this.lastPageY = iPageY;
} else {
var aCoord = Ext.core.Element.getXY(this.getEl());
this.lastPageX = aCoord[0];
this.lastPageY = aCoord[1];
}
},
autoScroll: function(x, y, h, w) {
if (this.scroll) {
var clientH = Ext.core.Element.getViewHeight();
var clientW = Ext.core.Element.getViewWidth();
var st = this.DDMInstance.getScrollTop();
var sl = this.DDMInstance.getScrollLeft();
var bot = h + y;
var right = w + x;
var toBot = (clientH + st - y - this.deltaY);
var toRight = (clientW + sl - x - this.deltaX);
var thresh = 40;
var scrAmt = (document.all) ? 80 : 30;
if ( bot > clientH && toBot < thresh ) {
window.scrollTo(sl, st + scrAmt);
}
if ( y < st && st > 0 && y - st < thresh ) {
window.scrollTo(sl, st - scrAmt);
}
if ( right > clientW && toRight < thresh ) {
window.scrollTo(sl + scrAmt, st);
}
if ( x < sl && sl > 0 && x - sl < thresh ) {
window.scrollTo(sl - scrAmt, st);
}
}
},
getTargetCoord: function(iPageX, iPageY) {
var x = iPageX - this.deltaX;
var y = iPageY - this.deltaY;
if (this.constrainX) {
if (x < this.minX) {
x = this.minX;
}
if (x > this.maxX) {
x = this.maxX;
}
}
if (this.constrainY) {
if (y < this.minY) {
y = this.minY;
}
if (y > this.maxY) {
y = this.maxY;
}
}
x = this.getTick(x, this.xTicks);
y = this.getTick(y, this.yTicks);
return {x: x, y: y};
},
applyConfig: function() {
this.callParent();
this.scroll = (this.config.scroll !== false);
},
b4MouseDown: function(e) {
this.autoOffset(e.getPageX(), e.getPageY());
},
b4Drag: function(e) {
this.setDragElPos(e.getPageX(), e.getPageY());
},
toString: function() {
return ("DD " + this.id);
}
});
Ext.define('Ext.dd.DDProxy', {
extend: 'Ext.dd.DD',
statics: {
dragElId: "ygddfdiv"
},
constructor: function(id, sGroup, config) {
if (id) {
this.init(id, sGroup, config);
this.initFrame();
}
},
resizeFrame: true,
centerFrame: false,
createFrame: function() {
var self = this;
var body = document.body;
if (!body || !body.firstChild) {
setTimeout( function() { self.createFrame(); }, 50 );
return;
}
var div = this.getDragEl();
if (!div) {
div = document.createElement("div");
div.id = this.dragElId;
var s = div.style;
s.position = "absolute";
s.visibility = "hidden";
s.cursor = "move";
s.border = "2px solid #aaa";
s.zIndex = 999;
body.insertBefore(div, body.firstChild);
}
},
initFrame: function() {
this.createFrame();
},
applyConfig: function() {
this.callParent();
this.resizeFrame = (this.config.resizeFrame !== false);
this.centerFrame = (this.config.centerFrame);
this.setDragElId(this.config.dragElId || Ext.dd.DDProxy.dragElId);
},
showFrame: function(iPageX, iPageY) {
var el = this.getEl();
var dragEl = this.getDragEl();
var s = dragEl.style;
this._resizeProxy();
if (this.centerFrame) {
this.setDelta( Math.round(parseInt(s.width, 10)/2),
Math.round(parseInt(s.height, 10)/2) );
}
this.setDragElPos(iPageX, iPageY);
Ext.fly(dragEl).show();
},
_resizeProxy: function() {
if (this.resizeFrame) {
var el = this.getEl();
Ext.fly(this.getDragEl()).setSize(el.offsetWidth, el.offsetHeight);
}
},
b4MouseDown: function(e) {
var x = e.getPageX();
var y = e.getPageY();
this.autoOffset(x, y);
this.setDragElPos(x, y);
},
b4StartDrag: function(x, y) {
this.showFrame(x, y);
},
b4EndDrag: function(e) {
Ext.fly(this.getDragEl()).hide();
},
endDrag: function(e) {
var lel = this.getEl();
var del = this.getDragEl();
del.style.visibility = "";
this.beforeMove();
lel.style.visibility = "hidden";
Ext.dd.DDM.moveToEl(lel, del);
del.style.visibility = "hidden";
lel.style.visibility = "";
this.afterDrag();
},
beforeMove : function(){
},
afterDrag : function(){
},
toString: function() {
return ("DDProxy " + this.id);
}
});
Ext.define('Ext.dd.DragSource', {
extend: 'Ext.dd.DDProxy',
requires: [
'Ext.dd.StatusProxy',
'Ext.dd.DragDropManager'
],
dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
animRepair: true,
repairHighlightColor: 'c3daf9',
constructor: function(el, config) {
this.el = Ext.get(el);
if(!this.dragData){
this.dragData = {};
}
Ext.apply(this, config);
if(!this.proxy){
this.proxy = Ext.create('Ext.dd.StatusProxy', {
animRepair: this.animRepair
});
}
this.callParent([this.el.dom, this.ddGroup || this.group,
{dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true}]);
this.dragging = false;
},
getDragData : function(e){
return this.dragData;
},
onDragEnter : function(e, id){
var target = Ext.dd.DragDropManager.getDDById(id);
this.cachedTarget = target;
if (this.beforeDragEnter(target, e, id) !== false) {
if (target.isNotifyTarget) {
var status = target.notifyEnter(this, e, this.dragData);
this.proxy.setStatus(status);
} else {
this.proxy.setStatus(this.dropAllowed);
}
if (this.afterDragEnter) {
this.afterDragEnter(target, e, id);
}
}
},
beforeDragEnter: function(target, e, id) {
return true;
},
alignElWithMouse: function() {
this.callParent(arguments);
this.proxy.sync();
},
onDragOver: function(e, id) {
var target = this.cachedTarget || Ext.dd.DragDropManager.getDDById(id);
if (this.beforeDragOver(target, e, id) !== false) {
if(target.isNotifyTarget){
var status = target.notifyOver(this, e, this.dragData);
this.proxy.setStatus(status);
}
if (this.afterDragOver) {
this.afterDragOver(target, e, id);
}
}
},
beforeDragOver: function(target, e, id) {
return true;
},
onDragOut: function(e, id) {
var target = this.cachedTarget || Ext.dd.DragDropManager.getDDById(id);
if (this.beforeDragOut(target, e, id) !== false) {
if (target.isNotifyTarget) {
target.notifyOut(this, e, this.dragData);
}
this.proxy.reset();
if (this.afterDragOut) {
this.afterDragOut(target, e, id);
}
}
this.cachedTarget = null;
},
beforeDragOut: function(target, e, id){
return true;
},
onDragDrop: function(e, id){
var target = this.cachedTarget || Ext.dd.DragDropManager.getDDById(id);
if (this.beforeDragDrop(target, e, id) !== false) {
if (target.isNotifyTarget) {
if (target.notifyDrop(this, e, this.dragData) !== false) {
this.onValidDrop(target, e, id);
} else {
this.onInvalidDrop(target, e, id);
}
} else {
this.onValidDrop(target, e, id);
}
if (this.afterDragDrop) {
this.afterDragDrop(target, e, id);
}
}
delete this.cachedTarget;
},
beforeDragDrop: function(target, e, id){
return true;
},
onValidDrop: function(target, e, id){
this.hideProxy();
if(this.afterValidDrop){
this.afterValidDrop(target, e, id);
}
},
getRepairXY: function(e, data){
return this.el.getXY();
},
onInvalidDrop: function(target, e, id) {
this.beforeInvalidDrop(target, e, id);
if (this.cachedTarget) {
if(this.cachedTarget.isNotifyTarget){
this.cachedTarget.notifyOut(this, e, this.dragData);
}
this.cacheTarget = null;
}
this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this);
if (this.afterInvalidDrop) {
this.afterInvalidDrop(e, id);
}
},
afterRepair: function() {
var me = this;
if (Ext.enableFx) {
me.el.highlight(me.repairHighlightColor);
}
me.dragging = false;
},
beforeInvalidDrop: function(target, e, id) {
return true;
},
handleMouseDown: function(e) {
if (this.dragging) {
return;
}
var data = this.getDragData(e);
if (data && this.onBeforeDrag(data, e) !== false) {
this.dragData = data;
this.proxy.stop();
this.callParent(arguments);
}
},
onBeforeDrag: function(data, e){
return true;
},
onStartDrag: Ext.emptyFn,
startDrag: function(x, y) {
this.proxy.reset();
this.dragging = true;
this.proxy.update("");
this.onInitDrag(x, y);
this.proxy.show();
},
onInitDrag: function(x, y) {
var clone = this.el.dom.cloneNode(true);
clone.id = Ext.id();
this.proxy.update(clone);
this.onStartDrag(x, y);
return true;
},
getProxy: function() {
return this.proxy;
},
hideProxy: function() {
this.proxy.hide();
this.proxy.reset(true);
this.dragging = false;
},
triggerCacheRefresh: function() {
Ext.dd.DDM.refreshCache(this.groups);
},
b4EndDrag: function(e) {
},
endDrag : function(e){
this.onEndDrag(this.dragData, e);
},
onEndDrag : function(data, e){
},
autoOffset : function(x, y) {
this.setDelta(-12, -20);
},
destroy: function(){
this.callParent();
Ext.destroy(this.proxy);
}
});
Ext.define('Ext.panel.DD', {
extend: 'Ext.dd.DragSource',
requires: ['Ext.panel.Proxy'],
constructor : function(panel, cfg){
this.panel = panel;
this.dragData = {panel: panel};
this.proxy = Ext.create('Ext.panel.Proxy', panel, cfg);
this.callParent([panel.el, cfg]);
Ext.defer(function() {
var header = panel.header,
el = panel.body;
if(header){
this.setHandleElId(header.id);
el = header.el;
}
el.setStyle('cursor', 'move');
this.scroll = false;
}, 200, this);
},
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.el.dom;
},
endDrag : function(e){
this.proxy.hide();
this.panel.saveState();
},
autoOffset : function(x, y) {
x -= this.startPageX;
y -= this.startPageY;
this.setDelta(x, y);
}
});
Ext.define('Ext.layout.component.Dock', {
alias: ['layout.dock'],
extend: 'Ext.layout.component.AbstractDock'
});
Ext.define('Ext.panel.Panel', {
extend: 'Ext.panel.AbstractPanel',
requires: [
'Ext.panel.Header',
'Ext.fx.Anim',
'Ext.util.KeyMap',
'Ext.panel.DD',
'Ext.XTemplate',
'Ext.layout.component.Dock',
'Ext.util.Memento'
],
alias: 'widget.panel',
alternateClassName: 'Ext.Panel',
collapsedCls: 'collapsed',
animCollapse: Ext.enableFx,
minButtonWidth: 75,
collapsed: false,
collapseFirst: true,
hideCollapseTool: false,
titleCollapse: false,
floatable: true,
collapsible: false,
closable: false,
closeAction: 'destroy',
preventHeader: false,
headerPosition: 'top',
frame: false,
frameHeader: true,
initComponent: function() {
var me = this,
cls;
me.addEvents(
"beforeexpand",
"beforecollapse",
"expand",
"collapse",
'titlechange',
'iconchange'
);
this.addStateEvents('expand', 'collapse');
if (me.unstyled) {
me.setUI('plain');
}
if (me.frame) {
me.setUI(me.ui + '-framed');
}
me.callParent();
me.collapseDirection = me.collapseDirection || me.headerPosition || Ext.Component.DIRECTION_TOP;
me.bridgeToolbars();
},
setBorder: function(border) {
this.callParent(arguments);
},
beforeDestroy: function() {
Ext.destroy(
this.ghostPanel,
this.dd
);
this.callParent();
},
initAria: function() {
this.callParent();
this.initHeaderAria();
},
initHeaderAria: function() {
var me = this,
el = me.el,
header = me.header;
if (el && header) {
el.dom.setAttribute('aria-labelledby', header.titleCmp.id);
}
},
getHeader: function() {
return this.header;
},
setTitle: function(newTitle) {
var me = this,
oldTitle = this.title;
me.title = newTitle;
if (me.header) {
me.header.setTitle(newTitle);
} else {
me.updateHeader();
}
if (me.reExpander) {
me.reExpander.setTitle(newTitle);
}
me.fireEvent('titlechange', me, newTitle, oldTitle);
},
setIconCls: function(newIconCls) {
var me = this,
oldIconCls = me.iconCls;
me.iconCls = newIconCls;
var header = me.header;
if (header) {
header.setIconCls(newIconCls);
}
me.fireEvent('iconchange', me, newIconCls, oldIconCls);
},
bridgeToolbars: function() {
var me = this,
fbar,
fbarDefaults,
minButtonWidth = me.minButtonWidth;
function initToolbar (toolbar, pos, useButtonAlign) {
if (Ext.isArray(toolbar)) {
toolbar = {
xtype: 'toolbar',
items: toolbar
};
}
else if (!toolbar.xtype) {
toolbar.xtype = 'toolbar';
}
toolbar.dock = pos;
if (pos == 'left' || pos == 'right') {
toolbar.vertical = true;
}
if (useButtonAlign) {
toolbar.layout = Ext.applyIf(toolbar.layout || {}, {
pack: { left:'start', center:'center' }[me.buttonAlign] || 'end'
});
}
return toolbar;
}
if (me.tbar) {
me.addDocked(initToolbar(me.tbar, 'top'));
me.tbar = null;
}
if (me.bbar) {
me.addDocked(initToolbar(me.bbar, 'bottom'));
me.bbar = null;
}
if (me.buttons) {
me.fbar = me.buttons;
me.buttons = null;
}
if (me.fbar) {
fbar = initToolbar(me.fbar, 'bottom', true);
fbar.ui = 'footer';
if (minButtonWidth) {
fbarDefaults = fbar.defaults;
fbar.defaults = function(config) {
var defaults = fbarDefaults || {};
if ((!config.xtype || config.xtype === 'button' || (config.isComponent && config.isXType('button'))) &&
!('minWidth' in defaults)) {
defaults = Ext.apply({minWidth: minButtonWidth}, defaults);
}
return defaults;
};
}
me.addDocked(fbar);
me.fbar = null;
}
if (me.lbar) {
me.addDocked(initToolbar(me.lbar, 'left'));
me.lbar = null;
}
if (me.rbar) {
me.addDocked(initToolbar(me.rbar, 'right'));
me.rbar = null;
}
},
initTools: function() {
var me = this;
me.tools = me.tools || [];
if (me.collapsible && !(me.hideCollapseTool || me.header === false)) {
me.collapseDirection = me.collapseDirection || me.headerPosition || 'top';
me.collapseTool = me.expandTool = me.createComponent({
xtype: 'tool',
type: 'collapse-' + me.collapseDirection,
expandType: me.getOppositeDirection(me.collapseDirection),
handler: me.toggleCollapse,
scope: me
});
if (me.collapseFirst) {
me.tools.unshift(me.collapseTool);
}
}
me.addTools();
if (me.closable) {
me.addClsWithUI('closable');
me.addTool({
type: 'close',
handler: Ext.Function.bind(me.close, this, [])
});
}
if (me.collapseTool && !me.collapseFirst) {
me.tools.push(me.collapseTool);
}
},
addTools: Ext.emptyFn,
close: function() {
if (this.fireEvent('beforeclose', this) !== false) {
this.doClose();
}
},
doClose: function() {
this.fireEvent('close', this);
this[this.closeAction]();
},
onRender: function(ct, position) {
var me = this,
topContainer;
me.initTools();
me.updateHeader();
me.callParent(arguments);
},
afterComponentLayout: function() {
var me = this;
me.callParent(arguments);
if (me.collapsed && me.componentLayoutCounter == 1) {
me.collapsed = false;
me.collapse(null, false, true);
}
},
updateHeader: function(force) {
var me = this,
header = me.header,
title = me.title,
tools = me.tools;
if (!me.preventHeader && (force || title || (tools && tools.length))) {
if (!header) {
header = me.header = Ext.create('Ext.panel.Header', {
title : title,
orientation : (me.headerPosition == 'left' || me.headerPosition == 'right') ? 'vertical' : 'horizontal',
dock : me.headerPosition || 'top',
textCls : me.headerTextCls,
iconCls : me.iconCls,
baseCls : me.baseCls + '-header',
tools : tools,
ui : me.ui,
indicateDrag: me.draggable,
border : me.border,
frame : me.frame && me.frameHeader,
ignoreParentFrame : me.frame || me.overlapHeader,
ignoreBorderManagement: me.frame || me.ignoreHeaderBorderManagement,
listeners : me.collapsible && me.titleCollapse ? {
click: me.toggleCollapse,
scope: me
} : null
});
me.addDocked(header, 0);
me.tools = header.tools;
}
header.show();
me.initHeaderAria();
} else if (header) {
header.hide();
}
},
setUI: function(ui) {
var me = this;
me.callParent(arguments);
if (me.header) {
me.header.setUI(ui);
}
},
getContentTarget: function() {
return this.body;
},
getTargetEl: function() {
return this.body || this.frameBody || this.el;
},
addTool: function(tool) {
this.tools.push(tool);
var header = this.header;
if (header) {
header.addTool(tool);
}
this.updateHeader();
},
getOppositeDirection: function(d) {
var c = Ext.Component;
switch (d) {
case c.DIRECTION_TOP:
return c.DIRECTION_BOTTOM;
case c.DIRECTION_RIGHT:
return c.DIRECTION_LEFT;
case c.DIRECTION_BOTTOM:
return c.DIRECTION_TOP;
case c.DIRECTION_LEFT:
return c.DIRECTION_RIGHT;
}
},
collapse: function(direction, animate, internal) {
var me = this,
c = Ext.Component,
height = me.getHeight(),
width = me.getWidth(),
frameInfo,
newSize = 0,
dockedItems = me.dockedItems.items,
dockedItemCount = dockedItems.length,
i = 0,
comp,
pos,
anim = {
from: {
height: height,
width: width
},
to: {
height: height,
width: width
},
listeners: {
afteranimate: me.afterCollapse,
scope: me
},
duration: Ext.Number.from(animate, Ext.fx.Anim.prototype.duration)
},
reExpander,
reExpanderOrientation,
reExpanderDock,
getDimension,
setDimension,
collapseDimension;
if (!direction) {
direction = me.collapseDirection;
}
if (internal) {
animate = false;
} else if (me.collapsed || me.fireEvent('beforecollapse', me, direction, animate) === false) {
return false;
}
reExpanderDock = direction;
me.expandDirection = me.getOppositeDirection(direction);
me.hiddenDocked = [];
switch (direction) {
case c.DIRECTION_TOP:
case c.DIRECTION_BOTTOM:
me.expandedSize = me.getHeight();
reExpanderOrientation = 'horizontal';
collapseDimension = 'height';
getDimension = 'getHeight';
setDimension = 'setHeight';
for (; i < dockedItemCount; i++) {
comp = dockedItems[i];
if (comp.isVisible()) {
if (comp.isHeader && (!comp.dock || comp.dock == 'top' || comp.dock == 'bottom')) {
reExpander = comp;
} else {
me.hiddenDocked.push(comp);
}
}
}
if (direction == Ext.Component.DIRECTION_BOTTOM) {
pos = me.getPosition()[1] - Ext.fly(me.el.dom.offsetParent).getRegion().top;
anim.from.top = pos;
}
break;
case c.DIRECTION_LEFT:
case c.DIRECTION_RIGHT:
me.expandedSize = me.getWidth();
reExpanderOrientation = 'vertical';
collapseDimension = 'width';
getDimension = 'getWidth';
setDimension = 'setWidth';
for (; i < dockedItemCount; i++) {
comp = dockedItems[i];
if (comp.isVisible()) {
if (comp.isHeader && (comp.dock == 'left' || comp.dock == 'right')) {
reExpander = comp;
} else {
me.hiddenDocked.push(comp);
}
}
}
if (direction == Ext.Component.DIRECTION_RIGHT) {
pos = me.getPosition()[0] - Ext.fly(me.el.dom.offsetParent).getRegion().left;
anim.from.left = pos;
}
break;
default:
throw('Panel collapse must be passed a valid Component collapse direction');
}
me.setAutoScroll(false);
me.suspendLayout = true;
me.body.setVisibilityMode(Ext.core.Element.DISPLAY);
if (animate && me.collapseTool) {
me.collapseTool.disable();
}
me.addClsWithUI(me.collapsedCls);
if (reExpander) {
reExpander.addClsWithUI(me.collapsedCls);
reExpander.addClsWithUI(me.collapsedCls + '-' + reExpander.dock);
if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) {
reExpander.addClsWithUI(me.collapsedCls + '-border-' + reExpander.dock);
}
frameInfo = reExpander.getFrameInfo();
newSize = reExpander[getDimension]() + (frameInfo ? frameInfo[direction] : 0);
reExpander.removeClsWithUI(me.collapsedCls);
reExpander.removeClsWithUI(me.collapsedCls + '-' + reExpander.dock);
if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) {
reExpander.removeClsWithUI(me.collapsedCls + '-border-' + reExpander.dock);
}
}
else {
reExpander = {
hideMode: 'offsets',
temporary: true,
title: me.title,
orientation: reExpanderOrientation,
dock: reExpanderDock,
textCls: me.headerTextCls,
iconCls: me.iconCls,
baseCls: me.baseCls + '-header',
ui: me.ui,
frame: me.frame && me.frameHeader,
ignoreParentFrame: me.frame || me.overlapHeader,
indicateDrag: me.draggable,
cls: me.baseCls + '-collapsed-placeholder ' + ' ' + Ext.baseCSSPrefix + 'docked ' + me.baseCls + '-' + me.ui + '-collapsed',
renderTo: me.el
};
if (!me.hideCollapseTool) {
reExpander[(reExpander.orientation == 'horizontal') ? 'tools' : 'items'] = [{
xtype: 'tool',
type: 'expand-' + me.expandDirection,
handler: me.toggleCollapse,
scope: me
}];
}
reExpander = me.reExpander = Ext.create('Ext.panel.Header', reExpander);
newSize = reExpander[getDimension]() + ((reExpander.frame) ? reExpander.frameSize[direction] : 0);
reExpander.hide();
me.insertDocked(0, reExpander);
}
me.reExpander = reExpander;
me.reExpander.addClsWithUI(me.collapsedCls);
me.reExpander.addClsWithUI(me.collapsedCls + '-' + reExpander.dock);
if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) {
me.reExpander.addClsWithUI(me.collapsedCls + '-border-' + me.reExpander.dock);
}
if (direction == Ext.Component.DIRECTION_RIGHT) {
anim.to.left = pos + (width - newSize);
} else if (direction == Ext.Component.DIRECTION_BOTTOM) {
anim.to.top = pos + (height - newSize);
}
anim.to[collapseDimension] = newSize;
if (!me.collapseMemento) {
me.collapseMemento = new Ext.util.Memento(me);
}
me.collapseMemento.capture(['width', 'height', 'minWidth', 'minHeight']);
me.savedFlex = me.flex;
me.minWidth = 0;
me.minHeight = 0;
delete me.flex;
if (animate) {
me.animate(anim);
} else {
me.setSize(anim.to.width, anim.to.height);
if (Ext.isDefined(anim.to.left) || Ext.isDefined(anim.to.top)) {
me.setPosition(anim.to.left, anim.to.top);
}
me.afterCollapse(false, internal);
}
return me;
},
afterCollapse: function(animated, internal) {
var me = this,
i = 0,
l = me.hiddenDocked.length;
me.collapseMemento.restore(['minWidth', 'minHeight']);
me.body.hide();
for (; i < l; i++) {
me.hiddenDocked[i].hide();
}
if (me.reExpander) {
me.reExpander.updateFrame();
me.reExpander.show();
}
me.collapsed = true;
if (!internal) {
me.doComponentLayout();
}
if (me.resizer) {
me.resizer.disable();
}
if (Ext.Component.VERTICAL_DIRECTION.test(me.expandDirection)) {
me.collapseMemento.restore('width');
} else {
me.collapseMemento.restore('height');
}
if (me.collapseTool) {
me.collapseTool.setType('expand-' + me.expandDirection);
}
if (!internal) {
me.fireEvent('collapse', me);
}
if (animated && me.collapseTool) {
me.collapseTool.enable();
}
},
expand: function(animate) {
var me = this;
if (!me.collapsed || me.fireEvent('beforeexpand', me, animate) === false) {
return false;
}
var i = 0,
l = me.hiddenDocked.length,
direction = me.expandDirection,
height = me.getHeight(),
width = me.getWidth(),
pos, anim;
if (animate && me.collapseTool) {
me.collapseTool.disable();
}
for (; i < l; i++) {
me.hiddenDocked[i].hidden = false;
me.hiddenDocked[i].el.show();
}
if (me.reExpander) {
if (me.reExpander.temporary) {
me.reExpander.hide();
} else {
me.reExpander.removeClsWithUI(me.collapsedCls);
me.reExpander.removeClsWithUI(me.collapsedCls + '-' + me.reExpander.dock);
if (me.border && (!me.frame || (me.frame && Ext.supports.CSS3BorderRadius))) {
me.reExpander.removeClsWithUI(me.collapsedCls + '-border-' + me.reExpander.dock);
}
me.reExpander.updateFrame();
}
}
if (me.collapseTool) {
me.collapseTool.setType('collapse-' + me.collapseDirection);
}
me.collapsed = false;
me.body.show();
me.removeClsWithUI(me.collapsedCls);
anim = {
to: {
},
from: {
height: height,
width: width
},
listeners: {
afteranimate: me.afterExpand,
scope: me
}
};
if ((direction == Ext.Component.DIRECTION_TOP) || (direction == Ext.Component.DIRECTION_BOTTOM)) {
if (me.autoHeight) {
me.setCalculatedSize(me.width, null);
anim.to.height = me.getHeight();
me.setCalculatedSize(me.width, anim.from.height);
}
else if (me.savedFlex) {
me.flex = me.savedFlex;
anim.to.height = me.ownerCt.layout.calculateChildBox(me).height;
delete me.flex;
}
else {
anim.to.height = me.expandedSize;
}
if (direction == Ext.Component.DIRECTION_TOP) {
pos = me.getPosition()[1] - Ext.fly(me.el.dom.offsetParent).getRegion().top;
anim.from.top = pos;
anim.to.top = pos - (anim.to.height - height);
}
} else if ((direction == Ext.Component.DIRECTION_LEFT) || (direction == Ext.Component.DIRECTION_RIGHT)) {
if (me.autoWidth) {
me.setCalculatedSize(null, me.height);
anim.to.width = me.getWidth();
me.setCalculatedSize(anim.from.width, me.height);
}
else if (me.savedFlex) {
me.flex = me.savedFlex;
anim.to.width = me.ownerCt.layout.calculateChildBox(me).width;
delete me.flex;
}
else {
anim.to.width = me.expandedSize;
}
if (direction == Ext.Component.DIRECTION_LEFT) {
pos = me.getPosition()[0] - Ext.fly(me.el.dom.offsetParent).getRegion().left;
anim.from.left = pos;
anim.to.left = pos - (anim.to.width - width);
}
}
if (animate) {
me.animate(anim);
} else {
me.setCalculatedSize(anim.to.width, anim.to.height);
if (anim.to.x) {
me.setLeft(anim.to.x);
}
if (anim.to.y) {
me.setTop(anim.to.y);
}
me.afterExpand(false);
}
return me;
},
afterExpand: function(animated) {
var me = this;
if (me.collapseMemento) {
me.collapseMemento.restoreAll();
}
me.setAutoScroll(me.initialConfig.autoScroll);
if (me.savedFlex) {
me.flex = me.savedFlex;
delete me.savedFlex;
delete me.width;
delete me.height;
}
delete me.suspendLayout;
if (animated && me.ownerCt) {
Ext.defer(me.ownerCt.doLayout, Ext.isIE6 ? 1 : 0, me);
}
if (me.resizer) {
me.resizer.enable();
}
me.fireEvent('expand', me);
if (animated && me.collapseTool) {
me.collapseTool.enable();
}
},
toggleCollapse: function() {
if (this.collapsed) {
this.expand(this.animCollapse);
} else {
this.collapse(this.collapseDirection, this.animCollapse);
}
return this;
},
getKeyMap : function(){
if(!this.keyMap){
this.keyMap = Ext.create('Ext.util.KeyMap', this.el, this.keys);
}
return this.keyMap;
},
initDraggable : function(){
this.dd = Ext.create('Ext.panel.DD', this, Ext.isBoolean(this.draggable) ? null : this.draggable);
},
ghostTools : function() {
var tools = [],
origTools = this.initialConfig.tools;
if (origTools) {
Ext.each(origTools, function(tool) {
tools.push({
type: tool.type
});
});
}
else {
tools = [{
type: 'placeholder'
}];
}
return tools;
},
ghost: function(cls) {
var me = this,
ghostPanel = me.ghostPanel,
box = me.getBox();
if (!ghostPanel) {
ghostPanel = Ext.create('Ext.panel.Panel', {
renderTo: document.body,
floating: {
shadow: false
},
frame: Ext.supports.CSS3BorderRadius ? me.frame : false,
title: me.title,
overlapHeader: me.overlapHeader,
headerPosition: me.headerPosition,
width: me.getWidth(),
height: me.getHeight(),
iconCls: me.iconCls,
baseCls: me.baseCls,
tools: me.ghostTools(),
cls: me.baseCls + '-ghost ' + (cls ||'')
});
me.ghostPanel = ghostPanel;
}
ghostPanel.floatParent = me.floatParent;
if (me.floating) {
ghostPanel.setZIndex(Ext.Number.from(me.el.getStyle('zIndex'), 0));
} else {
ghostPanel.toFront();
}
ghostPanel.el.show();
ghostPanel.setPosition(box.x, box.y);
ghostPanel.setSize(box.width, box.height);
me.el.hide();
if (me.floatingItems) {
me.floatingItems.hide();
}
return ghostPanel;
},
unghost: function(show, matchPosition) {
var me = this;
if (!me.ghostPanel) {
return;
}
if (show !== false) {
me.el.show();
if (matchPosition !== false) {
me.setPosition(me.ghostPanel.getPosition());
}
if (me.floatingItems) {
me.floatingItems.show();
}
Ext.defer(me.focus, 10, me);
}
me.ghostPanel.el.hide();
},
initResizable: function(resizable) {
if (this.collapsed) {
resizable.disabled = true;
}
this.callParent([resizable]);
}
});
Ext.define('Ext.layout.component.Tip', {
alias: ['layout.tip'],
extend: 'Ext.layout.component.Dock',
type: 'tip',
onLayout: function(width, height) {
var me = this,
owner = me.owner,
el = owner.el,
minWidth,
maxWidth,
naturalWidth,
constrainedWidth,
xy = el.getXY();
el.setXY([-9999,-9999]);
this.callParent(arguments);
if (!Ext.isNumber(width)) {
minWidth = owner.minWidth;
maxWidth = owner.maxWidth;
if (Ext.isStrict && (Ext.isIE6 || Ext.isIE7)) {
constrainedWidth = me.doAutoWidth();
} else {
naturalWidth = el.getWidth();
}
if (naturalWidth < minWidth) {
constrainedWidth = minWidth;
}
else if (naturalWidth > maxWidth) {
constrainedWidth = maxWidth;
}
if (constrainedWidth) {
this.callParent([constrainedWidth, height]);
}
}
el.setXY(xy);
},
doAutoWidth: function(){
var me = this,
owner = me.owner,
body = owner.body,
width = body.getTextWidth();
if (owner.header) {
width = Math.max(width, owner.header.getWidth());
}
if (!Ext.isDefined(me.frameWidth)) {
me.frameWidth = owner.el.getWidth() - body.getWidth();
}
width += me.frameWidth + body.getPadding('lr');
return width;
}
});
Ext.define('Ext.tip.Tip', {
extend: 'Ext.panel.Panel',
requires: [ 'Ext.layout.component.Tip' ],
alternateClassName: 'Ext.Tip',
minWidth : 40,
maxWidth : 300,
shadow : "sides",
defaultAlign : "tl-bl?",
constrainPosition : true,
frame: false,
autoRender: true,
hidden: true,
baseCls: Ext.baseCSSPrefix + 'tip',
floating: {
shadow: true,
shim: true,
constrain: true
},
focusOnToFront: false,
componentLayout: 'tip',
closeAction: 'hide',
ariaRole: 'tooltip',
initComponent: function() {
this.callParent(arguments);
this.constrain = this.constrain || this.constrainPosition;
},
showAt : function(xy){
var me = this;
this.callParent();
if (me.isVisible()) {
me.setPagePosition(xy[0], xy[1]);
if (me.constrainPosition || me.constrain) {
me.doConstrain();
}
me.toFront(true);
}
},
showBy : function(el, pos) {
this.showAt(this.el.getAlignToXY(el, pos || this.defaultAlign));
},
initDraggable : function(){
var me = this;
me.draggable = {
el: me.getDragEl(),
delegate: me.header.el,
constrain: me,
constrainTo: me.el.dom.parentNode
};
Ext.Component.prototype.initDraggable.call(me);
},
ghost: undefined,
unghost: undefined
});
Ext.define('Ext.tip.ToolTip', {
extend: 'Ext.tip.Tip',
alias: 'widget.tooltip',
alternateClassName: 'Ext.ToolTip',
showDelay: 500,
hideDelay: 200,
dismissDelay: 5000,
trackMouse: false,
anchorToTarget: true,
anchorOffset: 0,
targetCounter: 0,
quickShowInterval: 250,
initComponent: function() {
var me = this;
me.callParent(arguments);
me.lastActive = new Date();
me.setTarget(me.target);
me.origAnchor = me.anchor;
},
onRender: function(ct, position) {
var me = this;
me.callParent(arguments);
me.anchorCls = Ext.baseCSSPrefix + 'tip-anchor-' + me.getAnchorPosition();
me.anchorEl = me.el.createChild({
cls: Ext.baseCSSPrefix + 'tip-anchor ' + me.anchorCls
});
},
afterRender: function() {
var me = this,
zIndex;
me.callParent(arguments);
zIndex = parseInt(me.el.getZIndex(), 10) || 0;
me.anchorEl.setStyle('z-index', zIndex + 1).setVisibilityMode(Ext.core.Element.DISPLAY);
},
setTarget: function(target) {
var me = this,
t = Ext.get(target),
tg;
if (me.target) {
tg = Ext.get(me.target);
me.mun(tg, 'mouseover', me.onTargetOver, me);
me.mun(tg, 'mouseout', me.onTargetOut, me);
me.mun(tg, 'mousemove', me.onMouseMove, me);
}
me.target = t;
if (t) {
me.mon(t, {
freezeEvent: true,
mouseover: me.onTargetOver,
mouseout: me.onTargetOut,
mousemove: me.onMouseMove,
scope: me
});
}
if (me.anchor) {
me.anchorTarget = me.target;
}
},
onMouseMove: function(e) {
var me = this,
t = me.delegate ? e.getTarget(me.delegate) : me.triggerElement = true,
xy;
if (t) {
me.targetXY = e.getXY();
if (t === me.triggerElement) {
if (!me.hidden && me.trackMouse) {
xy = me.getTargetXY();
if (me.constrainPosition) {
xy = me.el.adjustForConstraints(xy, me.el.dom.parentNode);
}
me.setPagePosition(xy);
}
} else {
me.hide();
me.lastActive = new Date(0);
me.onTargetOver(e);
}
} else if ((!me.closable && me.isVisible()) && me.autoHide !== false) {
me.hide();
}
},
getTargetXY: function() {
var me = this,
mouseOffset;
if (me.delegate) {
me.anchorTarget = me.triggerElement;
}
if (me.anchor) {
me.targetCounter++;
var offsets = me.getOffsets(),
xy = (me.anchorToTarget && !me.trackMouse) ? me.el.getAlignToXY(me.anchorTarget, me.getAnchorAlign()) : me.targetXY,
dw = Ext.core.Element.getViewWidth() - 5,
dh = Ext.core.Element.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 = me.getSize(),
constrainPosition = me.constrainPosition;
me.anchorEl.removeCls(me.anchorCls);
if (me.targetCounter < 2 && constrainPosition) {
if (axy[0] < scrollX) {
if (me.anchorToTarget) {
me.defaultAlign = 'l-r';
if (me.mouseOffset) {
me.mouseOffset[0] *= -1;
}
}
me.anchor = 'left';
return me.getTargetXY();
}
if (axy[0] + sz.width > dw) {
if (me.anchorToTarget) {
me.defaultAlign = 'r-l';
if (me.mouseOffset) {
me.mouseOffset[0] *= -1;
}
}
me.anchor = 'right';
return me.getTargetXY();
}
if (axy[1] < scrollY) {
if (me.anchorToTarget) {
me.defaultAlign = 't-b';
if (me.mouseOffset) {
me.mouseOffset[1] *= -1;
}
}
me.anchor = 'top';
return me.getTargetXY();
}
if (axy[1] + sz.height > dh) {
if (me.anchorToTarget) {
me.defaultAlign = 'b-t';
if (me.mouseOffset) {
me.mouseOffset[1] *= -1;
}
}
me.anchor = 'bottom';
return me.getTargetXY();
}
}
me.anchorCls = Ext.baseCSSPrefix + 'tip-anchor-' + me.getAnchorPosition();
me.anchorEl.addCls(me.anchorCls);
me.targetCounter = 0;
return axy;
} else {
mouseOffset = me.getMouseOffset();
return (me.targetXY) ? [me.targetXY[0] + mouseOffset[0], me.targetXY[1] + mouseOffset[1]] : mouseOffset;
}
},
getMouseOffset: function() {
var me = this,
offset = me.anchor ? [0, 0] : [15, 18];
if (me.mouseOffset) {
offset[0] += me.mouseOffset[0];
offset[1] += me.mouseOffset[1];
}
return offset;
},
getAnchorPosition: function() {
var me = this,
m;
if (me.anchor) {
me.tipAnchor = me.anchor.charAt(0);
} else {
m = me.defaultAlign.match(/^([a-z]+)-([a-z]+)(\?)?$/);
me.tipAnchor = m[1].charAt(0);
}
switch (me.tipAnchor) {
case 't':
return 'top';
case 'b':
return 'bottom';
case 'r':
return 'right';
}
return 'left';
},
getAnchorAlign: function() {
switch (this.anchor) {
case 'top':
return 'tl-bl';
case 'left':
return 'tl-tr';
case 'right':
return 'tr-tl';
default:
return 'bl-tl';
}
},
getOffsets: function() {
var me = this,
mouseOffset,
offsets,
ap = me.getAnchorPosition().charAt(0);
if (me.anchorToTarget && !me.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 - me.anchorOffset, 30];
break;
case 'b':
offsets = [ - 19 - me.anchorOffset, -13 - me.el.dom.offsetHeight];
break;
case 'r':
offsets = [ - 15 - me.el.dom.offsetWidth, -13 - me.anchorOffset];
break;
default:
offsets = [25, -13 - me.anchorOffset];
break;
}
}
mouseOffset = me.getMouseOffset();
offsets[0] += mouseOffset[0];
offsets[1] += mouseOffset[1];
return offsets;
},
onTargetOver: function(e) {
var me = this,
t;
if (me.disabled || e.within(me.target.dom, true)) {
return;
}
t = e.getTarget(me.delegate);
if (t) {
me.triggerElement = t;
me.clearTimer('hide');
me.targetXY = e.getXY();
me.delayShow();
}
},
delayShow: function() {
var me = this;
if (me.hidden && !me.showTimer) {
if (Ext.Date.getElapsed(me.lastActive) < me.quickShowInterval) {
me.show();
} else {
me.showTimer = Ext.defer(me.show, me.showDelay, me);
}
}
else if (!me.hidden && me.autoHide !== false) {
me.show();
}
},
onTargetOut: function(e) {
var me = this;
if (me.disabled || e.within(me.target.dom, true)) {
return;
}
me.clearTimer('show');
if (me.autoHide !== false) {
me.delayHide();
}
},
delayHide: function() {
var me = this;
if (!me.hidden && !me.hideTimer) {
me.hideTimer = Ext.defer(me.hide, me.hideDelay, me);
}
},
hide: function() {
var me = this;
me.clearTimer('dismiss');
me.lastActive = new Date();
if (me.anchorEl) {
me.anchorEl.hide();
}
me.callParent(arguments);
delete me.triggerElement;
},
show: function() {
var me = this;
this.callParent();
if (this.hidden === false) {
me.setPagePosition(-10000, -10000);
if (me.anchor) {
me.anchor = me.origAnchor;
}
me.showAt(me.getTargetXY());
if (me.anchor) {
me.syncAnchor();
me.anchorEl.show();
} else {
me.anchorEl.hide();
}
}
},
showAt: function(xy) {
var me = this;
me.lastActive = new Date();
me.clearTimers();
if (!me.isVisible()) {
this.callParent(arguments);
}
if (me.isVisible()) {
me.setPagePosition(xy[0], xy[1]);
if (me.constrainPosition || me.constrain) {
me.doConstrain();
}
me.toFront(true);
}
if (me.dismissDelay && me.autoHide !== false) {
me.dismissTimer = Ext.defer(me.hide, me.dismissDelay, me);
}
if (me.anchor) {
me.syncAnchor();
if (!me.anchorEl.isVisible()) {
me.anchorEl.show();
}
} else {
me.anchorEl.hide();
}
},
syncAnchor: function() {
var me = this,
anchorPos,
targetPos,
offset;
switch (me.tipAnchor.charAt(0)) {
case 't':
anchorPos = 'b';
targetPos = 'tl';
offset = [20 + me.anchorOffset, 1];
break;
case 'r':
anchorPos = 'l';
targetPos = 'tr';
offset = [ - 1, 12 + me.anchorOffset];
break;
case 'b':
anchorPos = 't';
targetPos = 'bl';
offset = [20 + me.anchorOffset, -1];
break;
default:
anchorPos = 'r';
targetPos = 'tl';
offset = [1, 12 + me.anchorOffset];
break;
}
me.anchorEl.alignTo(me.el, anchorPos + '-' + targetPos, offset);
},
setPagePosition: function(x, y) {
var me = this;
me.callParent(arguments);
if (me.anchor) {
me.syncAnchor();
}
},
clearTimer: function(name) {
name = name + 'Timer';
clearTimeout(this[name]);
delete this[name];
},
clearTimers: function() {
var me = this;
me.clearTimer('show');
me.clearTimer('dismiss');
me.clearTimer('hide');
},
onShow: function() {
var me = this;
me.callParent();
me.mon(Ext.getDoc(), 'mousedown', me.onDocMouseDown, me);
},
onHide: function() {
var me = this;
me.callParent();
me.mun(Ext.getDoc(), 'mousedown', me.onDocMouseDown, me);
},
onDocMouseDown: function(e) {
var me = this;
if (me.autoHide !== true && !me.closable && !e.within(me.el.dom)) {
me.disable();
Ext.defer(me.doEnable, 100, me);
}
},
doEnable: function() {
if (!this.isDestroyed) {
this.enable();
}
},
onDisable: function() {
this.callParent();
this.clearTimers();
this.hide();
},
beforeDestroy: function() {
var me = this;
me.clearTimers();
Ext.destroy(me.anchorEl);
delete me.anchorEl;
delete me.target;
delete me.anchorTarget;
delete me.triggerElement;
me.callParent();
},
onDestroy: function() {
Ext.getDoc().un('mousedown', this.onDocMouseDown, this);
this.callParent();
}
});
Ext.define('Ext.tip.QuickTip', {
extend: 'Ext.tip.ToolTip',
alternateClassName: 'Ext.QuickTip',
interceptTitles : false,
title: ' ',
tagConfig : {
namespace : "data-",
attribute : "qtip",
width : "qwidth",
target : "target",
title : "qtitle",
hide : "hide",
cls : "qclass",
align : "qalign",
anchor : "anchor"
},
initComponent : function(){
var me = this;
me.target = me.target || Ext.getDoc();
me.targets = me.targets || {};
me.callParent();
},
register : function(config){
var configs = Ext.isArray(config) ? config : arguments,
i = 0,
len = configs.length,
target, j, targetLen;
for (; i < len; i++) {
config = configs[i];
target = config.target;
if (target) {
if (Ext.isArray(target)) {
for (j = 0, targetLen = target.length; j < targetLen; j++) {
this.targets[Ext.id(target[j])] = config;
}
} else{
this.targets[Ext.id(target)] = config;
}
}
}
},
unregister : function(el){
delete this.targets[Ext.id(el)];
},
cancelShow: function(el){
var me = this,
activeTarget = me.activeTarget;
el = Ext.get(el).dom;
if (me.isVisible()) {
if (activeTarget && activeTarget.el == el) {
me.hide();
}
} else if (activeTarget && activeTarget.el == el) {
me.clearTimer('show');
}
},
getTipCfg: function(e) {
var t = e.getTarget(),
ttp,
cfg;
if(this.interceptTitles && t.title && Ext.isString(t.title)){
ttp = t.title;
t.qtip = ttp;
t.removeAttribute("title");
e.preventDefault();
}
else {
cfg = this.tagConfig;
t = e.getTarget('[' + cfg.namespace + cfg.attribute + ']');
if (t) {
ttp = t.getAttribute(cfg.namespace + cfg.attribute);
}
}
return ttp;
},
onTargetOver : function(e){
var me = this,
target = e.getTarget(),
elTarget,
cfg,
ns,
ttp,
autoHide;
if (me.disabled) {
return;
}
me.targetXY = e.getXY();
if(!target || target.nodeType !== 1 || target == document || target == document.body){
return;
}
if (me.activeTarget && ((target == me.activeTarget.el) || Ext.fly(me.activeTarget.el).contains(target))) {
me.clearTimer('hide');
me.show();
return;
}
if (target) {
Ext.Object.each(me.targets, function(key, value) {
var targetEl = Ext.fly(value.target);
if (targetEl && (targetEl.dom === target || targetEl.contains(target))) {
elTarget = targetEl.dom;
return false;
}
});
if (elTarget) {
me.activeTarget = me.targets[elTarget.id];
me.activeTarget.el = target;
me.anchor = me.activeTarget.anchor;
if (me.anchor) {
me.anchorTarget = target;
}
me.delayShow();
return;
}
}
elTarget = Ext.get(target);
cfg = me.tagConfig;
ns = cfg.namespace;
ttp = me.getTipCfg(e);
if (ttp) {
autoHide = elTarget.getAttribute(ns + cfg.hide);
me.activeTarget = {
el: target,
text: ttp,
width: +elTarget.getAttribute(ns + cfg.width) || null,
autoHide: autoHide != "user" && autoHide !== 'false',
title: elTarget.getAttribute(ns + cfg.title),
cls: elTarget.getAttribute(ns + cfg.cls),
align: elTarget.getAttribute(ns + cfg.align)
};
me.anchor = elTarget.getAttribute(ns + cfg.anchor);
if (me.anchor) {
me.anchorTarget = target;
}
me.delayShow();
}
},
onTargetOut : function(e){
var me = this;
if (me.activeTarget && e.within(me.activeTarget.el) && !me.getTipCfg(e)) {
return;
}
me.clearTimer('show');
if (me.autoHide !== false) {
me.delayHide();
}
},
showAt : function(xy){
var me = this,
target = me.activeTarget;
if (target) {
if (!me.rendered) {
me.render(Ext.getBody());
me.activeTarget = target;
}
if (target.title) {
me.setTitle(target.title || '');
me.header.show();
} else {
me.header.hide();
}
me.body.update(target.text);
me.autoHide = target.autoHide;
me.dismissDelay = target.dismissDelay || me.dismissDelay;
if (me.lastCls) {
me.el.removeCls(me.lastCls);
delete me.lastCls;
}
if (target.cls) {
me.el.addCls(target.cls);
me.lastCls = target.cls;
}
me.setWidth(target.width);
if (me.anchor) {
me.constrainPosition = false;
} else if (target.align) {
xy = me.el.getAlignToXY(target.el, target.align);
me.constrainPosition = false;
}else{
me.constrainPosition = true;
}
}
me.callParent([xy]);
},
hide: function(){
delete this.activeTarget;
this.callParent();
}
});
Ext.define('Ext.tip.QuickTipManager', function() {
var tip,
disabled = false;
return {
requires: ['Ext.tip.QuickTip'],
singleton: true,
alternateClassName: 'Ext.QuickTips',
init : function (autoRender, config) {
if (!tip) {
if (!Ext.isReady) {
Ext.onReady(function(){
Ext.tip.QuickTipManager.init(autoRender);
});
return;
}
var tipConfig = Ext.apply({ disabled: disabled }, config),
className = tipConfig.className,
xtype = tipConfig.xtype;
if (className) {
delete tipConfig.className;
} else if (xtype) {
className = 'widget.' + xtype;
delete tipConfig.xtype;
}
if (autoRender !== false) {
tipConfig.renderTo = document.body;
}
tip = Ext.create(className || 'Ext.tip.QuickTip', tipConfig);
}
},
destroy: function() {
if (tip) {
var undef;
tip.destroy();
tip = undef;
}
},
ddDisable : function(){
if(tip && !disabled){
tip.disable();
}
},
ddEnable : function(){
if(tip && !disabled){
tip.enable();
}
},
enable : function(){
if(tip){
tip.enable();
}
disabled = false;
},
disable : function(){
if(tip){
tip.disable();
}
disabled = true;
},
isEnabled : function(){
return tip !== undefined && !tip.disabled;
},
getQuickTip : function(){
return tip;
},
register : function(){
tip.register.apply(tip, arguments);
},
unregister : function(){
tip.unregister.apply(tip, arguments);
},
tips : function(){
tip.register.apply(tip, arguments);
}
};
}());
Ext.define('Ext.app.Application', {
extend: 'Ext.app.Controller',
requires: [
'Ext.ModelManager',
'Ext.data.Model',
'Ext.data.StoreManager',
'Ext.tip.QuickTipManager',
'Ext.ComponentManager',
'Ext.app.EventBus'
],
scope: undefined,
enableQuickTips: true,
appFolder: 'app',
autoCreateViewport: false,
constructor: function(config) {
config = config || {};
Ext.apply(this, config);
var requires = config.requires || [];
Ext.Loader.setPath(this.name, this.appFolder);
if (this.paths) {
Ext.Object.each(this.paths, function(key, value) {
Ext.Loader.setPath(key, value);
});
}
this.callParent(arguments);
this.eventbus = Ext.create('Ext.app.EventBus');
var controllers = Ext.Array.from(this.controllers),
ln = controllers && controllers.length,
i, controller;
this.controllers = Ext.create('Ext.util.MixedCollection');
if (this.autoCreateViewport) {
requires.push(this.getModuleClassName('Viewport', 'view'));
}
for (i = 0; i < ln; i++) {
requires.push(this.getModuleClassName(controllers[i], 'controller'));
}
Ext.require(requires);
Ext.onReady(function() {
for (i = 0; i < ln; i++) {
controller = this.getController(controllers[i]);
controller.init(this);
}
this.onBeforeLaunch.call(this);
}, this);
},
control: function(selectors, listeners, controller) {
this.eventbus.control(selectors, listeners, controller);
},
launch: Ext.emptyFn,
onBeforeLaunch: function() {
if (this.enableQuickTips) {
Ext.tip.QuickTipManager.init();
}
if (this.autoCreateViewport) {
this.getView('Viewport').create();
}
this.launch.call(this.scope || this);
this.launched = true;
this.fireEvent('launch', this);
this.controllers.each(function(controller) {
controller.onLaunch(this);
}, this);
},
getModuleClassName: function(name, type) {
var namespace = Ext.Loader.getPrefix(name);
if (namespace.length > 0 && namespace !== name) {
return name;
}
return this.name + '.' + type + '.' + name;
},
getController: function(name) {
var controller = this.controllers.get(name);
if (!controller) {
controller = Ext.create(this.getModuleClassName(name, 'controller'), {
application: this,
id: name
});
this.controllers.add(controller);
}
return controller;
},
getStore: function(name) {
var store = Ext.StoreManager.get(name);
if (!store) {
store = Ext.create(this.getModuleClassName(name, 'store'), {
storeId: name
});
}
return store;
},
getModel: function(model) {
model = this.getModuleClassName(model, 'model');
return Ext.ModelManager.getModel(model);
},
getView: function(view) {
view = this.getModuleClassName(view, 'view');
return Ext.ClassManager.get(view);
}
});
Ext.define('Ext.chart.Callout', {
constructor: function(config) {
if (config.callouts) {
config.callouts.styles = Ext.applyIf(config.callouts.styles || {}, {
color: "#000",
font: "11px Helvetica, sans-serif"
});
this.callouts = Ext.apply(this.callouts || {}, config.callouts);
this.calloutsArray = [];
}
},
renderCallouts: function() {
if (!this.callouts) {
return;
}
var me = this,
items = me.items,
animate = me.chart.animate,
config = me.callouts,
styles = config.styles,
group = me.calloutsArray,
store = me.chart.store,
len = store.getCount(),
ratio = items.length / len,
previouslyPlacedCallouts = [],
i,
count,
j,
p;
for (i = 0, count = 0; i < len; i++) {
for (j = 0; j < ratio; j++) {
var item = items[count],
label = group[count],
storeItem = store.getAt(i),
display;
display = config.filter(storeItem);
if (!display && !label) {
count++;
continue;
}
if (!label) {
group[count] = label = me.onCreateCallout(storeItem, item, i, display, j, count);
}
for (p in label) {
if (label[p] && label[p].setAttributes) {
label[p].setAttributes(styles, true);
}
}
if (!display) {
for (p in label) {
if (label[p]) {
if (label[p].setAttributes) {
label[p].setAttributes({
hidden: true
}, true);
} else if(label[p].setVisible) {
label[p].setVisible(false);
}
}
}
}
config.renderer(label, storeItem);
me.onPlaceCallout(label, storeItem, item, i, display, animate,
j, count, previouslyPlacedCallouts);
previouslyPlacedCallouts.push(label);
count++;
}
}
this.hideCallouts(count);
},
onCreateCallout: function(storeItem, item, i, display) {
var me = this,
group = me.calloutsGroup,
config = me.callouts,
styles = config.styles,
width = styles.width,
height = styles.height,
chart = me.chart,
surface = chart.surface,
calloutObj = {
lines: false
};
calloutObj.lines = surface.add(Ext.apply({},
{
type: 'path',
path: 'M0,0',
stroke: me.getLegendColor() || '#555'
},
styles));
if (config.items) {
calloutObj.panel = Ext.create('widget.panel', {
style: "position: absolute;",
width: width,
height: height,
items: config.items,
renderTo: chart.el
});
}
return calloutObj;
},
hideCallouts: function(index) {
var calloutsArray = this.calloutsArray,
len = calloutsArray.length,
co,
p;
while (len-->index) {
co = calloutsArray[len];
for (p in co) {
if (co[p]) {
co[p].hide(true);
}
}
}
}
});
Ext.define('Ext.draw.CompositeSprite', {
extend: 'Ext.util.MixedCollection',
mixins: {
animate: 'Ext.util.Animate'
},
isCompositeSprite: true,
constructor: function(config) {
var me = this;
config = config || {};
Ext.apply(me, config);
me.addEvents(
'mousedown',
'mouseup',
'mouseover',
'mouseout',
'click'
);
me.id = Ext.id(null, 'ext-sprite-group-');
me.callParent();
},
onClick: function(e) {
this.fireEvent('click', e);
},
onMouseUp: function(e) {
this.fireEvent('mouseup', e);
},
onMouseDown: function(e) {
this.fireEvent('mousedown', e);
},
onMouseOver: function(e) {
this.fireEvent('mouseover', e);
},
onMouseOut: function(e) {
this.fireEvent('mouseout', e);
},
attachEvents: function(o) {
var me = this;
o.on({
scope: me,
mousedown: me.onMouseDown,
mouseup: me.onMouseUp,
mouseover: me.onMouseOver,
mouseout: me.onMouseOut,
click: me.onClick
});
},
add: function(key, o) {
var result = this.callParent(arguments);
this.attachEvents(result);
return result;
},
insert: function(index, key, o) {
return this.callParent(arguments);
},
remove: function(o) {
var me = this;
o.un({
scope: me,
mousedown: me.onMouseDown,
mouseup: me.onMouseUp,
mouseover: me.onMouseOver,
mouseout: me.onMouseOut,
click: me.onClick
});
me.callParent(arguments);
},
getBBox: function() {
var i = 0,
sprite,
bb,
items = this.items,
len = this.length,
infinity = Infinity,
minX = infinity,
maxHeight = -infinity,
minY = infinity,
maxWidth = -infinity,
maxWidthBBox, maxHeightBBox;
for (; i < len; i++) {
sprite = items[i];
if (sprite.el) {
bb = sprite.getBBox();
minX = Math.min(minX, bb.x);
minY = Math.min(minY, bb.y);
maxHeight = Math.max(maxHeight, bb.height + bb.y);
maxWidth = Math.max(maxWidth, bb.width + bb.x);
}
}
return {
x: minX,
y: minY,
height: maxHeight - minY,
width: maxWidth - minX
};
},
setAttributes: function(attrs, redraw) {
var i = 0,
items = this.items,
len = this.length;
for (; i < len; i++) {
items[i].setAttributes(attrs, redraw);
}
return this;
},
hide: function(redraw) {
var i = 0,
items = this.items,
len = this.length;
for (; i < len; i++) {
items[i].hide(redraw);
}
return this;
},
show: function(redraw) {
var i = 0,
items = this.items,
len = this.length;
for (; i < len; i++) {
items[i].show(redraw);
}
return this;
},
redraw: function() {
var me = this,
i = 0,
items = me.items,
surface = me.getSurface(),
len = me.length;
if (surface) {
for (; i < len; i++) {
surface.renderItem(items[i]);
}
}
return me;
},
setStyle: function(obj) {
var i = 0,
items = this.items,
len = this.length,
item, el;
for (; i < len; i++) {
item = items[i];
el = item.el;
if (el) {
el.setStyle(obj);
}
}
},
addCls: function(obj) {
var i = 0,
items = this.items,
surface = this.getSurface(),
len = this.length;
if (surface) {
for (; i < len; i++) {
surface.addCls(items[i], obj);
}
}
},
removeCls: function(obj) {
var i = 0,
items = this.items,
surface = this.getSurface(),
len = this.length;
if (surface) {
for (; i < len; i++) {
surface.removeCls(items[i], obj);
}
}
},
getSurface: function(){
var first = this.first();
if (first) {
return first.surface;
}
return null;
},
destroy: function(){
var me = this,
surface = me.getSurface(),
item;
if (surface) {
while (me.getCount() > 0) {
item = me.first();
me.remove(item);
surface.remove(item);
}
}
me.clearListeners();
}
});
Ext.define('Ext.layout.component.Draw', {
alias: 'layout.draw',
extend: 'Ext.layout.component.Auto',
type: 'draw',
onLayout : function(width, height) {
this.owner.surface.setSize(width, height);
this.callParent(arguments);
}
});
Ext.define('Ext.chart.theme.Theme', {
requires: ['Ext.draw.Color'],
theme: 'Base',
themeAttrs: false,
initTheme: function(theme) {
var me = this,
themes = Ext.chart.theme,
key, gradients;
if (theme) {
theme = theme.split(':');
for (key in themes) {
if (key == theme[0]) {
gradients = theme[1] == 'gradients';
me.themeAttrs = new themes[key]({
useGradients: gradients
});
if (gradients) {
me.gradients = me.themeAttrs.gradients;
}
if (me.themeAttrs.background) {
me.background = me.themeAttrs.background;
}
return;
}
}
}
}
},
function() {
(function() {
Ext.chart.theme = function(config, base) {
config = config || {};
var i = 0, l, colors, color,
seriesThemes, markerThemes,
seriesTheme, markerTheme,
key, gradients = [],
midColor, midL;
if (config.baseColor) {
midColor = Ext.draw.Color.fromString(config.baseColor);
midL = midColor.getHSL()[2];
if (midL < 0.15) {
midColor = midColor.getLighter(0.3);
} else if (midL < 0.3) {
midColor = midColor.getLighter(0.15);
} else if (midL > 0.85) {
midColor = midColor.getDarker(0.3);
} else if (midL > 0.7) {
midColor = midColor.getDarker(0.15);
}
config.colors = [ midColor.getDarker(0.3).toString(),
midColor.getDarker(0.15).toString(),
midColor.toString(),
midColor.getLighter(0.15).toString(),
midColor.getLighter(0.3).toString()];
delete config.baseColor;
}
if (config.colors) {
colors = config.colors.slice();
markerThemes = base.markerThemes;
seriesThemes = base.seriesThemes;
l = colors.length;
base.colors = colors;
for (; i < l; i++) {
color = colors[i];
markerTheme = markerThemes[i] || {};
seriesTheme = seriesThemes[i] || {};
markerTheme.fill = seriesTheme.fill = markerTheme.stroke = seriesTheme.stroke = color;
markerThemes[i] = markerTheme;
seriesThemes[i] = seriesTheme;
}
base.markerThemes = markerThemes.slice(0, l);
base.seriesThemes = seriesThemes.slice(0, l);
}
for (key in base) {
if (key in config) {
if (Ext.isObject(config[key]) && Ext.isObject(base[key])) {
Ext.apply(base[key], config[key]);
} else {
base[key] = config[key];
}
}
}
if (config.useGradients) {
colors = base.colors || (function () {
var ans = [];
for (i = 0, seriesThemes = base.seriesThemes, l = seriesThemes.length; i < l; i++) {
ans.push(seriesThemes[i].fill || seriesThemes[i].stroke);
}
return ans;
})();
for (i = 0, l = colors.length; i < l; i++) {
midColor = Ext.draw.Color.fromString(colors[i]);
if (midColor) {
color = midColor.getDarker(0.1).toString();
midColor = midColor.toString();
key = 'theme-' + midColor.substr(1) + '-' + color.substr(1);
gradients.push({
id: key,
angle: 45,
stops: {
0: {
color: midColor.toString()
},
100: {
color: color.toString()
}
}
});
colors[i] = 'url(#' + key + ')';
}
}
base.gradients = gradients;
base.colors = colors;
}
Ext.apply(this, base);
};
})();
});
Ext.define('Ext.chart.Mask', {
constructor: function(config) {
var me = this;
me.addEvents('select');
if (config) {
Ext.apply(me, config);
}
if (me.mask) {
me.on('afterrender', function() {
var comp = Ext.create('Ext.chart.MaskLayer', {
renderTo: me.el
});
comp.el.on({
'mousemove': function(e) {
me.onMouseMove(e);
},
'mouseup': function(e) {
me.resized(e);
}
});
var resizeHandler = Ext.create('Ext.resizer.Resizer', {
el: comp.el,
handles: 'all',
pinned: true
});
resizeHandler.on({
'resize': function(e) {
me.resized(e);
}
});
comp.initDraggable();
me.maskType = me.mask;
me.mask = comp;
me.maskSprite = me.surface.add({
type: 'path',
path: ['M', 0, 0],
zIndex: 1001,
opacity: 0.7,
hidden: true,
stroke: '#444'
});
}, me, { single: true });
}
},
resized: function(e) {
var me = this,
bbox = me.bbox || me.chartBBox,
x = bbox.x,
y = bbox.y,
width = bbox.width,
height = bbox.height,
box = me.mask.getBox(true),
max = Math.max,
min = Math.min,
staticX = box.x - x,
staticY = box.y - y;
staticX = max(staticX, x);
staticY = max(staticY, y);
staticX = min(staticX, width);
staticY = min(staticY, height);
box.x = staticX;
box.y = staticY;
me.fireEvent('select', me, box);
},
onMouseUp: function(e) {
var me = this,
bbox = me.bbox || me.chartBBox,
sel = me.maskSelection;
me.maskMouseDown = false;
me.mouseDown = false;
if (me.mouseMoved) {
me.onMouseMove(e);
me.mouseMoved = false;
me.fireEvent('select', me, {
x: sel.x - bbox.x,
y: sel.y - bbox.y,
width: sel.width,
height: sel.height
});
}
},
onMouseDown: function(e) {
var me = this;
me.mouseDown = true;
me.mouseMoved = false;
me.maskMouseDown = {
x: e.getPageX() - me.el.getX(),
y: e.getPageY() - me.el.getY()
};
},
onMouseMove: function(e) {
var me = this,
mask = me.maskType,
bbox = me.bbox || me.chartBBox,
x = bbox.x,
y = bbox.y,
math = Math,
floor = math.floor,
abs = math.abs,
min = math.min,
max = math.max,
height = floor(y + bbox.height),
width = floor(x + bbox.width),
posX = e.getPageX(),
posY = e.getPageY(),
staticX = posX - me.el.getX(),
staticY = posY - me.el.getY(),
maskMouseDown = me.maskMouseDown,
path;
me.mouseMoved = me.mouseDown;
staticX = max(staticX, x);
staticY = max(staticY, y);
staticX = min(staticX, width);
staticY = min(staticY, height);
if (maskMouseDown && me.mouseDown) {
if (mask == 'horizontal') {
staticY = y;
maskMouseDown.y = height;
posY = me.el.getY() + bbox.height + me.insetPadding;
}
else if (mask == 'vertical') {
staticX = x;
maskMouseDown.x = width;
}
width = maskMouseDown.x - staticX;
height = maskMouseDown.y - staticY;
path = ['M', staticX, staticY, 'l', width, 0, 0, height, -width, 0, 'z'];
me.maskSelection = {
x: width > 0 ? staticX : staticX + width,
y: height > 0 ? staticY : staticY + height,
width: abs(width),
height: abs(height)
};
me.mask.updateBox({
x: posX - abs(width),
y: posY - abs(height),
width: abs(width),
height: abs(height)
});
me.mask.show();
me.maskSprite.setAttributes({
hidden: true
}, true);
}
else {
if (mask == 'horizontal') {
path = ['M', staticX, y, 'L', staticX, height];
}
else if (mask == 'vertical') {
path = ['M', x, staticY, 'L', width, staticY];
}
else {
path = ['M', staticX, y, 'L', staticX, height, 'M', x, staticY, 'L', width, staticY];
}
me.maskSprite.setAttributes({
path: path,
fill: me.maskMouseDown ? me.maskSprite.stroke : false,
'stroke-width': mask === true ? 1 : 3,
hidden: false
}, true);
}
},
onMouseLeave: function(e) {
var me = this;
me.mouseMoved = false;
me.mouseDown = false;
me.maskMouseDown = false;
me.mask.hide();
me.maskSprite.hide(true);
}
});
Ext.define('Ext.chart.Navigation', {
constructor: function() {
this.originalStore = this.store;
},
setZoom: function(zoomConfig) {
var me = this,
store = me.substore || me.store,
bbox = me.chartBBox,
len = store.getCount(),
from = (zoomConfig.x / bbox.width * len) >> 0,
to = Math.ceil(((zoomConfig.x + zoomConfig.width) / bbox.width * len)),
recFieldsLen, recFields = [], curField, json = [], obj;
store.each(function(rec, i) {
if (i < from || i > to) {
return;
}
obj = {};
if (!recFields.length) {
rec.fields.each(function(f) {
recFields.push(f.name);
});
recFieldsLen = recFields.length;
}
for (i = 0; i < recFieldsLen; i++) {
curField = recFields[i];
obj[curField] = rec.get(curField);
}
json.push(obj);
});
me.store = me.substore = Ext.create('Ext.data.JsonStore', {
fields: recFields,
data: json
});
me.redraw(true);
},
restoreZoom: function() {
this.store = this.substore = this.originalStore;
this.redraw(true);
}
});
Ext.define('Ext.chart.Shape', {
singleton: true,
circle: function (surface, opts) {
return surface.add(Ext.apply({
type: 'circle',
x: opts.x,
y: opts.y,
stroke: null,
radius: opts.radius
}, opts));
},
line: function (surface, opts) {
return surface.add(Ext.apply({
type: 'rect',
x: opts.x - opts.radius,
y: opts.y - opts.radius,
height: 2 * opts.radius,
width: 2 * opts.radius / 5
}, opts));
},
square: function (surface, opts) {
return surface.add(Ext.applyIf({
type: 'rect',
x: opts.x - opts.radius,
y: opts.y - opts.radius,
height: 2 * opts.radius,
width: 2 * opts.radius,
radius: null
}, opts));
},
triangle: function (surface, opts) {
opts.radius *= 1.75;
return surface.add(Ext.apply({
type: 'path',
stroke: null,
path: "M".concat(opts.x, ",", opts.y, "m0-", opts.radius * 0.58, "l", opts.radius * 0.5, ",", opts.radius * 0.87, "-", opts.radius, ",0z")
}, opts));
},
diamond: function (surface, opts) {
var r = opts.radius;
r *= 1.5;
return surface.add(Ext.apply({
type: 'path',
stroke: null,
path: ["M", opts.x, opts.y - r, "l", r, r, -r, r, -r, -r, r, -r, "z"]
}, opts));
},
cross: function (surface, opts) {
var r = opts.radius;
r = r / 1.7;
return surface.add(Ext.apply({
type: 'path',
stroke: null,
path: "M".concat(opts.x - r, ",", opts.y, "l", [-r, -r, r, -r, r, r, r, -r, r, r, -r, r, r, r, -r, r, -r, -r, -r, r, -r, -r, "z"])
}, opts));
},
plus: function (surface, opts) {
var r = opts.radius / 1.3;
return surface.add(Ext.apply({
type: 'path',
stroke: null,
path: "M".concat(opts.x - r / 2, ",", opts.y - r / 2, "l", [0, -r, r, 0, 0, r, r, 0, 0, r, -r, 0, 0, r, -r, 0, 0, -r, -r, 0, 0, -r, "z"])
}, opts));
},
arrow: function (surface, opts) {
var r = opts.radius;
return surface.add(Ext.apply({
type: 'path',
path: "M".concat(opts.x - r * 0.7, ",", opts.y - r * 0.4, "l", [r * 0.6, 0, 0, -r * 0.4, r, r * 0.8, -r, r * 0.8, 0, -r * 0.4, -r * 0.6, 0], "z")
}, opts));
},
drop: function (surface, x, y, text, size, angle) {
size = size || 30;
angle = angle || 0;
surface.add({
type: 'path',
path: ['M', x, y, 'l', size, 0, 'A', size * 0.4, size * 0.4, 0, 1, 0, x + size * 0.7, y - size * 0.7, 'z'],
fill: '#000',
stroke: 'none',
rotate: {
degrees: 22.5 - angle,
x: x,
y: y
}
});
angle = (angle + 90) * Math.PI / 180;
surface.add({
type: 'text',
x: x + size * Math.sin(angle) - 10,
y: y + size * Math.cos(angle) + 5,
text: text,
'font-size': size * 12 / 40,
stroke: 'none',
fill: '#fff'
});
}
});
Ext.define('Ext.draw.Surface', {
mixins: {
observable: 'Ext.util.Observable'
},
requires: ['Ext.draw.CompositeSprite'],
uses: ['Ext.draw.engine.Svg', 'Ext.draw.engine.Vml'],
separatorRe: /[, ]+/,
statics: {
create: function(config, enginePriority) {
enginePriority = enginePriority || ['Svg', 'Vml'];
var i = 0,
len = enginePriority.length,
surfaceClass;
for (; i < len; i++) {
if (Ext.supports[enginePriority[i]]) {
return Ext.create('Ext.draw.engine.' + enginePriority[i], config);
}
}
return false;
}
},
availableAttrs: {
blur: 0,
"clip-rect": "0 0 1e9 1e9",
cursor: "default",
cx: 0,
cy: 0,
'dominant-baseline': 'auto',
fill: "none",
"fill-opacity": 1,
font: '10px "Arial"',
"font-family": '"Arial"',
"font-size": "10",
"font-style": "normal",
"font-weight": 400,
gradient: "",
height: 0,
hidden: false,
href: "http://sencha.com/",
opacity: 1,
path: "M0,0",
radius: 0,
rx: 0,
ry: 0,
scale: "1 1",
src: "",
stroke: "#000",
"stroke-dasharray": "",
"stroke-linecap": "butt",
"stroke-linejoin": "butt",
"stroke-miterlimit": 0,
"stroke-opacity": 1,
"stroke-width": 1,
target: "_blank",
text: "",
"text-anchor": "middle",
title: "Ext Draw",
width: 0,
x: 0,
y: 0,
zIndex: 0
},
container: undefined,
height: 352,
width: 512,
x: 0,
y: 0,
constructor: function(config) {
var me = this;
config = config || {};
Ext.apply(me, config);
me.domRef = Ext.getDoc().dom;
me.customAttributes = {};
me.addEvents(
'mousedown',
'mouseup',
'mouseover',
'mouseout',
'mousemove',
'mouseenter',
'mouseleave',
'click'
);
me.mixins.observable.constructor.call(me);
me.getId();
me.initGradients();
me.initItems();
if (me.renderTo) {
me.render(me.renderTo);
delete me.renderTo;
}
me.initBackground(config.background);
},
initSurface: Ext.emptyFn,
renderItem: Ext.emptyFn,
renderItems: Ext.emptyFn,
setViewBox: Ext.emptyFn,
addCls: Ext.emptyFn,
removeCls: Ext.emptyFn,
setStyle: Ext.emptyFn,
initGradients: function() {
var gradients = this.gradients;
if (gradients) {
Ext.each(gradients, this.addGradient, this);
}
},
initItems: function() {
var items = this.items;
this.items = Ext.create('Ext.draw.CompositeSprite');
this.groups = Ext.create('Ext.draw.CompositeSprite');
if (items) {
this.add(items);
}
},
initBackground: function(config) {
var me = this,
width = me.width,
height = me.height,
gradientId, gradient, backgroundSprite;
if (config) {
if (config.gradient) {
gradient = config.gradient;
gradientId = gradient.id;
me.addGradient(gradient);
me.background = me.add({
type: 'rect',
x: 0,
y: 0,
width: width,
height: height,
fill: 'url(#' + gradientId + ')'
});
} else if (config.fill) {
me.background = me.add({
type: 'rect',
x: 0,
y: 0,
width: width,
height: height,
fill: config.fill
});
} else if (config.image) {
me.background = me.add({
type: 'image',
x: 0,
y: 0,
width: width,
height: height,
src: config.image
});
}
}
},
setSize: function(w, h) {
if (this.background) {
this.background.setAttributes({
width: w,
height: h,
hidden: false
}, true);
}
},
scrubAttrs: function(sprite) {
var i,
attrs = {},
exclude = {},
sattr = sprite.attr;
for (i in sattr) {
if (this.translateAttrs.hasOwnProperty(i)) {
attrs[this.translateAttrs[i]] = sattr[i];
exclude[this.translateAttrs[i]] = true;
}
else if (this.availableAttrs.hasOwnProperty(i) && !exclude[i]) {
attrs[i] = sattr[i];
}
}
return attrs;
},
onClick: function(e) {
this.processEvent('click', e);
},
onMouseUp: function(e) {
this.processEvent('mouseup', e);
},
onMouseDown: function(e) {
this.processEvent('mousedown', e);
},
onMouseOver: function(e) {
this.processEvent('mouseover', e);
},
onMouseOut: function(e) {
this.processEvent('mouseout', e);
},
onMouseMove: function(e) {
this.fireEvent('mousemove', e);
},
onMouseEnter: Ext.emptyFn,
onMouseLeave: Ext.emptyFn,
addGradient: Ext.emptyFn,
add: function() {
var args = Array.prototype.slice.call(arguments),
sprite,
index;
var hasMultipleArgs = args.length > 1;
if (hasMultipleArgs || Ext.isArray(args[0])) {
var items = hasMultipleArgs ? args : args[0],
results = [],
i, ln, item;
for (i = 0, ln = items.length; i < ln; i++) {
item = items[i];
item = this.add(item);
results.push(item);
}
return results;
}
sprite = this.prepareItems(args[0], true)[0];
this.normalizeSpriteCollection(sprite);
this.onAdd(sprite);
return sprite;
},
normalizeSpriteCollection: function(sprite) {
var items = this.items,
zIndex = sprite.attr.zIndex,
idx = items.indexOf(sprite);
if (idx < 0 || (idx > 0 && items.getAt(idx - 1).attr.zIndex > zIndex) ||
(idx < items.length - 1 && items.getAt(idx + 1).attr.zIndex < zIndex)) {
items.removeAt(idx);
idx = items.findIndexBy(function(otherSprite) {
return otherSprite.attr.zIndex > zIndex;
});
if (idx < 0) {
idx = items.length;
}
items.insert(idx, sprite);
}
return idx;
},
onAdd: function(sprite) {
var group = sprite.group,
draggable = sprite.draggable,
groups, ln, i;
if (group) {
groups = [].concat(group);
ln = groups.length;
for (i = 0; i < ln; i++) {
group = groups[i];
this.getGroup(group).add(sprite);
}
delete sprite.group;
}
if (draggable) {
sprite.initDraggable();
}
},
remove: function(sprite, destroySprite) {
if (sprite) {
this.items.remove(sprite);
this.groups.each(function(item) {
item.remove(sprite);
});
sprite.onRemove();
if (destroySprite === true) {
sprite.destroy();
}
}
},
removeAll: function(destroySprites) {
var items = this.items.items,
ln = items.length,
i;
for (i = ln - 1; i > -1; i--) {
this.remove(items[i], destroySprites);
}
},
onRemove: Ext.emptyFn,
onDestroy: Ext.emptyFn,
applyTransformations: function(sprite) {
sprite.bbox.transform = 0;
this.transform(sprite);
var me = this,
dirty = false,
attr = sprite.attr;
if (attr.translation.x != null || attr.translation.y != null) {
me.translate(sprite);
dirty = true;
}
if (attr.scaling.x != null || attr.scaling.y != null) {
me.scale(sprite);
dirty = true;
}
if (attr.rotation.degrees != null) {
me.rotate(sprite);
dirty = true;
}
if (dirty) {
sprite.bbox.transform = 0;
this.transform(sprite);
sprite.transformations = [];
}
},
rotate: function (sprite) {
var bbox,
deg = sprite.attr.rotation.degrees,
centerX = sprite.attr.rotation.x,
centerY = sprite.attr.rotation.y;
if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
bbox = this.getBBox(sprite);
centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
}
sprite.transformations.push({
type: "rotate",
degrees: deg,
x: centerX,
y: centerY
});
},
translate: function(sprite) {
var x = sprite.attr.translation.x || 0,
y = sprite.attr.translation.y || 0;
sprite.transformations.push({
type: "translate",
x: x,
y: y
});
},
scale: function(sprite) {
var bbox,
x = sprite.attr.scaling.x || 1,
y = sprite.attr.scaling.y || 1,
centerX = sprite.attr.scaling.centerX,
centerY = sprite.attr.scaling.centerY;
if (!Ext.isNumber(centerX) || !Ext.isNumber(centerY)) {
bbox = this.getBBox(sprite);
centerX = !Ext.isNumber(centerX) ? bbox.x + bbox.width / 2 : centerX;
centerY = !Ext.isNumber(centerY) ? bbox.y + bbox.height / 2 : centerY;
}
sprite.transformations.push({
type: "scale",
x: x,
y: y,
centerX: centerX,
centerY: centerY
});
},
rectPath: function (x, y, w, h, r) {
if (r) {
return [["M", x + r, y], ["l", w - r * 2, 0], ["a", r, r, 0, 0, 1, r, r], ["l", 0, h - r * 2], ["a", r, r, 0, 0, 1, -r, r], ["l", r * 2 - w, 0], ["a", r, r, 0, 0, 1, -r, -r], ["l", 0, r * 2 - h], ["a", r, r, 0, 0, 1, r, -r], ["z"]];
}
return [["M", x, y], ["l", w, 0], ["l", 0, h], ["l", -w, 0], ["z"]];
},
ellipsePath: function (x, y, rx, ry) {
if (ry == null) {
ry = rx;
}
return [["M", x, y], ["m", 0, -ry], ["a", rx, ry, 0, 1, 1, 0, 2 * ry], ["a", rx, ry, 0, 1, 1, 0, -2 * ry], ["z"]];
},
getPathpath: function (el) {
return el.attr.path;
},
getPathcircle: function (el) {
var a = el.attr;
return this.ellipsePath(a.x, a.y, a.radius, a.radius);
},
getPathellipse: function (el) {
var a = el.attr;
return this.ellipsePath(a.x, a.y,
a.radiusX || (a.width / 2) || 0,
a.radiusY || (a.height / 2) || 0);
},
getPathrect: function (el) {
var a = el.attr;
return this.rectPath(a.x, a.y, a.width, a.height, a.r);
},
getPathimage: function (el) {
var a = el.attr;
return this.rectPath(a.x || 0, a.y || 0, a.width, a.height);
},
getPathtext: function (el) {
var bbox = this.getBBoxText(el);
return this.rectPath(bbox.x, bbox.y, bbox.width, bbox.height);
},
createGroup: function(id) {
var group = this.groups.get(id);
if (!group) {
group = Ext.create('Ext.draw.CompositeSprite', {
surface: this
});
group.id = id || Ext.id(null, 'ext-surface-group-');
this.groups.add(group);
}
return group;
},
getGroup: function(id) {
if (typeof id == "string") {
var group = this.groups.get(id);
if (!group) {
group = this.createGroup(id);
}
} else {
group = id;
}
return group;
},
prepareItems: function(items, applyDefaults) {
items = [].concat(items);
var item, i, ln;
for (i = 0, ln = items.length; i < ln; i++) {
item = items[i];
if (!(item instanceof Ext.draw.Sprite)) {
item.surface = this;
items[i] = this.createItem(item);
} else {
item.surface = this;
}
}
return items;
},
setText: Ext.emptyFn,
//@private Creates an item and appends it to the surface. Called
createItem: Ext.emptyFn,
getId: function() {
return this.id || (this.id = Ext.id(null, 'ext-surface-'));
},
destroy: function() {
delete this.domRef;
this.removeAll();
}
});
Ext.define('Ext.draw.Component', {
alias: 'widget.draw',
extend: 'Ext.Component',
requires: [
'Ext.draw.Surface',
'Ext.layout.component.Draw'
],
enginePriority: ['Svg', 'Vml'],
baseCls: Ext.baseCSSPrefix + 'surface',
componentLayout: 'draw',
viewBox: true,
autoSize: false,
initComponent: function() {
this.callParent(arguments);
this.addEvents(
'mousedown',
'mouseup',
'mousemove',
'mouseenter',
'mouseleave',
'click'
);
},
onRender: function() {
var me = this,
viewBox = me.viewBox,
autoSize = me.autoSize,
bbox, items, width, height, x, y;
me.callParent(arguments);
me.createSurface();
items = me.surface.items;
if (viewBox || autoSize) {
bbox = items.getBBox();
width = bbox.width;
height = bbox.height;
x = bbox.x;
y = bbox.y;
if (me.viewBox) {
me.surface.setViewBox(x, y, width, height);
}
else {
me.autoSizeSurface();
}
}
},
//@private
autoSizeSurface: function() {
var me = this,
items = me.surface.items,
bbox = items.getBBox(),
width = bbox.width,
height = bbox.height;
items.setAttributes({
translate: {
x: -bbox.x,
y: -bbox.y + (+Ext.isOpera)
}
}, true);
if (me.rendered) {
me.setSize(width, height);
me.surface.setSize(width, height);
}
else {
me.surface.setSize(width, height);
}
me.el.setSize(width, height);
},
createSurface: function() {
var surface = Ext.draw.Surface.create(Ext.apply({}, {
width: this.width,
height: this.height,
renderTo: this.el
}, this.initialConfig));
this.surface = surface;
function refire(eventName) {
return function(e) {
this.fireEvent(eventName, e);
};
}
surface.on({
scope: this,
mouseup: refire('mouseup'),
mousedown: refire('mousedown'),
mousemove: refire('mousemove'),
mouseenter: refire('mouseenter'),
mouseleave: refire('mouseleave'),
click: refire('click')
});
},
onDestroy: function() {
var surface = this.surface;
if (surface) {
surface.destroy();
}
this.callParent(arguments);
}
});
Ext.define('Ext.chart.LegendItem', {
extend: 'Ext.draw.CompositeSprite',
requires: ['Ext.chart.Shape'],
x: 0,
y: 0,
zIndex: 500,
constructor: function(config) {
this.callParent(arguments);
this.createLegend(config);
},
createLegend: function(config) {
var me = this,
index = config.yFieldIndex,
series = me.series,
seriesType = series.type,
idx = me.yFieldIndex,
legend = me.legend,
surface = me.surface,
refX = legend.x + me.x,
refY = legend.y + me.y,
bbox, z = me.zIndex,
markerConfig, label, mask,
radius, toggle = false,
seriesStyle = Ext.apply(series.seriesStyle, series.style);
function getSeriesProp(name) {
var val = series[name];
return (Ext.isArray(val) ? val[idx] : val);
}
label = me.add('label', surface.add({
type: 'text',
x: 20,
y: 0,
zIndex: z || 0,
font: legend.labelFont,
text: getSeriesProp('title') || getSeriesProp('yField')
}));
if (seriesType === 'line' || seriesType === 'scatter') {
if(seriesType === 'line') {
me.add('line', surface.add({
type: 'path',
path: 'M0.5,0.5L16.5,0.5',
zIndex: z,
"stroke-width": series.lineWidth,
"stroke-linejoin": "round",
"stroke-dasharray": series.dash,
stroke: seriesStyle.stroke || '#000',
style: {
cursor: 'pointer'
}
}));
}
if (series.showMarkers || seriesType === 'scatter') {
markerConfig = Ext.apply(series.markerStyle, series.markerConfig || {});
me.add('marker', Ext.chart.Shape[markerConfig.type](surface, {
fill: markerConfig.fill,
x: 8.5,
y: 0.5,
zIndex: z,
radius: markerConfig.radius || markerConfig.size,
style: {
cursor: 'pointer'
}
}));
}
}
else {
me.add('box', surface.add({
type: 'rect',
zIndex: z,
x: 0,
y: 0,
width: 12,
height: 12,
fill: series.getLegendColor(index),
style: {
cursor: 'pointer'
}
}));
}
me.setAttributes({
hidden: false
}, true);
bbox = me.getBBox();
mask = me.add('mask', surface.add({
type: 'rect',
x: bbox.x,
y: bbox.y,
width: bbox.width || 20,
height: bbox.height || 20,
zIndex: (z || 0) + 1000,
fill: '#f00',
opacity: 0,
style: {
'cursor': 'pointer'
}
}));
me.on('mouseover', function() {
label.setStyle({
'font-weight': 'bold'
});
mask.setStyle({
'cursor': 'pointer'
});
series._index = index;
series.highlightItem();
}, me);
me.on('mouseout', function() {
label.setStyle({
'font-weight': 'normal'
});
series._index = index;
series.unHighlightItem();
}, me);
if (!series.visibleInLegend(index)) {
toggle = true;
label.setAttributes({
opacity: 0.5
}, true);
}
me.on('mousedown', function() {
if (!toggle) {
series.hideAll();
label.setAttributes({
opacity: 0.5
}, true);
} else {
series.showAll();
label.setAttributes({
opacity: 1
}, true);
}
toggle = !toggle;
}, me);
me.updatePosition({x:0, y:0});
},
updatePosition: function(relativeTo) {
var me = this,
items = me.items,
ln = items.length,
i = 0,
item;
if (!relativeTo) {
relativeTo = me.legend;
}
for (; i < ln; i++) {
item = items[i];
switch (item.type) {
case 'text':
item.setAttributes({
x: 20 + relativeTo.x + me.x,
y: relativeTo.y + me.y
}, true);
break;
case 'rect':
item.setAttributes({
translate: {
x: relativeTo.x + me.x,
y: relativeTo.y + me.y - 6
}
}, true);
break;
default:
item.setAttributes({
translate: {
x: relativeTo.x + me.x,
y: relativeTo.y + me.y
}
}, true);
}
}
}
});
Ext.define('Ext.chart.Legend', {
requires: ['Ext.chart.LegendItem'],
visible: true,
position: 'bottom',
x: 0,
y: 0,
labelFont: '12px Helvetica, sans-serif',
boxStroke: '#000',
boxStrokeWidth: 1,
boxFill: '#FFF',
itemSpacing: 10,
padding: 5,
width: 0,
height: 0,
boxZIndex: 100,
constructor: function(config) {
var me = this;
if (config) {
Ext.apply(me, config);
}
me.items = [];
me.isVertical = ("left|right|float".indexOf(me.position) !== -1);
me.origX = me.x;
me.origY = me.y;
},
create: function() {
var me = this;
me.createItems();
if (!me.created && me.isDisplayed()) {
me.createBox();
me.created = true;
me.chart.series.each(function(series) {
series.on('titlechange', function() {
me.create();
me.updatePosition();
});
});
}
},
isDisplayed: function() {
return this.visible && this.chart.series.findIndex('showInLegend', true) !== -1;
},
createItems: function() {
var me = this,
chart = me.chart,
surface = chart.surface,
items = me.items,
padding = me.padding,
itemSpacing = me.itemSpacing,
spacingOffset = 2,
maxWidth = 0,
maxHeight = 0,
totalWidth = 0,
totalHeight = 0,
vertical = me.isVertical,
math = Math,
mfloor = math.floor,
mmax = math.max,
index = 0,
i = 0,
len = items ? items.length : 0,
x, y, spacing, item, bbox, height, width;
if (len) {
for (; i < len; i++) {
items[i].destroy();
}
}
items.length = [];
chart.series.each(function(series, i) {
if (series.showInLegend) {
Ext.each([].concat(series.yField), function(field, j) {
item = Ext.create('Ext.chart.LegendItem', {
legend: this,
series: series,
surface: chart.surface,
yFieldIndex: j
});
bbox = item.getBBox();
width = bbox.width;
height = bbox.height;
if (i + j === 0) {
spacing = vertical ? padding + height / 2 : padding;
}
else {
spacing = itemSpacing / (vertical ? 2 : 1);
}
item.x = mfloor(vertical ? padding : totalWidth + spacing);
item.y = mfloor(vertical ? totalHeight + spacing : padding + height / 2);
totalWidth += width + spacing;
totalHeight += height + spacing;
maxWidth = mmax(maxWidth, width);
maxHeight = mmax(maxHeight, height);
items.push(item);
}, this);
}
}, me);
me.width = mfloor((vertical ? maxWidth : totalWidth) + padding * 2);
if (vertical && items.length === 1) {
spacingOffset = 1;
}
me.height = mfloor((vertical ? totalHeight - spacingOffset * spacing : maxHeight) + (padding * 2));
me.itemHeight = maxHeight;
},
getBBox: function() {
var me = this;
return {
x: Math.round(me.x) - me.boxStrokeWidth / 2,
y: Math.round(me.y) - me.boxStrokeWidth / 2,
width: me.width,
height: me.height
};
},
createBox: function() {
var me = this,
box = me.boxSprite = me.chart.surface.add(Ext.apply({
type: 'rect',
stroke: me.boxStroke,
"stroke-width": me.boxStrokeWidth,
fill: me.boxFill,
zIndex: me.boxZIndex
}, me.getBBox()));
box.redraw();
},
updatePosition: function() {
var me = this,
x, y,
legendWidth = me.width,
legendHeight = me.height,
padding = me.padding,
chart = me.chart,
chartBBox = chart.chartBBox,
insets = chart.insetPadding,
chartWidth = chartBBox.width - (insets * 2),
chartHeight = chartBBox.height - (insets * 2),
chartX = chartBBox.x + insets,
chartY = chartBBox.y + insets,
surface = chart.surface,
mfloor = Math.floor;
if (me.isDisplayed()) {
switch(me.position) {
case "left":
x = insets;
y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
break;
case "right":
x = mfloor(surface.width - legendWidth) - insets;
y = mfloor(chartY + chartHeight / 2 - legendHeight / 2);
break;
case "top":
x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
y = insets;
break;
case "bottom":
x = mfloor(chartX + chartWidth / 2 - legendWidth / 2);
y = mfloor(surface.height - legendHeight) - insets;
break;
default:
x = mfloor(me.origX) + insets;
y = mfloor(me.origY) + insets;
}
me.x = x;
me.y = y;
Ext.each(me.items, function(item) {
item.updatePosition();
});
me.boxSprite.setAttributes(me.getBBox(), true);
}
}
});
Ext.define('Ext.chart.Chart', {
alias: 'widget.chart',
extend: 'Ext.draw.Component',
mixins: {
themeManager: 'Ext.chart.theme.Theme',
mask: 'Ext.chart.Mask',
navigation: 'Ext.chart.Navigation'
},
requires: [
'Ext.util.MixedCollection',
'Ext.data.StoreManager',
'Ext.chart.Legend',
'Ext.util.DelayedTask'
],
viewBox: false,
animate: false,
legend: false,
insetPadding: 10,
enginePriority: ['Svg', 'Vml'],
background: false,
constructor: function(config) {
var me = this,
defaultAnim;
me.initTheme(config.theme || me.theme);
if (me.gradients) {
Ext.apply(config, { gradients: me.gradients });
}
if (me.background) {
Ext.apply(config, { background: me.background });
}
if (config.animate) {
defaultAnim = {
easing: 'ease',
duration: 500
};
if (Ext.isObject(config.animate)) {
config.animate = Ext.applyIf(config.animate, defaultAnim);
}
else {
config.animate = defaultAnim;
}
}
me.mixins.mask.constructor.call(me, config);
me.mixins.navigation.constructor.call(me, config);
me.callParent([config]);
},
initComponent: function() {
var me = this,
axes,
series;
me.callParent();
me.addEvents(
'itemmousedown',
'itemmouseup',
'itemmouseover',
'itemmouseout',
'itemclick',
'itemdoubleclick',
'itemdragstart',
'itemdrag',
'itemdragend',
'beforerefresh',
'refresh'
);
Ext.applyIf(me, {
zoom: {
width: 1,
height: 1,
x: 0,
y: 0
}
});
me.maxGutter = [0, 0];
me.store = Ext.data.StoreManager.lookup(me.store);
axes = me.axes;
me.axes = Ext.create('Ext.util.MixedCollection', false, function(a) { return a.position; });
if (axes) {
me.axes.addAll(axes);
}
series = me.series;
me.series = Ext.create('Ext.util.MixedCollection', false, function(a) { return a.seriesId || (a.seriesId = Ext.id(null, 'ext-chart-series-')); });
if (series) {
me.series.addAll(series);
}
if (me.legend !== false) {
me.legend = Ext.create('Ext.chart.Legend', Ext.applyIf({chart:me}, me.legend));
}
me.on({
mousemove: me.onMouseMove,
mouseleave: me.onMouseLeave,
mousedown: me.onMouseDown,
mouseup: me.onMouseUp,
scope: me
});
},
afterComponentLayout: function(width, height) {
var me = this;
if (Ext.isNumber(width) && Ext.isNumber(height)) {
me.curWidth = width;
me.curHeight = height;
me.redraw(true);
}
this.callParent(arguments);
},
redraw: function(resize) {
var me = this,
chartBBox = me.chartBBox = {
x: 0,
y: 0,
height: me.curHeight,
width: me.curWidth
},
legend = me.legend;
me.surface.setSize(chartBBox.width, chartBBox.height);
me.series.each(me.initializeSeries, me);
me.axes.each(me.initializeAxis, me);
me.axes.each(function(axis) {
axis.processView();
});
me.axes.each(function(axis) {
axis.drawAxis(true);
});
if (legend !== false) {
legend.create();
}
me.alignAxes();
if (me.legend !== false) {
legend.updatePosition();
}
me.getMaxGutter();
me.resizing = !!resize;
me.axes.each(me.drawAxis, me);
me.series.each(me.drawCharts, me);
me.resizing = false;
},
afterRender: function() {
var ref,
me = this;
this.callParent();
if (me.categoryNames) {
me.setCategoryNames(me.categoryNames);
}
if (me.tipRenderer) {
ref = me.getFunctionRef(me.tipRenderer);
me.setTipRenderer(ref.fn, ref.scope);
}
me.bindStore(me.store, true);
me.refresh();
},
getEventXY: function(e) {
var me = this,
box = this.surface.getRegion(),
pageXY = e.getXY(),
x = pageXY[0] - box.left,
y = pageXY[1] - box.top;
return [x, y];
},
onClick: function(e) {
var me = this,
position = me.getEventXY(e),
item;
me.series.each(function(series) {
if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
if (series.getItemForPoint) {
item = series.getItemForPoint(position[0], position[1]);
if (item) {
series.fireEvent('itemclick', item);
}
}
}
}, me);
},
onMouseDown: function(e) {
var me = this,
position = me.getEventXY(e),
item;
if (me.mask) {
me.mixins.mask.onMouseDown.call(me, e);
}
me.series.each(function(series) {
if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
if (series.getItemForPoint) {
item = series.getItemForPoint(position[0], position[1]);
if (item) {
series.fireEvent('itemmousedown', item);
}
}
}
}, me);
},
onMouseUp: function(e) {
var me = this,
position = me.getEventXY(e),
item;
if (me.mask) {
me.mixins.mask.onMouseUp.call(me, e);
}
me.series.each(function(series) {
if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
if (series.getItemForPoint) {
item = series.getItemForPoint(position[0], position[1]);
if (item) {
series.fireEvent('itemmouseup', item);
}
}
}
}, me);
},
onMouseMove: function(e) {
var me = this,
position = me.getEventXY(e),
item, last, storeItem, storeField;
if (me.mask) {
me.mixins.mask.onMouseMove.call(me, e);
}
me.series.each(function(series) {
if (Ext.draw.Draw.withinBox(position[0], position[1], series.bbox)) {
if (series.getItemForPoint) {
item = series.getItemForPoint(position[0], position[1]);
last = series._lastItemForPoint;
storeItem = series._lastStoreItem;
storeField = series._lastStoreField;
if (item !== last || item && (item.storeItem != storeItem || item.storeField != storeField)) {
if (last) {
series.fireEvent('itemmouseout', last);
delete series._lastItemForPoint;
delete series._lastStoreField;
delete series._lastStoreItem;
}
if (item) {
series.fireEvent('itemmouseover', item);
series._lastItemForPoint = item;
series._lastStoreItem = item.storeItem;
series._lastStoreField = item.storeField;
}
}
}
} else {
last = series._lastItemForPoint;
if (last) {
series.fireEvent('itemmouseout', last);
delete series._lastItemForPoint;
delete series._lastStoreField;
delete series._lastStoreItem;
}
}
}, me);
},
onMouseLeave: function(e) {
var me = this;
if (me.mask) {
me.mixins.mask.onMouseLeave.call(me, e);
}
me.series.each(function(series) {
delete series._lastItemForPoint;
});
},
delayRefresh: function() {
var me = this;
if (!me.refreshTask) {
me.refreshTask = Ext.create('Ext.util.DelayedTask', me.refresh, me);
}
me.refreshTask.delay(me.refreshBuffer);
},
refresh: function() {
var me = this;
if (me.rendered && me.curWidth != undefined && me.curHeight != undefined) {
if (me.fireEvent('beforerefresh', me) !== false) {
me.redraw();
me.fireEvent('refresh', me);
}
}
},
bindStore: function(store, initial) {
var me = this;
if (!initial && me.store) {
if (store !== me.store && me.store.autoDestroy) {
me.store.destroy();
}
else {
me.store.un('datachanged', me.refresh, me);
me.store.un('add', me.delayRefresh, me);
me.store.un('remove', me.delayRefresh, me);
me.store.un('update', me.delayRefresh, me);
me.store.un('clear', me.refresh, me);
}
}
if (store) {
store = Ext.data.StoreManager.lookup(store);
store.on({
scope: me,
datachanged: me.refresh,
add: me.delayRefresh,
remove: me.delayRefresh,
update: me.delayRefresh,
clear: me.refresh
});
}
me.store = store;
if (store && !initial) {
me.refresh();
}
},
initializeAxis: function(axis) {
var me = this,
chartBBox = me.chartBBox,
w = chartBBox.width,
h = chartBBox.height,
x = chartBBox.x,
y = chartBBox.y,
themeAttrs = me.themeAttrs,
config = {
chart: me
};
if (themeAttrs) {
config.axisStyle = Ext.apply({}, themeAttrs.axis);
config.axisLabelLeftStyle = Ext.apply({}, themeAttrs.axisLabelLeft);
config.axisLabelRightStyle = Ext.apply({}, themeAttrs.axisLabelRight);
config.axisLabelTopStyle = Ext.apply({}, themeAttrs.axisLabelTop);
config.axisLabelBottomStyle = Ext.apply({}, themeAttrs.axisLabelBottom);
config.axisTitleLeftStyle = Ext.apply({}, themeAttrs.axisTitleLeft);
config.axisTitleRightStyle = Ext.apply({}, themeAttrs.axisTitleRight);
config.axisTitleTopStyle = Ext.apply({}, themeAttrs.axisTitleTop);
config.axisTitleBottomStyle = Ext.apply({}, themeAttrs.axisTitleBottom);
}
switch (axis.position) {
case 'top':
Ext.apply(config, {
length: w,
width: h,
x: x,
y: y
});
break;
case 'bottom':
Ext.apply(config, {
length: w,
width: h,
x: x,
y: h
});
break;
case 'left':
Ext.apply(config, {
length: h,
width: w,
x: x,
y: h
});
break;
case 'right':
Ext.apply(config, {
length: h,
width: w,
x: w,
y: h
});
break;
}
if (!axis.chart) {
Ext.apply(config, axis);
axis = me.axes.replace(Ext.createByAlias('axis.' + axis.type.toLowerCase(), config));
}
else {
Ext.apply(axis, config);
}
},
alignAxes: function() {
var me = this,
axes = me.axes,
legend = me.legend,
edges = ['top', 'right', 'bottom', 'left'],
chartBBox,
insetPadding = me.insetPadding,
insets = {
top: insetPadding,
right: insetPadding,
bottom: insetPadding,
left: insetPadding
};
function getAxis(edge) {
var i = axes.findIndex('position', edge);
return (i < 0) ? null : axes.getAt(i);
}
Ext.each(edges, function(edge) {
var isVertical = (edge === 'left' || edge === 'right'),
axis = getAxis(edge),
bbox;
if (legend !== false) {
if (legend.position === edge) {
bbox = legend.getBBox();
insets[edge] += (isVertical ? bbox.width : bbox.height) + insets[edge];
}
}
if (axis && axis.bbox) {
bbox = axis.bbox;
insets[edge] += (isVertical ? bbox.width : bbox.height);
}
});
chartBBox = {
x: insets.left,
y: insets.top,
width: me.curWidth - insets.left - insets.right,
height: me.curHeight - insets.top - insets.bottom
};
me.chartBBox = chartBBox;
axes.each(function(axis) {
var pos = axis.position,
isVertical = (pos === 'left' || pos === 'right');
axis.x = (pos === 'right' ? chartBBox.x + chartBBox.width : chartBBox.x);
axis.y = (pos === 'top' ? chartBBox.y : chartBBox.y + chartBBox.height);
axis.width = (isVertical ? chartBBox.width : chartBBox.height);
axis.length = (isVertical ? chartBBox.height : chartBBox.width);
});
},
initializeSeries: function(series, idx) {
var me = this,
themeAttrs = me.themeAttrs,
seriesObj, markerObj, seriesThemes, st,
markerThemes, colorArrayStyle = [],
i = 0, l,
config = {
chart: me,
seriesId: series.seriesId
};
if (themeAttrs) {
seriesThemes = themeAttrs.seriesThemes;
markerThemes = themeAttrs.markerThemes;
seriesObj = Ext.apply({}, themeAttrs.series);
markerObj = Ext.apply({}, themeAttrs.marker);
config.seriesStyle = Ext.apply(seriesObj, seriesThemes[idx % seriesThemes.length]);
config.seriesLabelStyle = Ext.apply({}, themeAttrs.seriesLabel);
config.markerStyle = Ext.apply(markerObj, markerThemes[idx % markerThemes.length]);
if (themeAttrs.colors) {
config.colorArrayStyle = themeAttrs.colors;
} else {
colorArrayStyle = [];
for (l = seriesThemes.length; i < l; i++) {
st = seriesThemes[i];
if (st.fill || st.stroke) {
colorArrayStyle.push(st.fill || st.stroke);
}
}
if (colorArrayStyle.length) {
config.colorArrayStyle = colorArrayStyle;
}
}
config.seriesIdx = idx;
}
if (series instanceof Ext.chart.series.Series) {
Ext.apply(series, config);
} else {
Ext.applyIf(config, series);
series = me.series.replace(Ext.createByAlias('series.' + series.type.toLowerCase(), config));
}
if (series.initialize) {
series.initialize();
}
},
getMaxGutter: function() {
var me = this,
maxGutter = [0, 0];
me.series.each(function(s) {
var gutter = s.getGutters && s.getGutters() || [0, 0];
maxGutter[0] = Math.max(maxGutter[0], gutter[0]);
maxGutter[1] = Math.max(maxGutter[1], gutter[1]);
});
me.maxGutter = maxGutter;
},
drawAxis: function(axis) {
axis.drawAxis();
},
drawCharts: function(series) {
series.triggerafterrender = false;
series.drawSeries();
if (!this.animate) {
series.fireEvent('afterrender');
}
},
destroy: function() {
this.surface.destroy();
this.bindStore(null);
this.callParent(arguments);
}
});
Ext.define('Ext.chart.Highlight', {
requires: ['Ext.fx.Anim'],
highlight: false,
highlightCfg : null,
constructor: function(config) {
if (config.highlight) {
if (config.highlight !== true) {
this.highlightCfg = Ext.apply({}, config.highlight);
}
else {
this.highlightCfg = {
fill: '#fdd',
radius: 20,
lineWidth: 5,
stroke: '#f55'
};
}
}
},
highlightItem: function(item) {
if (!item) {
return;
}
var me = this,
sprite = item.sprite,
opts = me.highlightCfg,
surface = me.chart.surface,
animate = me.chart.animate,
p, from, to, pi;
if (!me.highlight || !sprite || sprite._highlighted) {
return;
}
if (sprite._anim) {
sprite._anim.paused = true;
}
sprite._highlighted = true;
if (!sprite._defaults) {
sprite._defaults = Ext.apply({}, sprite.attr);
from = {};
to = {};
for (p in opts) {
if (! (p in sprite._defaults)) {
sprite._defaults[p] = surface.availableAttrs[p];
}
from[p] = sprite._defaults[p];
to[p] = opts[p];
if (Ext.isObject(opts[p])) {
from[p] = {};
to[p] = {};
Ext.apply(sprite._defaults[p], sprite.attr[p]);
Ext.apply(from[p], sprite._defaults[p]);
for (pi in sprite._defaults[p]) {
if (! (pi in opts[p])) {
to[p][pi] = from[p][pi];
} else {
to[p][pi] = opts[p][pi];
}
}
for (pi in opts[p]) {
if (! (pi in to[p])) {
to[p][pi] = opts[p][pi];
}
}
}
}
sprite._from = from;
sprite._to = to;
sprite._endStyle = to;
}
if (animate) {
sprite._anim = Ext.create('Ext.fx.Anim', {
target: sprite,
from: sprite._from,
to: sprite._to,
duration: 150
});
} else {
sprite.setAttributes(sprite._to, true);
}
},
unHighlightItem: function() {
if (!this.highlight || !this.items) {
return;
}
var me = this,
items = me.items,
len = items.length,
opts = me.highlightCfg,
animate = me.chart.animate,
i = 0,
obj, p, sprite;
for (; i < len; i++) {
if (!items[i]) {
continue;
}
sprite = items[i].sprite;
if (sprite && sprite._highlighted) {
if (sprite._anim) {
sprite._anim.paused = true;
}
obj = {};
for (p in opts) {
if (Ext.isObject(sprite._defaults[p])) {
obj[p] = {};
Ext.apply(obj[p], sprite._defaults[p]);
}
else {
obj[p] = sprite._defaults[p];
}
}
if (animate) {
sprite._endStyle = obj;
sprite._anim = Ext.create('Ext.fx.Anim', {
target: sprite,
to: obj,
duration: 150
});
}
else {
sprite.setAttributes(obj, true);
}
delete sprite._highlighted;
}
}
},
cleanHighlights: function() {
if (!this.highlight) {
return;
}
var group = this.group,
markerGroup = this.markerGroup,
i = 0,
l;
for (l = group.getCount(); i < l; i++) {
delete group.getAt(i)._defaults;
}
if (markerGroup) {
for (l = markerGroup.getCount(); i < l; i++) {
delete markerGroup.getAt(i)._defaults;
}
}
}
});
Ext.define('Ext.chart.Label', {
requires: ['Ext.draw.Color'],
//@private a regex to parse url type colors.
colorStringRe: /url\s*\(\s*#([^\/)]+)\s*\)/,
//@private the mixin constructor. Used internally by Series.
constructor: function(config) {
var me = this;
me.label = Ext.applyIf(me.label || {},
{
display: "none",
color: "#000",
field: "name",
minMargin: 50,
font: "11px Helvetica, sans-serif",
orientation: "horizontal",
renderer: function(v) {
return v;
}
});
if (me.label.display !== 'none') {
me.labelsGroup = me.chart.surface.getGroup(me.seriesId + '-labels');
}
},
//@private a method to render all labels in the labelGroup
renderLabels: function() {
var me = this,
chart = me.chart,
gradients = chart.gradients,
items = me.items,
animate = chart.animate,
config = me.label,
display = config.display,
color = config.color,
field = [].concat(config.field),
group = me.labelsGroup,
store = me.chart.store,
len = store.getCount(),
itemLength = (items || 0) && items.length,
ratio = itemLength / len,
gradientsCount = (gradients || 0) && gradients.length,
Color = Ext.draw.Color,
gradient, i, count, index, j, k, colorStopTotal, colorStopIndex, colorStop, item, label,
storeItem, sprite, spriteColor, spriteBrightness, labelColor, colorString;
if (display == 'none') {
return;
}
for (i = 0, count = 0; i < len; i++) {
index = 0;
for (j = 0; j < ratio; j++) {
item = items[count];
label = group.getAt(count);
storeItem = store.getAt(i);
while(this.__excludes && this.__excludes[index]) {
index++;
}
if (!item && label) {
label.hide(true);
}
if (item && field[j]) {
if (!label) {
label = me.onCreateLabel(storeItem, item, i, display, j, index);
}
me.onPlaceLabel(label, storeItem, item, i, display, animate, j, index);
if (config.contrast && item.sprite) {
sprite = item.sprite;
if (sprite._endStyle) {
colorString = sprite._endStyle.fill;
}
else if (sprite._to) {
colorString = sprite._to.fill;
}
else {
colorString = sprite.attr.fill;
}
colorString = colorString || sprite.attr.fill;
spriteColor = Color.fromString(colorString);
if (colorString && !spriteColor) {
colorString = colorString.match(me.colorStringRe)[1];
for (k = 0; k < gradientsCount; k++) {
gradient = gradients[k];
if (gradient.id == colorString) {
colorStop = 0; colorStopTotal = 0;
for (colorStopIndex in gradient.stops) {
colorStop++;
colorStopTotal += Color.fromString(gradient.stops[colorStopIndex].color).getGrayscale();
}
spriteBrightness = (colorStopTotal / colorStop) / 255;
break;
}
}
}
else {
spriteBrightness = spriteColor.getGrayscale() / 255;
}
if (label.isOutside) {
spriteBrightness = 1;
}
labelColor = Color.fromString(label.attr.color || label.attr.fill).getHSL();
labelColor[2] = spriteBrightness > 0.5 ? 0.2 : 0.8;
label.setAttributes({
fill: String(Color.fromHSL.apply({}, labelColor))
}, true);
}
}
count++;
index++;
}
}
me.hideLabels(count);
},
//@private a method to hide labels.
hideLabels: function(index) {
var labelsGroup = this.labelsGroup, len;
if (labelsGroup) {
len = labelsGroup.getCount();
while (len-->index) {
labelsGroup.getAt(len).hide(true);
}
}
}
});
Ext.define('Ext.chart.MaskLayer', {
extend: 'Ext.Component',
constructor: function(config) {
config = Ext.apply(config || {}, {
style: 'position:absolute;background-color:#888;cursor:move;opacity:0.6;border:1px solid #222;'
});
this.callParent([config]);
},
initComponent: function() {
var me = this;
me.callParent(arguments);
me.addEvents(
'mousedown',
'mouseup',
'mousemove',
'mouseenter',
'mouseleave'
);
},
initDraggable: function() {
this.callParent(arguments);
this.dd.onStart = function (e) {
var me = this,
comp = me.comp;
this.startPosition = comp.getPosition(true);
if (comp.ghost && !comp.liveDrag) {
me.proxy = comp.ghost();
me.dragTarget = me.proxy.header.el;
}
if (me.constrain || me.constrainDelegate) {
me.constrainTo = me.calculateConstrainRegion();
}
};
}
});
Ext.define('Ext.chart.TipSurface', {
extend: 'Ext.draw.Component',
spriteArray: false,
renderFirst: true,
constructor: function(config) {
this.callParent([config]);
if (config.sprites) {
this.spriteArray = [].concat(config.sprites);
delete config.sprites;
}
},
onRender: function() {
var me = this,
i = 0,
l = 0,
sp,
sprites;
this.callParent(arguments);
sprites = me.spriteArray;
if (me.renderFirst && sprites) {
me.renderFirst = false;
for (l = sprites.length; i < l; i++) {
sp = me.surface.add(sprites[i]);
sp.setAttributes({
hidden: false
},
true);
}
}
}
});
Ext.define('Ext.chart.Tip', {
requires: ['Ext.tip.ToolTip', 'Ext.chart.TipSurface'],
constructor: function(config) {
var me = this,
surface,
sprites,
tipSurface;
if (config.tips) {
me.tipTimeout = null;
me.tipConfig = Ext.apply({}, config.tips, {
renderer: Ext.emptyFn,
constrainPosition: false
});
me.tooltip = Ext.create('Ext.tip.ToolTip', me.tipConfig);
Ext.getBody().on('mousemove', me.tooltip.onMouseMove, me.tooltip);
if (me.tipConfig.surface) {
surface = me.tipConfig.surface;
sprites = surface.sprites;
tipSurface = Ext.create('Ext.chart.TipSurface', {
id: 'tipSurfaceComponent',
sprites: sprites
});
if (surface.width && surface.height) {
tipSurface.setSize(surface.width, surface.height);
}
me.tooltip.add(tipSurface);
me.spriteTip = tipSurface;
}
}
},
showTip: function(item) {
var me = this;
if (!me.tooltip) {
return;
}
clearTimeout(me.tipTimeout);
var tooltip = me.tooltip,
spriteTip = me.spriteTip,
tipConfig = me.tipConfig,
trackMouse = tooltip.trackMouse,
sprite, surface, surfaceExt, pos, x, y;
if (!trackMouse) {
tooltip.trackMouse = true;
sprite = item.sprite;
surface = sprite.surface;
surfaceExt = Ext.get(surface.getId());
if (surfaceExt) {
pos = surfaceExt.getXY();
x = pos[0] + (sprite.attr.x || 0) + (sprite.attr.translation && sprite.attr.translation.x || 0);
y = pos[1] + (sprite.attr.y || 0) + (sprite.attr.translation && sprite.attr.translation.y || 0);
tooltip.targetXY = [x, y];
}
}
if (spriteTip) {
tipConfig.renderer.call(tooltip, item.storeItem, item, spriteTip.surface);
} else {
tipConfig.renderer.call(tooltip, item.storeItem, item);
}
tooltip.show();
tooltip.trackMouse = trackMouse;
},
hideTip: function(item) {
var tooltip = this.tooltip;
if (!tooltip) {
return;
}
clearTimeout(this.tipTimeout);
this.tipTimeout = setTimeout(function() {
tooltip.hide();
}, 0);
}
});
Ext.define('Ext.chart.axis.Abstract', {
requires: ['Ext.chart.Chart'],
constructor: function(config) {
config = config || {};
var me = this,
pos = config.position || 'left';
pos = pos.charAt(0).toUpperCase() + pos.substring(1);
config.label = Ext.apply(config['axisLabel' + pos + 'Style'] || {}, config.label || {});
config.axisTitleStyle = Ext.apply(config['axisTitle' + pos + 'Style'] || {}, config.labelTitle || {});
Ext.apply(me, config);
me.fields = [].concat(me.fields);
this.callParent();
me.labels = [];
me.getId();
me.labelGroup = me.chart.surface.getGroup(me.axisId + "-labels");
},
alignment: null,
grid: false,
steps: 10,
x: 0,
y: 0,
minValue: 0,
maxValue: 0,
getId: function() {
return this.axisId || (this.axisId = Ext.id(null, 'ext-axis-'));
},
processView: Ext.emptyFn,
drawAxis: Ext.emptyFn,
addDisplayAndLabels: Ext.emptyFn
});
Ext.define('Ext.chart.axis.Axis', {
extend: 'Ext.chart.axis.Abstract',
alternateClassName: 'Ext.chart.Axis',
requires: ['Ext.draw.Draw'],
//@private force min/max values from store
forceMinMax: false,
dashSize: 3,
position: 'bottom',
skipFirst: false,
length: 0,
width: 0,
majorTickSteps: false,
applyData: Ext.emptyFn,
calcEnds: function() {
var me = this,
math = Math,
mmax = math.max,
mmin = math.min,
store = me.chart.substore || me.chart.store,
series = me.chart.series.items,
fields = me.fields,
ln = fields.length,
min = isNaN(me.minimum) ? Infinity : me.minimum,
max = isNaN(me.maximum) ? -Infinity : me.maximum,
prevMin = me.prevMin,
prevMax = me.prevMax,
aggregate = false,
total = 0,
excludes = [],
outfrom, outto,
i, l, values, rec, out;
for (i = 0, l = series.length; !aggregate && i < l; i++) {
aggregate = aggregate || series[i].stacked;
excludes = series[i].__excludes || excludes;
}
store.each(function(record) {
if (aggregate) {
if (!isFinite(min)) {
min = 0;
}
for (values = [0, 0], i = 0; i < ln; i++) {
if (excludes[i]) {
continue;
}
rec = record.get(fields[i]);
values[+(rec > 0)] += math.abs(rec);
}
max = mmax(max, -values[0], values[1]);
min = mmin(min, -values[0], values[1]);
}
else {
for (i = 0; i < ln; i++) {
if (excludes[i]) {
continue;
}
value = record.get(fields[i]);
max = mmax(max, value);
min = mmin(min, value);
}
}
});
if (!isFinite(max)) {
max = me.prevMax || 0;
}
if (!isFinite(min)) {
min = me.prevMin || 0;
}
if (min != max && (max != (max >> 0))) {
max = (max >> 0) + 1;
}
out = Ext.draw.Draw.snapEnds(min, max, me.majorTickSteps !== false ? (me.majorTickSteps +1) : me.steps);
outfrom = out.from;
outto = out.to;
if (me.forceMinMax) {
if (!isNaN(max)) {
out.to = max;
}
if (!isNaN(min)) {
out.from = min;
}
}
if (!isNaN(me.maximum)) {
out.to = me.maximum;
}
if (!isNaN(me.minimum)) {
out.from = me.minimum;
}
out.step = (out.to - out.from) / (outto - outfrom) * out.step;
if (me.adjustMaximumByMajorUnit) {
out.to += out.step;
}
if (me.adjustMinimumByMajorUnit) {
out.from -= out.step;
}
me.prevMin = min == max? 0 : min;
me.prevMax = max;
return out;
},
drawAxis: function (init) {
var me = this,
i, j,
x = me.x,
y = me.y,
gutterX = me.chart.maxGutter[0],
gutterY = me.chart.maxGutter[1],
dashSize = me.dashSize,
subDashesX = me.minorTickSteps || 0,
subDashesY = me.minorTickSteps || 0,
length = me.length,
position = me.position,
inflections = [],
calcLabels = false,
stepCalcs = me.applyData(),
step = stepCalcs.step,
steps = stepCalcs.steps,
from = stepCalcs.from,
to = stepCalcs.to,
trueLength,
currentX,
currentY,
path,
prev,
dashesX,
dashesY,
delta;
if (me.hidden || isNaN(step) || (from == to)) {
return;
}
me.from = stepCalcs.from;
me.to = stepCalcs.to;
if (position == 'left' || position == 'right') {
currentX = Math.floor(x) + 0.5;
path = ["M", currentX, y, "l", 0, -length];
trueLength = length - (gutterY * 2);
}
else {
currentY = Math.floor(y) + 0.5;
path = ["M", x, currentY, "l", length, 0];
trueLength = length - (gutterX * 2);
}
delta = trueLength / (steps || 1);
dashesX = Math.max(subDashesX +1, 0);
dashesY = Math.max(subDashesY +1, 0);
if (me.type == 'Numeric') {
calcLabels = true;
me.labels = [stepCalcs.from];
}
if (position == 'right' || position == 'left') {
currentY = y - gutterY;
currentX = x - ((position == 'left') * dashSize * 2);
while (currentY >= y - gutterY - trueLength) {
path.push("M", currentX, Math.floor(currentY) + 0.5, "l", dashSize * 2 + 1, 0);
if (currentY != y - gutterY) {
for (i = 1; i < dashesY; i++) {
path.push("M", currentX + dashSize, Math.floor(currentY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
}
}
inflections.push([ Math.floor(x), Math.floor(currentY) ]);
currentY -= delta;
if (calcLabels) {
me.labels.push(me.labels[me.labels.length -1] + step);
}
if (delta === 0) {
break;
}
}
if (Math.round(currentY + delta - (y - gutterY - trueLength))) {
path.push("M", currentX, Math.floor(y - length + gutterY) + 0.5, "l", dashSize * 2 + 1, 0);
for (i = 1; i < dashesY; i++) {
path.push("M", currentX + dashSize, Math.floor(y - length + gutterY + delta * i / dashesY) + 0.5, "l", dashSize + 1, 0);
}
inflections.push([ Math.floor(x), Math.floor(currentY) ]);
if (calcLabels) {
me.labels.push(me.labels[me.labels.length -1] + step);
}
}
} else {
currentX = x + gutterX;
currentY = y - ((position == 'top') * dashSize * 2);
while (currentX <= x + gutterX + trueLength) {
path.push("M", Math.floor(currentX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
if (currentX != x + gutterX) {
for (i = 1; i < dashesX; i++) {
path.push("M", Math.floor(currentX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
}
}
inflections.push([ Math.floor(currentX), Math.floor(y) ]);
currentX += delta;
if (calcLabels) {
me.labels.push(me.labels[me.labels.length -1] + step);
}
if (delta === 0) {
break;
}
}
if (Math.round(currentX - delta - (x + gutterX + trueLength))) {
path.push("M", Math.floor(x + length - gutterX) + 0.5, currentY, "l", 0, dashSize * 2 + 1);
for (i = 1; i < dashesX; i++) {
path.push("M", Math.floor(x + length - gutterX - delta * i / dashesX) + 0.5, currentY, "l", 0, dashSize + 1);
}
inflections.push([ Math.floor(currentX), Math.floor(y) ]);
if (calcLabels) {
me.labels.push(me.labels[me.labels.length -1] + step);
}
}
}
if (!me.axis) {
me.axis = me.chart.surface.add(Ext.apply({
type: 'path',
path: path
}, me.axisStyle));
}
me.axis.setAttributes({
path: path
}, true);
me.inflections = inflections;
if (!init && me.grid) {
me.drawGrid();
}
me.axisBBox = me.axis.getBBox();
me.drawLabel();
},
drawGrid: function() {
var me = this,
surface = me.chart.surface,
grid = me.grid,
odd = grid.odd,
even = grid.even,
inflections = me.inflections,
ln = inflections.length - ((odd || even)? 0 : 1),
position = me.position,
gutter = me.chart.maxGutter,
width = me.width - 2,
vert = false,
point, prevPoint,
i = 1,
path = [], styles, lineWidth, dlineWidth,
oddPath = [], evenPath = [];
if ((gutter[1] !== 0 && (position == 'left' || position == 'right')) ||
(gutter[0] !== 0 && (position == 'top' || position == 'bottom'))) {
i = 0;
ln++;
}
for (; i < ln; i++) {
point = inflections[i];
prevPoint = inflections[i - 1];
if (odd || even) {
path = (i % 2)? oddPath : evenPath;
styles = ((i % 2)? odd : even) || {};
lineWidth = (styles.lineWidth || styles['stroke-width'] || 0) / 2;
dlineWidth = 2 * lineWidth;
if (position == 'left') {
path.push("M", prevPoint[0] + 1 + lineWidth, prevPoint[1] + 0.5 - lineWidth,
"L", prevPoint[0] + 1 + width - lineWidth, prevPoint[1] + 0.5 - lineWidth,
"L", point[0] + 1 + width - lineWidth, point[1] + 0.5 + lineWidth,
"L", point[0] + 1 + lineWidth, point[1] + 0.5 + lineWidth, "Z");
}
else if (position == 'right') {
path.push("M", prevPoint[0] - lineWidth, prevPoint[1] + 0.5 - lineWidth,
"L", prevPoint[0] - width + lineWidth, prevPoint[1] + 0.5 - lineWidth,
"L", point[0] - width + lineWidth, point[1] + 0.5 + lineWidth,
"L", point[0] - lineWidth, point[1] + 0.5 + lineWidth, "Z");
}
else if (position == 'top') {
path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + lineWidth,
"L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] + 1 + width - lineWidth,
"L", point[0] + 0.5 - lineWidth, point[1] + 1 + width - lineWidth,
"L", point[0] + 0.5 - lineWidth, point[1] + 1 + lineWidth, "Z");
}
else {
path.push("M", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - lineWidth,
"L", prevPoint[0] + 0.5 + lineWidth, prevPoint[1] - width + lineWidth,
"L", point[0] + 0.5 - lineWidth, point[1] - width + lineWidth,
"L", point[0] + 0.5 - lineWidth, point[1] - lineWidth, "Z");
}
} else {
if (position == 'left') {
path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", width, 0]);
}
else if (position == 'right') {
path = path.concat(["M", point[0] - 0.5, point[1] + 0.5, "l", -width, 0]);
}
else if (position == 'top') {
path = path.concat(["M", point[0] + 0.5, point[1] + 0.5, "l", 0, width]);
}
else {
path = path.concat(["M", point[0] + 0.5, point[1] - 0.5, "l", 0, -width]);
}
}
}
if (odd || even) {
if (oddPath.length) {
if (!me.gridOdd && oddPath.length) {
me.gridOdd = surface.add({
type: 'path',
path: oddPath
});
}
me.gridOdd.setAttributes(Ext.apply({
path: oddPath,
hidden: false
}, odd || {}), true);
}
if (evenPath.length) {
if (!me.gridEven) {
me.gridEven = surface.add({
type: 'path',
path: evenPath
});
}
me.gridEven.setAttributes(Ext.apply({
path: evenPath,
hidden: false
}, even || {}), true);
}
}
else {
if (path.length) {
if (!me.gridLines) {
me.gridLines = me.chart.surface.add({
type: 'path',
path: path,
"stroke-width": me.lineWidth || 1,
stroke: me.gridColor || '#ccc'
});
}
me.gridLines.setAttributes({
hidden: false,
path: path
}, true);
}
else if (me.gridLines) {
me.gridLines.hide(true);
}
}
},
//@private
getOrCreateLabel: function(i, text) {
var me = this,
labelGroup = me.labelGroup,
textLabel = labelGroup.getAt(i),
surface = me.chart.surface;
if (textLabel) {
if (text != textLabel.attr.text) {
textLabel.setAttributes(Ext.apply({
text: text
}, me.label), true);
textLabel._bbox = textLabel.getBBox();
}
}
else {
textLabel = surface.add(Ext.apply({
group: labelGroup,
type: 'text',
x: 0,
y: 0,
text: text
}, me.label));
surface.renderItem(textLabel);
textLabel._bbox = textLabel.getBBox();
}
if (me.label.rotation) {
textLabel.setAttributes({
rotation: {
degrees: 0
}
}, true);
textLabel._ubbox = textLabel.getBBox();
textLabel.setAttributes(me.label, true);
} else {
textLabel._ubbox = textLabel._bbox;
}
return textLabel;
},
rect2pointArray: function(sprite) {
var surface = this.chart.surface,
rect = surface.getBBox(sprite, true),
p1 = [rect.x, rect.y],
p1p = p1.slice(),
p2 = [rect.x + rect.width, rect.y],
p2p = p2.slice(),
p3 = [rect.x + rect.width, rect.y + rect.height],
p3p = p3.slice(),
p4 = [rect.x, rect.y + rect.height],
p4p = p4.slice(),
matrix = sprite.matrix;
p1[0] = matrix.x.apply(matrix, p1p);
p1[1] = matrix.y.apply(matrix, p1p);
p2[0] = matrix.x.apply(matrix, p2p);
p2[1] = matrix.y.apply(matrix, p2p);
p3[0] = matrix.x.apply(matrix, p3p);
p3[1] = matrix.y.apply(matrix, p3p);
p4[0] = matrix.x.apply(matrix, p4p);
p4[1] = matrix.y.apply(matrix, p4p);
return [p1, p2, p3, p4];
},
intersect: function(l1, l2) {
var r1 = this.rect2pointArray(l1),
r2 = this.rect2pointArray(l2);
return !!Ext.draw.Draw.intersect(r1, r2).length;
},
drawHorizontalLabels: function() {
var me = this,
labelConf = me.label,
floor = Math.floor,
max = Math.max,
axes = me.chart.axes,
position = me.position,
inflections = me.inflections,
ln = inflections.length,
labels = me.labels,
labelGroup = me.labelGroup,
maxHeight = 0,
ratio,
gutterY = me.chart.maxGutter[1],
ubbox, bbox, point, prevX, prevLabel,
projectedWidth = 0,
textLabel, attr, textRight, text,
label, last, x, y, i, firstLabel;
last = ln - 1;
point = inflections[0];
firstLabel = me.getOrCreateLabel(0, me.label.renderer(labels[0]));
ratio = Math.abs(Math.sin(labelConf.rotate && (labelConf.rotate.degrees * Math.PI / 180) || 0)) >> 0;
for (i = 0; i < ln; i++) {
point = inflections[i];
text = me.label.renderer(labels[i]);
textLabel = me.getOrCreateLabel(i, text);
bbox = textLabel._bbox;
maxHeight = max(maxHeight, bbox.height + me.dashSize + me.label.padding);
x = floor(point[0] - (ratio? bbox.height : bbox.width) / 2);
if (me.chart.maxGutter[0] == 0) {
if (i == 0 && axes.findIndex('position', 'left') == -1) {
x = point[0];
}
else if (i == last && axes.findIndex('position', 'right') == -1) {
x = point[0] - bbox.width;
}
}
if (position == 'top') {
y = point[1] - (me.dashSize * 2) - me.label.padding - (bbox.height / 2);
}
else {
y = point[1] + (me.dashSize * 2) + me.label.padding + (bbox.height / 2);
}
textLabel.setAttributes({
hidden: false,
x: x,
y: y
}, true);
if (i != 0 && (me.intersect(textLabel, prevLabel)
|| me.intersect(textLabel, firstLabel))) {
textLabel.hide(true);
continue;
}
prevLabel = textLabel;
}
return maxHeight;
},
drawVerticalLabels: function() {
var me = this,
inflections = me.inflections,
position = me.position,
ln = inflections.length,
labels = me.labels,
maxWidth = 0,
max = Math.max,
floor = Math.floor,
ceil = Math.ceil,
axes = me.chart.axes,
gutterY = me.chart.maxGutter[1],
ubbox, bbox, point, prevLabel,
projectedWidth = 0,
textLabel, attr, textRight, text,
label, last, x, y, i;
last = ln;
for (i = 0; i < last; i++) {
point = inflections[i];
text = me.label.renderer(labels[i]);
textLabel = me.getOrCreateLabel(i, text);
bbox = textLabel._bbox;
maxWidth = max(maxWidth, bbox.width + me.dashSize + me.label.padding);
y = point[1];
if (gutterY < bbox.height / 2) {
if (i == last - 1 && axes.findIndex('position', 'top') == -1) {
y = me.y - me.length + ceil(bbox.height / 2);
}
else if (i == 0 && axes.findIndex('position', 'bottom') == -1) {
y = me.y - floor(bbox.height / 2);
}
}
if (position == 'left') {
x = point[0] - bbox.width - me.dashSize - me.label.padding - 2;
}
else {
x = point[0] + me.dashSize + me.label.padding + 2;
}
textLabel.setAttributes(Ext.apply({
hidden: false,
x: x,
y: y
}, me.label), true);
if (i != 0 && me.intersect(textLabel, prevLabel)) {
textLabel.hide(true);
continue;
}
prevLabel = textLabel;
}
return maxWidth;
},
drawLabel: function() {
var me = this,
position = me.position,
labelGroup = me.labelGroup,
inflections = me.inflections,
maxWidth = 0,
maxHeight = 0,
ln, i;
if (position == 'left' || position == 'right') {
maxWidth = me.drawVerticalLabels();
} else {
maxHeight = me.drawHorizontalLabels();
}
ln = labelGroup.getCount();
i = inflections.length;
for (; i < ln; i++) {
labelGroup.getAt(i).hide(true);
}
me.bbox = {};
Ext.apply(me.bbox, me.axisBBox);
me.bbox.height = maxHeight;
me.bbox.width = maxWidth;
if (Ext.isString(me.title)) {
me.drawTitle(maxWidth, maxHeight);
}
},
elipsis: function(sprite, text, desiredWidth, minWidth, center) {
var bbox,
x;
if (desiredWidth < minWidth) {
sprite.hide(true);
return false;
}
while (text.length > 4) {
text = text.substr(0, text.length - 4) + "...";
sprite.setAttributes({
text: text
}, true);
bbox = sprite.getBBox();
if (bbox.width < desiredWidth) {
if (typeof center == 'number') {
sprite.setAttributes({
x: Math.floor(center - (bbox.width / 2))
}, true);
}
break;
}
}
return true;
},
setTitle: function(title) {
this.title = title;
this.drawLabel();
},
drawTitle: function(maxWidth, maxHeight) {
var me = this,
position = me.position,
surface = me.chart.surface,
displaySprite = me.displaySprite,
title = me.title,
rotate = (position == 'left' || position == 'right'),
x = me.x,
y = me.y,
base, bbox, pad;
if (displaySprite) {
displaySprite.setAttributes({text: title}, true);
} else {
base = {
type: 'text',
x: 0,
y: 0,
text: title
};
displaySprite = me.displaySprite = surface.add(Ext.apply(base, me.axisTitleStyle, me.labelTitle));
surface.renderItem(displaySprite);
}
bbox = displaySprite.getBBox();
pad = me.dashSize + me.label.padding;
if (rotate) {
y -= ((me.length / 2) - (bbox.height / 2));
if (position == 'left') {
x -= (maxWidth + pad + (bbox.width / 2));
}
else {
x += (maxWidth + pad + bbox.width - (bbox.width / 2));
}
me.bbox.width += bbox.width + 10;
}
else {
x += (me.length / 2) - (bbox.width * 0.5);
if (position == 'top') {
y -= (maxHeight + pad + (bbox.height * 0.3));
}
else {
y += (maxHeight + pad + (bbox.height * 0.8));
}
me.bbox.height += bbox.height + 10;
}
displaySprite.setAttributes({
translate: {
x: x,
y: y
}
}, true);
}
});
Ext.define('Ext.chart.axis.Category', {
extend: 'Ext.chart.axis.Axis',
alternateClassName: 'Ext.chart.CategoryAxis',
alias: 'axis.category',
categoryNames: null,
calculateCategoryCount: false,
setLabels: function() {
var store = this.chart.store,
fields = this.fields,
ln = fields.length,
i;
this.labels = [];
store.each(function(record) {
for (i = 0; i < ln; i++) {
this.labels.push(record.get(fields[i]));
}
}, this);
},
applyData: function() {
this.callParent();
this.setLabels();
var count = this.chart.store.getCount();
return {
from: 0,
to: count,
power: 1,
step: 1,
steps: count - 1
};
}
});
Ext.define('Ext.chart.axis.Gauge', {
extend: 'Ext.chart.axis.Abstract',
position: 'gauge',
alias: 'axis.gauge',
drawAxis: function(init) {
var chart = this.chart,
surface = chart.surface,
bbox = chart.chartBBox,
centerX = bbox.x + (bbox.width / 2),
centerY = bbox.y + bbox.height,
margin = this.margin || 10,
rho = Math.min(bbox.width, 2 * bbox.height) /2 + margin,
sprites = [], sprite,
steps = this.steps,
i, pi = Math.PI,
cos = Math.cos,
sin = Math.sin;
if (this.sprites && !chart.resizing) {
this.drawLabel();
return;
}
if (this.margin >= 0) {
if (!this.sprites) {
for (i = 0; i <= steps; i++) {
sprite = surface.add({
type: 'path',
path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
centerY + (rho - margin) * sin(i / steps * pi - pi),
'L', centerX + rho * cos(i / steps * pi - pi),
centerY + rho * sin(i / steps * pi - pi), 'Z'],
stroke: '#ccc'
});
sprite.setAttributes({
hidden: false
}, true);
sprites.push(sprite);
}
} else {
sprites = this.sprites;
for (i = 0; i <= steps; i++) {
sprites[i].setAttributes({
path: ['M', centerX + (rho - margin) * cos(i / steps * pi - pi),
centerY + (rho - margin) * sin(i / steps * pi - pi),
'L', centerX + rho * cos(i / steps * pi - pi),
centerY + rho * sin(i / steps * pi - pi), 'Z'],
stroke: '#ccc'
}, true);
}
}
}
this.sprites = sprites;
this.drawLabel();
if (this.title) {
this.drawTitle();
}
},
drawTitle: function() {
var me = this,
chart = me.chart,
surface = chart.surface,
bbox = chart.chartBBox,
labelSprite = me.titleSprite,
labelBBox;
if (!labelSprite) {
me.titleSprite = labelSprite = surface.add({
type: 'text',
zIndex: 2
});
}
labelSprite.setAttributes(Ext.apply({
text: me.title
}, me.label || {}), true);
labelBBox = labelSprite.getBBox();
labelSprite.setAttributes({
x: bbox.x + (bbox.width / 2) - (labelBBox.width / 2),
y: bbox.y + bbox.height - (labelBBox.height / 2) - 4
}, true);
},
setTitle: function(title) {
this.title = title;
this.drawTitle();
},
drawLabel: function() {
var chart = this.chart,
surface = chart.surface,
bbox = chart.chartBBox,
centerX = bbox.x + (bbox.width / 2),
centerY = bbox.y + bbox.height,
margin = this.margin || 10,
rho = Math.min(bbox.width, 2 * bbox.height) /2 + 2 * margin,
round = Math.round,
labelArray = [], label,
maxValue = this.maximum || 0,
steps = this.steps, i = 0,
adjY,
pi = Math.PI,
cos = Math.cos,
sin = Math.sin,
labelConf = this.label,
renderer = labelConf.renderer || function(v) { return v; };
if (!this.labelArray) {
for (i = 0; i <= steps; i++) {
adjY = (i === 0 || i === steps) ? 7 : 0;
label = surface.add({
type: 'text',
text: renderer(round(i / steps * maxValue)),
x: centerX + rho * cos(i / steps * pi - pi),
y: centerY + rho * sin(i / steps * pi - pi) - adjY,
'text-anchor': 'middle',
'stroke-width': 0.2,
zIndex: 10,
stroke: '#333'
});
label.setAttributes({
hidden: false
}, true);
labelArray.push(label);
}
}
else {
labelArray = this.labelArray;
for (i = 0; i <= steps; i++) {
adjY = (i === 0 || i === steps) ? 7 : 0;
labelArray[i].setAttributes({
text: renderer(round(i / steps * maxValue)),
x: centerX + rho * cos(i / steps * pi - pi),
y: centerY + rho * sin(i / steps * pi - pi) - adjY
}, true);
}
}
this.labelArray = labelArray;
}
});
Ext.define('Ext.chart.axis.Numeric', {
extend: 'Ext.chart.axis.Axis',
alternateClassName: 'Ext.chart.NumericAxis',
type: 'numeric',
alias: 'axis.numeric',
constructor: function(config) {
var me = this,
hasLabel = !!(config.label && config.label.renderer),
label;
me.callParent([config]);
label = me.label;
if (me.roundToDecimal === false) {
return;
}
if (!hasLabel) {
label.renderer = function(v) {
return me.roundToDecimal(v, me.decimals);
};
}
},
roundToDecimal: function(v, dec) {
var val = Math.pow(10, dec || 0);
return ((v * val) >> 0) / val;
},
minimum: NaN,
maximum: NaN,
decimals: 2,
scale: "linear",
position: 'left',
adjustMaximumByMajorUnit: false,
adjustMinimumByMajorUnit: false,
applyData: function() {
this.callParent();
return this.calcEnds();
}
});
Ext.define('Ext.chart.axis.Radial', {
extend: 'Ext.chart.axis.Abstract',
position: 'radial',
alias: 'axis.radial',
drawAxis: function(init) {
var chart = this.chart,
surface = chart.surface,
bbox = chart.chartBBox,
store = chart.store,
l = store.getCount(),
centerX = bbox.x + (bbox.width / 2),
centerY = bbox.y + (bbox.height / 2),
rho = Math.min(bbox.width, bbox.height) /2,
sprites = [], sprite,
steps = this.steps,
i, j, pi2 = Math.PI * 2,
cos = Math.cos, sin = Math.sin;
if (this.sprites && !chart.resizing) {
this.drawLabel();
return;
}
if (!this.sprites) {
for (i = 1; i <= steps; i++) {
sprite = surface.add({
type: 'circle',
x: centerX,
y: centerY,
radius: Math.max(rho * i / steps, 0),
stroke: '#ccc'
});
sprite.setAttributes({
hidden: false
}, true);
sprites.push(sprite);
}
store.each(function(rec, i) {
sprite = surface.add({
type: 'path',
path: ['M', centerX, centerY, 'L', centerX + rho * cos(i / l * pi2), centerY + rho * sin(i / l * pi2), 'Z'],
stroke: '#ccc'
});
sprite.setAttributes({
hidden: false
}, true);
sprites.push(sprite);
});
} else {
sprites = this.sprites;
for (i = 0; i < steps; i++) {
sprites[i].setAttributes({
x: centerX,
y: centerY,
radius: Math.max(rho * (i + 1) / steps, 0),
stroke: '#ccc'
}, true);
}
store.each(function(rec, j) {
sprites[i + j].setAttributes({
path: ['M', centerX, centerY, 'L', centerX + rho * cos(j / l * pi2), centerY + rho * sin(j / l * pi2), 'Z'],
stroke: '#ccc'
}, true);
});
}
this.sprites = sprites;
this.drawLabel();
},
drawLabel: function() {
var chart = this.chart,
surface = chart.surface,
bbox = chart.chartBBox,
store = chart.store,
centerX = bbox.x + (bbox.width / 2),
centerY = bbox.y + (bbox.height / 2),
rho = Math.min(bbox.width, bbox.height) /2,
max = Math.max, round = Math.round,
labelArray = [], label,
fields = [], nfields,
categories = [], xField,
aggregate = !this.maximum,
maxValue = this.maximum || 0,
steps = this.steps, i = 0, j, dx, dy,
pi2 = Math.PI * 2,
cos = Math.cos, sin = Math.sin,
display = this.label.display,
draw = display !== 'none',
margin = 10;
if (!draw) {
return;
}
chart.series.each(function(series) {
fields.push(series.yField);
xField = series.xField;
});
store.each(function(record, i) {
if (aggregate) {
for (i = 0, nfields = fields.length; i < nfields; i++) {
maxValue = max(+record.get(fields[i]), maxValue);
}
}
categories.push(record.get(xField));
});
if (!this.labelArray) {
if (display != 'categories') {
for (i = 1; i <= steps; i++) {
label = surface.add({
type: 'text',
text: round(i / steps * maxValue),
x: centerX,
y: centerY - rho * i / steps,
'text-anchor': 'middle',
'stroke-width': 0.1,
stroke: '#333'
});
label.setAttributes({
hidden: false
}, true);
labelArray.push(label);
}
}
if (display != 'scale') {
for (j = 0, steps = categories.length; j < steps; j++) {
dx = cos(j / steps * pi2) * (rho + margin);
dy = sin(j / steps * pi2) * (rho + margin);
label = surface.add({
type: 'text',
text: categories[j],
x: centerX + dx,
y: centerY + dy,
'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
});
label.setAttributes({
hidden: false
}, true);
labelArray.push(label);
}
}
}
else {
labelArray = this.labelArray;
if (display != 'categories') {
for (i = 0; i < steps; i++) {
labelArray[i].setAttributes({
text: round((i + 1) / steps * maxValue),
x: centerX,
y: centerY - rho * (i + 1) / steps,
'text-anchor': 'middle',
'stroke-width': 0.1,
stroke: '#333'
}, true);
}
}
if (display != 'scale') {
for (j = 0, steps = categories.length; j < steps; j++) {
dx = cos(j / steps * pi2) * (rho + margin);
dy = sin(j / steps * pi2) * (rho + margin);
if (labelArray[i + j]) {
labelArray[i + j].setAttributes({
type: 'text',
text: categories[j],
x: centerX + dx,
y: centerY + dy,
'text-anchor': dx * dx <= 0.001? 'middle' : (dx < 0? 'end' : 'start')
}, true);
}
}
}
}
this.labelArray = labelArray;
}
});
Ext.define('Ext.data.AbstractStore', {
requires: ['Ext.util.MixedCollection', 'Ext.data.Operation', 'Ext.util.Filter'],
mixins: {
observable: 'Ext.util.Observable',
sortable: 'Ext.util.Sortable'
},
statics: {
create: function(store){
if (!store.isStore) {
if (!store.type) {
store.type = 'store';
}
store = Ext.createByAlias('store.' + store.type, store);
}
return store;
}
},
remoteSort : false,
remoteFilter: false,
autoLoad: false,
autoSync: false,
batchUpdateMode: 'operation',
filterOnLoad: true,
sortOnLoad: true,
implicitModel: false,
defaultProxyType: 'memory',
isDestroyed: false,
isStore: true,
sortRoot: 'data',
constructor: function(config) {
var me = this,
filters;
me.addEvents(
'add',
'remove',
'update',
'datachanged',
'beforeload',
'load',
'beforesync',
'clear'
);
Ext.apply(me, config);
me.removed = [];
me.mixins.observable.constructor.apply(me, arguments);
me.model = Ext.ModelManager.getModel(me.model);
Ext.applyIf(me, {
modelDefaults: {}
});
if (!me.model && me.fields) {
me.model = Ext.define('Ext.data.Store.ImplicitModel-' + (me.storeId || Ext.id()), {
extend: 'Ext.data.Model',
fields: me.fields,
proxy: me.proxy || me.defaultProxyType
});
delete me.fields;
me.implicitModel = true;
}
me.setProxy(me.proxy || me.model.getProxy());
if (me.id && !me.storeId) {
me.storeId = me.id;
delete me.id;
}
if (me.storeId) {
Ext.data.StoreManager.register(me);
}
me.mixins.sortable.initSortable.call(me);
filters = me.decodeFilters(me.filters);
me.filters = Ext.create('Ext.util.MixedCollection');
me.filters.addAll(filters);
},
setProxy: function(proxy) {
var me = this;
if (proxy instanceof Ext.data.proxy.Proxy) {
proxy.setModel(me.model);
} else {
if (Ext.isString(proxy)) {
proxy = {
type: proxy
};
}
Ext.applyIf(proxy, {
model: me.model
});
proxy = Ext.createByAlias('proxy.' + proxy.type, proxy);
}
me.proxy = proxy;
return me.proxy;
},
getProxy: function() {
return this.proxy;
},
create: function(data, options) {
var me = this,
instance = Ext.ModelManager.create(Ext.applyIf(data, me.modelDefaults), me.model.modelName),
operation;
options = options || {};
Ext.applyIf(options, {
action : 'create',
records: [instance]
});
operation = Ext.create('Ext.data.Operation', options);
me.proxy.create(operation, me.onProxyWrite, me);
return instance;
},
read: function() {
return this.load.apply(this, arguments);
},
onProxyRead: Ext.emptyFn,
update: function(options) {
var me = this,
operation;
options = options || {};
Ext.applyIf(options, {
action : 'update',
records: me.getUpdatedRecords()
});
operation = Ext.create('Ext.data.Operation', options);
return me.proxy.update(operation, me.onProxyWrite, me);
},
onProxyWrite: function(operation) {
var me = this,
success = operation.wasSuccessful(),
records = operation.getRecords();
switch (operation.action) {
case 'create':
me.onCreateRecords(records, operation, success);
break;
case 'update':
me.onUpdateRecords(records, operation, success);
break;
case 'destroy':
me.onDestroyRecords(records, operation, success);
break;
}
if (success) {
me.fireEvent('write', me, operation);
me.fireEvent('datachanged', me);
}
Ext.callback(operation.callback, operation.scope || me, [records, operation, success]);
},
destroy: function(options) {
var me = this,
operation;
options = options || {};
Ext.applyIf(options, {
action : 'destroy',
records: me.getRemovedRecords()
});
operation = Ext.create('Ext.data.Operation', options);
return me.proxy.destroy(operation, me.onProxyWrite, me);
},
onBatchOperationComplete: function(batch, operation) {
return this.onProxyWrite(operation);
},
onBatchComplete: function(batch, operation) {
var me = this,
operations = batch.operations,
length = operations.length,
i;
me.suspendEvents();
for (i = 0; i < length; i++) {
me.onProxyWrite(operations[i]);
}
me.resumeEvents();
me.fireEvent('datachanged', me);
},
onBatchException: function(batch, operation) {
},
filterNew: function(item) {
return item.phantom === true && item.isValid();
},
getNewRecords: function() {
return [];
},
getUpdatedRecords: function() {
return [];
},
filterUpdated: function(item) {
return item.dirty === true && item.phantom !== true && item.isValid();
},
getRemovedRecords: function() {
return this.removed;
},
filter: function(filters, value) {
},
decodeFilters: function(filters) {
if (!Ext.isArray(filters)) {
if (filters === undefined) {
filters = [];
} else {
filters = [filters];
}
}
var length = filters.length,
Filter = Ext.util.Filter,
config, i;
for (i = 0; i < length; i++) {
config = filters[i];
if (!(config instanceof Filter)) {
Ext.apply(config, {
root: 'data'
});
if (config.fn) {
config.filterFn = config.fn;
}
if (typeof config == 'function') {
config = {
filterFn: config
};
}
filters[i] = new Filter(config);
}
}
return filters;
},
clearFilter: function(supressEvent) {
},
isFiltered: function() {
},
filterBy: function(fn, scope) {
},
sync: function() {
var me = this,
options = {},
toCreate = me.getNewRecords(),
toUpdate = me.getUpdatedRecords(),
toDestroy = me.getRemovedRecords(),
needsSync = false;
if (toCreate.length > 0) {
options.create = toCreate;
needsSync = true;
}
if (toUpdate.length > 0) {
options.update = toUpdate;
needsSync = true;
}
if (toDestroy.length > 0) {
options.destroy = toDestroy;
needsSync = true;
}
if (needsSync && me.fireEvent('beforesync', options) !== false) {
me.proxy.batch(options, me.getBatchListeners());
}
},
getBatchListeners: function() {
var me = this,
listeners = {
scope: me,
exception: me.onBatchException
};
if (me.batchUpdateMode == 'operation') {
listeners.operationcomplete = me.onBatchOperationComplete;
} else {
listeners.complete = me.onBatchComplete;
}
return listeners;
},
save: function() {
return this.sync.apply(this, arguments);
},
load: function(options) {
var me = this,
operation;
options = options || {};
Ext.applyIf(options, {
action : 'read',
filters: me.filters.items,
sorters: me.getSorters()
});
operation = Ext.create('Ext.data.Operation', options);
if (me.fireEvent('beforeload', me, operation) !== false) {
me.loading = true;
me.proxy.read(operation, me.onProxyLoad, me);
}
return me;
},
afterEdit : function(record) {
var me = this;
if (me.autoSync) {
me.sync();
}
me.fireEvent('update', me, record, Ext.data.Model.EDIT);
},
afterReject : function(record) {
this.fireEvent('update', this, record, Ext.data.Model.REJECT);
},
afterCommit : function(record) {
this.fireEvent('update', this, record, Ext.data.Model.COMMIT);
},
clearData: Ext.emptyFn,
destroyStore: function() {
var me = this;
if (!me.isDestroyed) {
if (me.storeId) {
Ext.data.StoreManager.unregister(me);
}
me.clearData();
me.data = null;
me.tree = null;
me.reader = me.writer = null;
me.clearListeners();
me.isDestroyed = true;
if (me.implicitModel) {
Ext.destroy(me.model);
}
}
},
doSort: function(sorterFn) {
var me = this;
if (me.remoteSort) {
me.load();
} else {
me.data.sortBy(sorterFn);
me.fireEvent('datachanged', me);
}
},
getCount: Ext.emptyFn,
getById: Ext.emptyFn,
removeAll: Ext.emptyFn,
isLoading: function() {
return this.loading;
}
});
Ext.define('Ext.util.Grouper', {
extend: 'Ext.util.Sorter',
getGroupString: function(instance) {
return instance.get(this.property);
}
});
Ext.define('Ext.data.Store', {
extend: 'Ext.data.AbstractStore',
alias: 'store.store',
requires: ['Ext.ModelManager', 'Ext.data.Model', 'Ext.util.Grouper'],
uses: ['Ext.data.proxy.Memory'],
remoteSort: false,
remoteFilter: false,
remoteGroup : false,
groupField: undefined,
groupDir: "ASC",
pageSize: 25,
currentPage: 1,
clearOnPageLoad: true,
loading: false,
sortOnFilter: true,
buffered: false,
purgePageCount: 5,
isStore: true,
constructor: function(config) {
config = config || {};
var me = this,
groupers = config.groupers || me.groupers,
groupField = config.groupField || me.groupField,
proxy,
data;
if (config.buffered || me.buffered) {
me.prefetchData = Ext.create('Ext.util.MixedCollection', false, function(record) {
return record.index;
});
me.pendingRequests = [];
me.pagesRequested = [];
me.sortOnLoad = false;
me.filterOnLoad = false;
}
me.addEvents(
'beforeprefetch',
'groupchange',
'prefetch'
);
data = config.data || me.data;
me.data = Ext.create('Ext.util.MixedCollection', false, function(record) {
return record.internalId;
});
if (data) {
me.inlineData = data;
delete config.data;
}
if (!groupers && groupField) {
groupers = [{
property : groupField,
direction: config.groupDir || me.groupDir
}];
}
delete config.groupers;
me.groupers = Ext.create('Ext.util.MixedCollection');
me.groupers.addAll(me.decodeGroupers(groupers));
this.callParent([config]);
if (me.groupers.items.length) {
me.sort(me.groupers.items, 'prepend', false);
}
proxy = me.proxy;
data = me.inlineData;
if (data) {
if (proxy instanceof Ext.data.proxy.Memory) {
proxy.data = data;
me.read();
} else {
me.add.apply(me, data);
}
me.sort();
delete me.inlineData;
} else if (me.autoLoad) {
Ext.defer(me.load, 10, me, [typeof me.autoLoad === 'object' ? me.autoLoad: undefined]);
}
},
onBeforeSort: function() {
this.sort(this.groupers.items, 'prepend', false);
},
decodeGroupers: function(groupers) {
if (!Ext.isArray(groupers)) {
if (groupers === undefined) {
groupers = [];
} else {
groupers = [groupers];
}
}
var length = groupers.length,
Grouper = Ext.util.Grouper,
config, i;
for (i = 0; i < length; i++) {
config = groupers[i];
if (!(config instanceof Grouper)) {
if (Ext.isString(config)) {
config = {
property: config
};
}
Ext.applyIf(config, {
root : 'data',
direction: "ASC"
});
if (config.fn) {
config.sorterFn = config.fn;
}
if (typeof config == 'function') {
config = {
sorterFn: config
};
}
groupers[i] = new Grouper(config);
}
}
return groupers;
},
group: function(groupers, direction) {
var me = this,
grouper,
newGroupers;
if (Ext.isArray(groupers)) {
newGroupers = groupers;
} else if (Ext.isObject(groupers)) {
newGroupers = [groupers];
} else if (Ext.isString(groupers)) {
grouper = me.groupers.get(groupers);
if (!grouper) {
grouper = {
property : groupers,
direction: direction
};
newGroupers = [grouper];
} else if (direction === undefined) {
grouper.toggle();
} else {
grouper.setDirection(direction);
}
}
if (newGroupers && newGroupers.length) {
newGroupers = me.decodeGroupers(newGroupers);
me.groupers.clear();
me.groupers.addAll(newGroupers);
}
if (me.remoteGroup) {
me.load({
scope: me,
callback: me.fireGroupChange
});
} else {
me.sort();
me.fireEvent('groupchange', me, me.groupers);
}
},
clearGrouping: function(){
var me = this;
me.groupers.each(function(grouper){
me.sorters.remove(grouper);
});
me.groupers.clear();
if (me.remoteGroup) {
me.load({
scope: me,
callback: me.fireGroupChange
});
} else {
me.sort();
me.fireEvent('groupchange', me, me.groupers);
}
},
isGrouped: function() {
return this.groupers.getCount() > 0;
},
fireGroupChange: function(){
this.fireEvent('groupchange', this, this.groupers);
},
getGroups: function(requestGroupString) {
var records = this.data.items,
length = records.length,
groups = [],
pointers = {},
record,
groupStr,
group,
i;
for (i = 0; i < length; i++) {
record = records[i];
groupStr = this.getGroupString(record);
group = pointers[groupStr];
if (group === undefined) {
group = {
name: groupStr,
children: []
};
groups.push(group);
pointers[groupStr] = group;
}
group.children.push(record);
}
return requestGroupString ? pointers[requestGroupString] : groups;
},
getGroupsForGrouper: function(records, grouper) {
var length = records.length,
groups = [],
oldValue,
newValue,
record,
group,
i;
for (i = 0; i < length; i++) {
record = records[i];
newValue = grouper.getGroupString(record);
if (newValue !== oldValue) {
group = {
name: newValue,
grouper: grouper,
records: []
};
groups.push(group);
}
group.records.push(record);
oldValue = newValue;
}
return groups;
},
getGroupsForGrouperIndex: function(records, grouperIndex) {
var me = this,
groupers = me.groupers,
grouper = groupers.getAt(grouperIndex),
groups = me.getGroupsForGrouper(records, grouper),
length = groups.length,
i;
if (grouperIndex + 1 < groupers.length) {
for (i = 0; i < length; i++) {
groups[i].children = me.getGroupsForGrouperIndex(groups[i].records, grouperIndex + 1);
}
}
for (i = 0; i < length; i++) {
groups[i].depth = grouperIndex;
}
return groups;
},
getGroupData: function(sort) {
var me = this;
if (sort !== false) {
me.sort();
}
return me.getGroupsForGrouperIndex(me.data.items, 0);
},
getGroupString: function(instance) {
var group = this.groupers.first();
if (group) {
return instance.get(group.property);
}
return '';
},
insert: function(index, records) {
var me = this,
sync = false,
i,
record,
len;
records = [].concat(records);
for (i = 0, len = records.length; i < len; i++) {
record = me.createModel(records[i]);
record.set(me.modelDefaults);
records[i] = record;
me.data.insert(index + i, record);
record.join(me);
sync = sync || record.phantom === true;
}
if (me.snapshot) {
me.snapshot.addAll(records);
}
me.fireEvent('add', me, records, index);
me.fireEvent('datachanged', me);
if (me.autoSync && sync) {
me.sync();
}
},
add: function(records) {
if (!Ext.isArray(records)) {
records = Array.prototype.slice.apply(arguments);
}
var me = this,
i = 0,
length = records.length,
record;
for (; i < length; i++) {
record = me.createModel(records[i]);
records[i] = record;
}
me.insert(me.data.length, records);
return records;
},
createModel: function(record) {
if (!record.isModel) {
record = Ext.ModelManager.create(record, this.model);
}
return record;
},
each: function(fn, scope) {
this.data.each(fn, scope);
},
remove: function(records, isMove) {
if (!Ext.isArray(records)) {
records = [records];
}
isMove = isMove === true;
var me = this,
sync = false,
i = 0,
length = records.length,
isPhantom,
index,
record;
for (; i < length; i++) {
record = records[i];
index = me.data.indexOf(record);
if (me.snapshot) {
me.snapshot.remove(record);
}
if (index > -1) {
isPhantom = record.phantom === true;
if (!isMove && !isPhantom) {
me.removed.push(record);
}
record.unjoin(me);
me.data.remove(record);
sync = sync || !isPhantom;
me.fireEvent('remove', me, record, index);
}
}
me.fireEvent('datachanged', me);
if (!isMove && me.autoSync && sync) {
me.sync();
}
},
removeAt: function(index) {
var record = this.getAt(index);
if (record) {
this.remove(record);
}
},
load: function(options) {
var me = this;
options = options || {};
if (Ext.isFunction(options)) {
options = {
callback: options
};
}
Ext.applyIf(options, {
groupers: me.groupers.items,
page: me.currentPage,
start: (me.currentPage - 1) * me.pageSize,
limit: me.pageSize,
addRecords: false
});
return me.callParent([options]);
},
onProxyLoad: function(operation) {
var me = this,
resultSet = operation.getResultSet(),
records = operation.getRecords(),
successful = operation.wasSuccessful();
if (resultSet) {
me.totalCount = resultSet.total;
}
if (successful) {
me.loadRecords(records, operation);
}
me.loading = false;
me.fireEvent('load', me, records, successful);
me.fireEvent('read', me, records, operation.wasSuccessful());
Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
},
onCreateRecords: function(records, operation, success) {
if (success) {
var i = 0,
data = this.data,
snapshot = this.snapshot,
length = records.length,
originalRecords = operation.records,
record,
original,
index;
for (; i < length; ++i) {
record = records[i];
original = originalRecords[i];
if (original) {
index = data.indexOf(original);
if (index > -1) {
data.removeAt(index);
data.insert(index, record);
}
if (snapshot) {
index = snapshot.indexOf(original);
if (index > -1) {
snapshot.removeAt(index);
snapshot.insert(index, record);
}
}
record.phantom = false;
record.join(this);
}
}
}
},
onUpdateRecords: function(records, operation, success){
if (success) {
var i = 0,
length = records.length,
data = this.data,
snapshot = this.snapshot,
record;
for (; i < length; ++i) {
record = records[i];
data.replace(record);
if (snapshot) {
snapshot.replace(record);
}
record.join(this);
}
}
},
onDestroyRecords: function(records, operation, success){
if (success) {
var me = this,
i = 0,
length = records.length,
data = me.data,
snapshot = me.snapshot,
record;
for (; i < length; ++i) {
record = records[i];
record.unjoin(me);
data.remove(record);
if (snapshot) {
snapshot.remove(record);
}
}
me.removed = [];
}
},
getNewRecords: function() {
return this.data.filterBy(this.filterNew).items;
},
getUpdatedRecords: function() {
return this.data.filterBy(this.filterUpdated).items;
},
filter: function(filters, value) {
if (Ext.isString(filters)) {
filters = {
property: filters,
value: value
};
}
var me = this,
decoded = me.decodeFilters(filters),
i = 0,
doLocalSort = me.sortOnFilter && !me.remoteSort,
length = decoded.length;
for (; i < length; i++) {
me.filters.replace(decoded[i]);
}
if (me.remoteFilter) {
me.load();
} else {
if (me.filters.getCount()) {
me.snapshot = me.snapshot || me.data.clone();
me.data = me.data.filter(me.filters.items);
if (doLocalSort) {
me.sort();
}
if (!doLocalSort || me.sorters.length < 1) {
me.fireEvent('datachanged', me);
}
}
}
},
clearFilter: function(suppressEvent) {
var me = this;
me.filters.clear();
if (me.remoteFilter) {
me.load();
} else if (me.isFiltered()) {
me.data = me.snapshot.clone();
delete me.snapshot;
if (suppressEvent !== true) {
me.fireEvent('datachanged', me);
}
}
},
isFiltered: function() {
var snapshot = this.snapshot;
return !! snapshot && snapshot !== this.data;
},
filterBy: function(fn, scope) {
var me = this;
me.snapshot = me.snapshot || me.data.clone();
me.data = me.queryBy(fn, scope || me);
me.fireEvent('datachanged', me);
},
queryBy: function(fn, scope) {
var me = this,
data = me.snapshot || me.data;
return data.filterBy(fn, scope || me);
},
loadData: function(data, append) {
var model = this.model,
length = data.length,
i,
record;
for (i = 0; i < length; i++) {
record = data[i];
if (! (record instanceof Ext.data.Model)) {
data[i] = Ext.ModelManager.create(record, model);
}
}
this.loadRecords(data, {addRecords: append});
},
loadRecords: function(records, options) {
var me = this,
i = 0,
length = records.length;
options = options || {};
if (!options.addRecords) {
delete me.snapshot;
me.clearData();
}
me.data.addAll(records);
for (; i < length; i++) {
if (options.start !== undefined) {
records[i].index = options.start + i;
}
records[i].join(me);
}
me.suspendEvents();
if (me.filterOnLoad && !me.remoteFilter) {
me.filter();
}
if (me.sortOnLoad && !me.remoteSort) {
me.sort();
}
me.resumeEvents();
me.fireEvent('datachanged', me, records);
},
loadPage: function(page) {
var me = this;
me.currentPage = page;
me.read({
page: page,
start: (page - 1) * me.pageSize,
limit: me.pageSize,
addRecords: !me.clearOnPageLoad
});
},
nextPage: function() {
this.loadPage(this.currentPage + 1);
},
previousPage: function() {
this.loadPage(this.currentPage - 1);
},
clearData: function() {
this.data.each(function(record) {
record.unjoin();
});
this.data.clear();
},
prefetch: function(options) {
var me = this,
operation,
requestId = me.getRequestId();
options = options || {};
Ext.applyIf(options, {
action : 'read',
filters: me.filters.items,
sorters: me.sorters.items,
requestId: requestId
});
me.pendingRequests.push(requestId);
operation = Ext.create('Ext.data.Operation', options);
if (me.fireEvent('beforeprefetch', me, operation) !== false) {
me.loading = true;
me.proxy.read(operation, me.onProxyPrefetch, me);
}
return me;
},
prefetchPage: function(page, options) {
var me = this,
pageSize = me.pageSize,
start = (page - 1) * me.pageSize,
end = start + pageSize;
if (Ext.Array.indexOf(me.pagesRequested, page) === -1 && !me.rangeSatisfied(start, end)) {
options = options || {};
me.pagesRequested.push(page);
Ext.applyIf(options, {
page : page,
start: start,
limit: pageSize,
callback: me.onWaitForGuarantee,
scope: me
});
me.prefetch(options);
}
},
getRequestId: function() {
this.requestSeed = this.requestSeed || 1;
return this.requestSeed++;
},
onProxyPrefetch: function(operation) {
var me = this,
resultSet = operation.getResultSet(),
records = operation.getRecords(),
successful = operation.wasSuccessful();
if (resultSet) {
me.totalCount = resultSet.total;
me.fireEvent('totalcountchange', me.totalCount);
}
if (successful) {
me.cacheRecords(records, operation);
}
Ext.Array.remove(me.pendingRequests, operation.requestId);
if (operation.page) {
Ext.Array.remove(me.pagesRequested, operation.page);
}
me.loading = false;
me.fireEvent('prefetch', me, records, successful, operation);
if (operation.blocking) {
me.fireEvent('load', me, records, successful);
}
Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
},
cacheRecords: function(records, operation) {
var me = this,
i = 0,
length = records.length,
start = operation ? operation.start : 0;
if (!Ext.isDefined(me.totalCount)) {
me.totalCount = records.length;
me.fireEvent('totalcountchange', me.totalCount);
}
for (; i < length; i++) {
records[i].index = start + i;
}
me.prefetchData.addAll(records);
if (me.purgePageCount) {
me.purgeRecords();
}
},
purgeRecords: function() {
var me = this,
prefetchCount = me.prefetchData.getCount(),
purgeCount = me.purgePageCount * me.pageSize,
numRecordsToPurge = prefetchCount - purgeCount - 1,
i = 0;
for (; i <= numRecordsToPurge; i++) {
me.prefetchData.removeAt(0);
}
},
rangeSatisfied: function(start, end) {
var me = this,
i = start,
satisfied = true;
for (; i < end; i++) {
if (!me.prefetchData.getByKey(i)) {
satisfied = false;
break;
}
}
return satisfied;
},
getPageFromRecordIndex: function(index) {
return Math.floor(index / this.pageSize) + 1;
},
onGuaranteedRange: function() {
var me = this,
totalCount = me.getTotalCount(),
start = me.requestStart,
end = ((totalCount - 1) < me.requestEnd) ? totalCount - 1 : me.requestEnd,
range = [],
record,
i = start;
if (start !== me.guaranteedStart && end !== me.guaranteedEnd) {
me.guaranteedStart = start;
me.guaranteedEnd = end;
for (; i <= end; i++) {
record = me.prefetchData.getByKey(i);
range.push(record);
}
me.fireEvent('guaranteedrange', range, start, end);
if (me.cb) {
me.cb.call(me.scope || me, range);
}
}
me.unmask();
},
mask: function() {
this.masked = true;
this.fireEvent('beforeload');
},
unmask: function() {
if (this.masked) {
this.fireEvent('load');
}
},
hasPendingRequests: function() {
return this.pendingRequests.length;
},
onWaitForGuarantee: function() {
if (!this.hasPendingRequests()) {
this.onGuaranteedRange();
}
},
guaranteeRange: function(start, end, cb, scope) {
end = (end > this.totalCount) ? this.totalCount - 1 : end;
var me = this,
i = start,
prefetchData = me.prefetchData,
range = [],
startLoaded = !!prefetchData.getByKey(start),
endLoaded = !!prefetchData.getByKey(end),
startPage = me.getPageFromRecordIndex(start),
endPage = me.getPageFromRecordIndex(end);
me.cb = cb;
me.scope = scope;
me.requestStart = start;
me.requestEnd = end;
if (!startLoaded || !endLoaded) {
if (startPage === endPage) {
me.mask();
me.prefetchPage(startPage, {
callback: me.onWaitForGuarantee,
scope: me
});
} else {
me.mask();
me.prefetchPage(startPage, {
callback: me.onWaitForGuarantee,
scope: me
});
me.prefetchPage(endPage, {
callback: me.onWaitForGuarantee,
scope: me
});
}
} else {
me.onGuaranteedRange();
}
},
sort: function() {
var me = this,
prefetchData = me.prefetchData,
sorters,
start,
end,
range;
if (me.buffered) {
if (me.remoteSort) {
prefetchData.clear();
me.callParent(arguments);
} else {
sorters = me.getSorters();
start = me.guaranteedStart;
end = me.guaranteedEnd;
if (sorters.length) {
prefetchData.sort(sorters);
range = prefetchData.getRange();
prefetchData.clear();
me.cacheRecords(range);
delete me.guaranteedStart;
delete me.guaranteedEnd;
me.guaranteeRange(start, end);
}
me.callParent(arguments);
}
} else {
me.callParent(arguments);
}
},
doSort: function(sorterFn) {
var me = this;
if (me.remoteSort) {
me.load();
} else {
me.data.sortBy(sorterFn);
if (!me.buffered) {
var range = me.getRange(),
ln = range.length,
i = 0;
for (; i < ln; i++) {
range[i].index = i;
}
}
me.fireEvent('datachanged', me);
}
},
find: function(property, value, start, anyMatch, caseSensitive, exactMatch) {
var fn = this.createFilterFn(property, value, anyMatch, caseSensitive, exactMatch);
return fn ? this.data.findIndexBy(fn, null, start) : -1;
},
findRecord: function() {
var me = this,
index = me.find.apply(me, arguments);
return index !== -1 ? me.getAt(index) : null;
},
createFilterFn: function(property, value, anyMatch, caseSensitive, exactMatch) {
if (Ext.isEmpty(value)) {
return false;
}
value = this.data.createValueMatcher(value, anyMatch, caseSensitive, exactMatch);
return function(r) {
return value.test(r.data[property]);
};
},
findExact: function(property, value, start) {
return this.data.findIndexBy(function(rec) {
return rec.get(property) === value;
},
this, start);
},
findBy: function(fn, scope, start) {
return this.data.findIndexBy(fn, scope, start);
},
collect: function(dataIndex, allowNull, bypassFilter) {
var me = this,
data = (bypassFilter === true && me.snapshot) ? me.snapshot: me.data;
return data.collect(dataIndex, 'data', allowNull);
},
getCount: function() {
return this.data.length || 0;
},
getTotalCount: function() {
return this.totalCount;
},
getAt: function(index) {
return this.data.getAt(index);
},
getRange: function(start, end) {
return this.data.getRange(start, end);
},
getById: function(id) {
return (this.snapshot || this.data).findBy(function(record) {
return record.getId() === id;
});
},
indexOf: function(record) {
return this.data.indexOf(record);
},
indexOfTotal: function(record) {
return record.index || this.indexOf(record);
},
indexOfId: function(id) {
return this.data.indexOfKey(id);
},
removeAll: function(silent) {
var me = this;
me.clearData();
if (me.snapshot) {
me.snapshot.clear();
}
if (silent !== true) {
me.fireEvent('clear', me);
}
},
first: function(grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(function(records) {
return records.length ? records[0] : undefined;
}, me, true);
} else {
return me.data.first();
}
},
last: function(grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(function(records) {
var len = records.length;
return len ? records[len - 1] : undefined;
}, me, true);
} else {
return me.data.last();
}
},
sum: function(field, grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(me.getSum, me, true, [field]);
} else {
return me.getSum(me.data.items, field);
}
},
getSum: function(records, field) {
var total = 0,
i = 0,
len = records.length;
for (; i < len; ++i) {
total += records[i].get(field);
}
return total;
},
count: function(grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(function(records) {
return records.length;
}, me, true);
} else {
return me.getCount();
}
},
min: function(field, grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(me.getMin, me, true, [field]);
} else {
return me.getMin(me.data.items, field);
}
},
getMin: function(records, field){
var i = 1,
len = records.length,
value, min;
if (len > 0) {
min = records[0].get(field);
}
for (; i < len; ++i) {
value = records[i].get(field);
if (value < min) {
min = value;
}
}
return min;
},
max: function(field, grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(me.getMax, me, true, [field]);
} else {
return me.getMax(me.data.items, field);
}
},
getMax: function(records, field) {
var i = 1,
len = records.length,
value,
max;
if (len > 0) {
max = records[0].get(field);
}
for (; i < len; ++i) {
value = records[i].get(field);
if (value > max) {
max = value;
}
}
return max;
},
average: function(field, grouped) {
var me = this;
if (grouped && me.isGrouped()) {
return me.aggregate(me.getAverage, me, true, [field]);
} else {
return me.getAverage(me.data.items, field);
}
},
getAverage: function(records, field) {
var i = 0,
len = records.length,
sum = 0;
if (records.length > 0) {
for (; i < len; ++i) {
sum += records[i].get(field);
}
return sum / len;
}
return 0;
},
aggregate: function(fn, scope, grouped, args) {
args = args || [];
if (grouped && this.isGrouped()) {
var groups = this.getGroups(),
i = 0,
len = groups.length,
out = {},
group;
for (; i < len; ++i) {
group = groups[i];
out[group.name] = fn.apply(scope || this, [group.children].concat(args));
}
return out;
} else {
return fn.apply(scope || this, [this.data.items].concat(args));
}
}
});
Ext.define('Ext.data.JsonStore', {
extend: 'Ext.data.Store',
alias: 'store.json',
constructor: function(config) {
config = config || {};
Ext.applyIf(config, {
proxy: {
type : 'ajax',
reader: 'json',
writer: 'json'
}
});
this.callParent([config]);
}
});
Ext.define('Ext.chart.axis.Time', {
extend: 'Ext.chart.axis.Category',
alternateClassName: 'Ext.chart.TimeAxis',
alias: 'axis.time',
requires: ['Ext.data.Store', 'Ext.data.JsonStore'],
calculateByLabelSize: true,
dateFormat: false,
groupBy: 'year,month,day',
aggregateOp: 'sum',
fromDate: false,
toDate: false,
step: [Ext.Date.DAY, 1],
constrain: false,
dateMethods: {
'year': function(date) {
return date.getFullYear();
},
'month': function(date) {
return date.getMonth() + 1;
},
'day': function(date) {
return date.getDate();
},
'hour': function(date) {
return date.getHours();
},
'minute': function(date) {
return date.getMinutes();
},
'second': function(date) {
return date.getSeconds();
},
'millisecond': function(date) {
return date.getMilliseconds();
}
},
aggregateFn: (function() {
var etype = (function() {
var rgxp = /^\[object\s(.*)\]$/,
toString = Object.prototype.toString;
return function(e) {
return toString.call(e).match(rgxp)[1];
};
})();
return {
'sum': function(list) {
var i = 0, l = list.length, acum = 0;
if (!list.length || etype(list[0]) != 'Number') {
return list[0];
}
for (; i < l; i++) {
acum += list[i];
}
return acum;
},
'max': function(list) {
if (!list.length || etype(list[0]) != 'Number') {
return list[0];
}
return Math.max.apply(Math, list);
},
'min': function(list) {
if (!list.length || etype(list[0]) != 'Number') {
return list[0];
}
return Math.min.apply(Math, list);
},
'avg': function(list) {
var i = 0, l = list.length, acum = 0;
if (!list.length || etype(list[0]) != 'Number') {
return list[0];
}
for (; i < l; i++) {
acum += list[i];
}
return acum / l;
}
};
})(),
constrainDates: function() {
var fromDate = Ext.Date.clone(this.fromDate),
toDate = Ext.Date.clone(this.toDate),
step = this.step,
field = this.fields,
store = this.chart.store,
record, recObj, fieldNames = [],
newStore = Ext.create('Ext.data.Store', {
model: store.model
});
var getRecordByDate = (function() {
var index = 0, l = store.getCount();
return function(date) {
var rec, recDate;
for (; index < l; index++) {
rec = store.getAt(index);
recDate = rec.get(field);
if (+recDate > +date) {
return false;
} else if (+recDate == +date) {
return rec;
}
}
return false;
};
})();
if (!this.constrain) {
this.chart.filteredStore = this.chart.store;
return;
}
while(+fromDate <= +toDate) {
record = getRecordByDate(fromDate);
recObj = {};
if (record) {
newStore.add(record.data);
} else {
newStore.model.prototype.fields.each(function(f) {
recObj[f.name] = false;
});
recObj.date = fromDate;
newStore.add(recObj);
}
fromDate = Ext.Date.add(fromDate, step[0], step[1]);
}
this.chart.filteredStore = newStore;
},
aggregate: function() {
var aggStore = {},
aggKeys = [], key, value,
op = this.aggregateOp,
field = this.fields, i,
fields = this.groupBy.split(','),
curField,
recFields = [],
recFieldsLen = 0,
obj,
dates = [],
json = [],
l = fields.length,
dateMethods = this.dateMethods,
aggregateFn = this.aggregateFn,
store = this.chart.filteredStore || this.chart.store;
store.each(function(rec) {
if (!recFields.length) {
rec.fields.each(function(f) {
recFields.push(f.name);
});
recFieldsLen = recFields.length;
}
value = rec.get(field);
for (i = 0; i < l; i++) {
if (i == 0) {
key = String(dateMethods[fields[i]](value));
} else {
key += '||' + dateMethods[fields[i]](value);
}
}
if (key in aggStore) {
obj = aggStore[key];
} else {
obj = aggStore[key] = {};
aggKeys.push(key);
dates.push(value);
}
for (i = 0; i < recFieldsLen; i++) {
curField = recFields[i];
if (!obj[curField]) {
obj[curField] = [];
}
if (rec.get(curField) !== undefined) {
obj[curField].push(rec.get(curField));
}
}
});
for (key in aggStore) {
obj = aggStore[key];
for (i = 0; i < recFieldsLen; i++) {
curField = recFields[i];
obj[curField] = aggregateFn[op](obj[curField]);
}
json.push(obj);
}
this.chart.substore = Ext.create('Ext.data.JsonStore', {
fields: recFields,
data: json
});
this.dates = dates;
},
setLabels: function() {
var store = this.chart.substore,
fields = this.fields,
format = this.dateFormat,
labels, i, dates = this.dates,
formatFn = Ext.Date.format;
this.labels = labels = [];
store.each(function(record, i) {
if (!format) {
labels.push(record.get(fields));
} else {
labels.push(formatFn(dates[i], format));
}
}, this);
},
processView: function() {
if (this.constrain) {
this.constrainDates();
this.aggregate();
this.chart.substore = this.chart.filteredStore;
} else {
this.aggregate();
}
},
applyData: function() {
this.setLabels();
var count = this.chart.substore.getCount();
return {
from: 0,
to: count,
steps: count - 1,
step: 1
};
}
});
Ext.define('Ext.chart.series.Series', {
mixins: {
observable: 'Ext.util.Observable',
labels: 'Ext.chart.Label',
highlights: 'Ext.chart.Highlight',
tips: 'Ext.chart.Tip',
callouts: 'Ext.chart.Callout'
},
type: null,
title: null,
showInLegend: true,
renderer: function(sprite, record, attributes, index, store) {
return attributes;
},
shadowAttributes: null,
//@private triggerdrawlistener flag
triggerAfterDraw: false,
constructor: function(config) {
var me = this;
if (config) {
Ext.apply(me, config);
}
me.shadowGroups = [];
me.mixins.labels.constructor.call(me, config);
me.mixins.highlights.constructor.call(me, config);
me.mixins.tips.constructor.call(me, config);
me.mixins.callouts.constructor.call(me, config);
me.addEvents({
scope: me,
itemmouseover: true,
itemmouseout: true,
itemmousedown: true,
itemmouseup: true,
mouseleave: true,
afterdraw: true,
titlechange: true
});
me.mixins.observable.constructor.call(me, config);
me.on({
scope: me,
itemmouseover: me.onItemMouseOver,
itemmouseout: me.onItemMouseOut,
mouseleave: me.onMouseLeave
});
},
setBBox: function(noGutter) {
var me = this,
chart = me.chart,
chartBBox = chart.chartBBox,
gutterX = noGutter ? 0 : chart.maxGutter[0],
gutterY = noGutter ? 0 : chart.maxGutter[1],
clipBox, bbox;
clipBox = {
x: chartBBox.x,
y: chartBBox.y,
width: chartBBox.width,
height: chartBBox.height
};
me.clipBox = clipBox;
bbox = {
x: (clipBox.x + gutterX) - (chart.zoom.x * chart.zoom.width),
y: (clipBox.y + gutterY) - (chart.zoom.y * chart.zoom.height),
width: (clipBox.width - (gutterX * 2)) * chart.zoom.width,
height: (clipBox.height - (gutterY * 2)) * chart.zoom.height
};
me.bbox = bbox;
},
onAnimate: function(sprite, attr) {
var me = this;
sprite.stopAnimation();
if (me.triggerAfterDraw) {
return sprite.animate(Ext.applyIf(attr, me.chart.animate));
} else {
me.triggerAfterDraw = true;
return sprite.animate(Ext.apply(Ext.applyIf(attr, me.chart.animate), {
listeners: {
'afteranimate': function() {
me.triggerAfterDraw = false;
me.fireEvent('afterrender');
}
}
}));
}
},
getGutters: function() {
return [0, 0];
},
onItemMouseOver: function(item) {
var me = this;
if (item.series === me) {
if (me.highlight) {
me.highlightItem(item);
}
if (me.tooltip) {
me.showTip(item);
}
}
},
onItemMouseOut: function(item) {
var me = this;
if (item.series === me) {
me.unHighlightItem();
if (me.tooltip) {
me.hideTip(item);
}
}
},
onMouseLeave: function() {
var me = this;
me.unHighlightItem();
if (me.tooltip) {
me.hideTip();
}
},
getItemForPoint: function(x, y) {
if (!this.items || !this.items.length || this.seriesIsHidden) {
return null;
}
var me = this,
items = me.items,
bbox = me.bbox,
item, i, ln;
if (!Ext.draw.Draw.withinBox(x, y, bbox)) {
return null;
}
for (i = 0, ln = items.length; i < ln; i++) {
if (items[i] && this.isItemInPoint(x, y, items[i], i)) {
return items[i];
}
}
return null;
},
isItemInPoint: function(x, y, item, i) {
return false;
},
hideAll: function() {
var me = this,
items = me.items,
item, len, i, sprite;
me.seriesIsHidden = true;
me._prevShowMarkers = me.showMarkers;
me.showMarkers = false;
me.hideLabels(0);
for (i = 0, len = items.length; i < len; i++) {
item = items[i];
sprite = item.sprite;
if (sprite) {
sprite.setAttributes({
hidden: true
}, true);
}
}
},
showAll: function() {
var me = this,
prevAnimate = me.chart.animate;
me.chart.animate = false;
me.seriesIsHidden = false;
me.showMarkers = me._prevShowMarkers;
me.drawSeries();
me.chart.animate = prevAnimate;
},
getLegendColor: function(index) {
var me = this, fill, stroke;
if (me.seriesStyle) {
fill = me.seriesStyle.fill;
stroke = me.seriesStyle.stroke;
if (fill && fill != 'none') {
return fill;
}
return stroke;
}
return '#000';
},
visibleInLegend: function(index){
var excludes = this.__excludes;
if (excludes) {
return !excludes[index];
}
return !this.seriesIsHidden;
},
setTitle: function(index, title) {
var me = this,
oldTitle = me.title;
if (Ext.isString(index)) {
title = index;
index = 0;
}
if (Ext.isArray(oldTitle)) {
oldTitle[index] = title;
} else {
me.title = title;
}
me.fireEvent('titlechange', title, index);
}
});
Ext.define('Ext.chart.series.Cartesian', {
extend: 'Ext.chart.series.Series',
alternateClassName: ['Ext.chart.CartesianSeries', 'Ext.chart.CartesianChart'],
xField: null,
yField: null,
axis: 'left'
});
Ext.define('Ext.chart.series.Area', {
extend: 'Ext.chart.series.Cartesian',
alias: 'series.area',
requires: ['Ext.chart.axis.Axis', 'Ext.draw.Color', 'Ext.fx.Anim'],
type: 'area',
stacked: true,
style: {},
constructor: function(config) {
this.callParent(arguments);
var me = this,
surface = me.chart.surface,
i, l;
Ext.apply(me, config, {
__excludes: [],
highlightCfg: {
lineWidth: 3,
stroke: '#55c',
opacity: 0.8,
color: '#f00'
}
});
if (me.highlight) {
me.highlightSprite = surface.add({
type: 'path',
path: ['M', 0, 0],
zIndex: 1000,
opacity: 0.3,
lineWidth: 5,
hidden: true,
stroke: '#444'
});
}
me.group = surface.getGroup(me.seriesId);
},
shrink: function(xValues, yValues, size) {
var len = xValues.length,
ratio = Math.floor(len / size),
i, j,
xSum = 0,
yCompLen = this.areas.length,
ySum = [],
xRes = [],
yRes = [];
for (j = 0; j < yCompLen; ++j) {
ySum[j] = 0;
}
for (i = 0; i < len; ++i) {
xSum += xValues[i];
for (j = 0; j < yCompLen; ++j) {
ySum[j] += yValues[i][j];
}
if (i % ratio == 0) {
xRes.push(xSum/ratio);
for (j = 0; j < yCompLen; ++j) {
ySum[j] /= ratio;
}
yRes.push(ySum);
xSum = 0;
for (j = 0, ySum = []; j < yCompLen; ++j) {
ySum[j] = 0;
}
}
}
return {
x: xRes,
y: yRes
};
},
getBounds: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
areas = [].concat(me.yField),
areasLen = areas.length,
xValues = [],
yValues = [],
infinity = Infinity,
minX = infinity,
minY = infinity,
maxX = -infinity,
maxY = -infinity,
math = Math,
mmin = math.min,
mmax = math.max,
bbox, xScale, yScale, xValue, yValue, areaIndex, acumY, ln, sumValues, clipBox, areaElem;
me.setBBox();
bbox = me.bbox;
if (me.axis) {
axis = chart.axes.get(me.axis);
if (axis) {
out = axis.calcEnds();
minY = out.from || axis.prevMin;
maxY = mmax(out.to || axis.prevMax, 0);
}
}
if (me.yField && !Ext.isNumber(minY)) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.yField)
});
out = axis.calcEnds();
minY = out.from || axis.prevMin;
maxY = mmax(out.to || axis.prevMax, 0);
}
if (!Ext.isNumber(minY)) {
minY = 0;
}
if (!Ext.isNumber(maxY)) {
maxY = 0;
}
store.each(function(record, i) {
xValue = record.get(me.xField);
yValue = [];
if (typeof xValue != 'number') {
xValue = i;
}
xValues.push(xValue);
acumY = 0;
for (areaIndex = 0; areaIndex < areasLen; areaIndex++) {
areaElem = record.get(areas[areaIndex]);
if (typeof areaElem == 'number') {
minY = mmin(minY, areaElem);
yValue.push(areaElem);
acumY += areaElem;
}
}
minX = mmin(minX, xValue);
maxX = mmax(maxX, xValue);
maxY = mmax(maxY, acumY);
yValues.push(yValue);
}, me);
xScale = bbox.width / (maxX - minX);
yScale = bbox.height / (maxY - minY);
ln = xValues.length;
if ((ln > bbox.width) && me.areas) {
sumValues = me.shrink(xValues, yValues, bbox.width);
xValues = sumValues.x;
yValues = sumValues.y;
}
return {
bbox: bbox,
minX: minX,
minY: minY,
xValues: xValues,
yValues: yValues,
xScale: xScale,
yScale: yScale,
areasLen: areasLen
};
},
getPaths: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
first = true,
bounds = me.getBounds(),
bbox = bounds.bbox,
items = me.items = [],
componentPaths = [],
componentPath,
paths = [],
i, ln, x, y, xValue, yValue, acumY, areaIndex, prevAreaIndex, areaElem, path;
ln = bounds.xValues.length;
for (i = 0; i < ln; i++) {
xValue = bounds.xValues[i];
yValue = bounds.yValues[i];
x = bbox.x + (xValue - bounds.minX) * bounds.xScale;
acumY = 0;
for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) {
if (me.__excludes[areaIndex]) {
continue;
}
if (!componentPaths[areaIndex]) {
componentPaths[areaIndex] = [];
}
areaElem = yValue[areaIndex];
acumY += areaElem;
y = bbox.y + bbox.height - (acumY - bounds.minY) * bounds.yScale;
if (!paths[areaIndex]) {
paths[areaIndex] = ['M', x, y];
componentPaths[areaIndex].push(['L', x, y]);
} else {
paths[areaIndex].push('L', x, y);
componentPaths[areaIndex].push(['L', x, y]);
}
if (!items[areaIndex]) {
items[areaIndex] = {
pointsUp: [],
pointsDown: [],
series: me
};
}
items[areaIndex].pointsUp.push([x, y]);
}
}
for (areaIndex = 0; areaIndex < bounds.areasLen; areaIndex++) {
if (me.__excludes[areaIndex]) {
continue;
}
path = paths[areaIndex];
if (areaIndex == 0 || first) {
first = false;
path.push('L', x, bbox.y + bbox.height,
'L', bbox.x, bbox.y + bbox.height,
'Z');
}
else {
componentPath = componentPaths[prevAreaIndex];
componentPath.reverse();
path.push('L', x, componentPath[0][2]);
for (i = 0; i < ln; i++) {
path.push(componentPath[i][0],
componentPath[i][1],
componentPath[i][2]);
items[areaIndex].pointsDown[ln -i -1] = [componentPath[i][1], componentPath[i][2]];
}
path.push('L', bbox.x, path[2], 'Z');
}
prevAreaIndex = areaIndex;
}
return {
paths: paths,
areasLen: bounds.areasLen
};
},
drawSeries: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
surface = chart.surface,
animate = chart.animate,
group = me.group,
endLineStyle = Ext.apply(me.seriesStyle, me.style),
colorArrayStyle = me.colorArrayStyle,
colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
areaIndex, areaElem, paths, path, rendererAttributes;
me.unHighlightItem();
me.cleanHighlights();
if (!store || !store.getCount()) {
return;
}
paths = me.getPaths();
if (!me.areas) {
me.areas = [];
}
for (areaIndex = 0; areaIndex < paths.areasLen; areaIndex++) {
if (me.__excludes[areaIndex]) {
continue;
}
if (!me.areas[areaIndex]) {
me.items[areaIndex].sprite = me.areas[areaIndex] = surface.add(Ext.apply({}, {
type: 'path',
group: group,
path: paths.paths[areaIndex],
stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength],
fill: colorArrayStyle[areaIndex % colorArrayLength]
}, endLineStyle || {}));
}
areaElem = me.areas[areaIndex];
path = paths.paths[areaIndex];
if (animate) {
rendererAttributes = me.renderer(areaElem, false, {
path: path,
fill: colorArrayStyle[areaIndex % colorArrayLength],
stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
}, areaIndex, store);
me.animation = me.onAnimate(areaElem, {
to: rendererAttributes
});
} else {
rendererAttributes = me.renderer(areaElem, false, {
path: path,
hidden: false,
fill: colorArrayStyle[areaIndex % colorArrayLength],
stroke: endLineStyle.stroke || colorArrayStyle[areaIndex % colorArrayLength]
}, areaIndex, store);
me.areas[areaIndex].setAttributes(rendererAttributes, true);
}
}
me.renderLabels();
me.renderCallouts();
},
onAnimate: function(sprite, attr) {
sprite.show();
return this.callParent(arguments);
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
group = me.labelsGroup,
config = me.label,
bbox = me.bbox,
endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
return me.chart.surface.add(Ext.apply({
'type': 'text',
'text-anchor': 'middle',
'group': group,
'x': item.point[0],
'y': bbox.y + bbox.height / 2
}, endLabelStyle || {}));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.label,
format = config.renderer,
field = config.field,
bbox = me.bbox,
x = item.point[0],
y = item.point[1],
bb, width, height;
label.setAttributes({
text: format(storeItem.get(field[index])),
hidden: true
}, true);
bb = label.getBBox();
width = bb.width / 2;
height = bb.height / 2;
x = x - width < bbox.x? bbox.x + width : x;
x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
y = y - height < bbox.y? bbox.y + height : y;
y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
if (me.chart.animate && !me.chart.resizing) {
label.show(true);
me.onAnimate(label, {
to: {
x: x,
y: y
}
});
} else {
label.setAttributes({
x: x,
y: y
}, true);
if (resizing) {
me.animation.on('afteranimate', function() {
label.show(true);
});
} else {
label.show(true);
}
}
},
onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
var me = this,
chart = me.chart,
surface = chart.surface,
resizing = chart.resizing,
config = me.callouts,
items = me.items,
prev = (i == 0) ? false : items[i -1].point,
next = (i == items.length -1) ? false : items[i +1].point,
cur = item.point,
dir, norm, normal, a, aprev, anext,
bbox = callout.label.getBBox(),
offsetFromViz = 30,
offsetToSide = 10,
offsetBox = 3,
boxx, boxy, boxw, boxh,
p, clipRect = me.clipRect,
x, y;
if (!prev) {
prev = cur;
}
if (!next) {
next = cur;
}
a = (next[1] - prev[1]) / (next[0] - prev[0]);
aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
anext = (next[1] - cur[1]) / (next[0] - cur[0]);
norm = Math.sqrt(1 + a * a);
dir = [1 / norm, a / norm];
normal = [-dir[1], dir[0]];
if (aprev > 0 && anext < 0 && normal[1] < 0 || aprev < 0 && anext > 0 && normal[1] > 0) {
normal[0] *= -1;
normal[1] *= -1;
} else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0 || Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
normal[0] *= -1;
normal[1] *= -1;
}
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
normal[0] *= -1;
}
if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
normal[1] *= -1;
}
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
callout.lines.setAttributes({
path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}, true);
callout.box.setAttributes({
x: boxx,
y: boxy,
width: boxw,
height: boxh
}, true);
callout.label.setAttributes({
x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
y: y
}, true);
for (p in callout) {
callout[p].show(true);
}
},
isItemInPoint: function(x, y, item, i) {
var me = this,
pointsUp = item.pointsUp,
pointsDown = item.pointsDown,
abs = Math.abs,
dist = Infinity, p, pln, point;
for (p = 0, pln = pointsUp.length; p < pln; p++) {
point = [pointsUp[p][0], pointsUp[p][1]];
if (dist > abs(x - point[0])) {
dist = abs(x - point[0]);
} else {
point = pointsUp[p -1];
if (y >= point[1] && (!pointsDown.length || y <= (pointsDown[p -1][1]))) {
item.storeIndex = p -1;
item.storeField = me.yField[i];
item.storeItem = me.chart.store.getAt(p -1);
item._points = pointsDown.length? [point, pointsDown[p -1]] : [point];
return true;
} else {
break;
}
}
}
return false;
},
highlightSeries: function() {
var area, to, fillColor;
if (this._index !== undefined) {
area = this.areas[this._index];
if (area.__highlightAnim) {
area.__highlightAnim.paused = true;
}
area.__highlighted = true;
area.__prevOpacity = area.__prevOpacity || area.attr.opacity || 1;
area.__prevFill = area.__prevFill || area.attr.fill;
area.__prevLineWidth = area.__prevLineWidth || area.attr.lineWidth;
fillColor = Ext.draw.Color.fromString(area.__prevFill);
to = {
lineWidth: (area.__prevLineWidth || 0) + 2
};
if (fillColor) {
to.fill = fillColor.getLighter(0.2).toString();
}
else {
to.opacity = Math.max(area.__prevOpacity - 0.3, 0);
}
if (this.chart.animate) {
area.__highlightAnim = Ext.create('Ext.fx.Anim', Ext.apply({
target: area,
to: to
}, this.chart.animate));
}
else {
area.setAttributes(to, true);
}
}
},
unHighlightSeries: function() {
var area;
if (this._index !== undefined) {
area = this.areas[this._index];
if (area.__highlightAnim) {
area.__highlightAnim.paused = true;
}
if (area.__highlighted) {
area.__highlighted = false;
area.__highlightAnim = Ext.create('Ext.fx.Anim', {
target: area,
to: {
fill: area.__prevFill,
opacity: area.__prevOpacity,
lineWidth: area.__prevLineWidth
}
});
}
}
},
highlightItem: function(item) {
var me = this,
points, path;
if (!item) {
this.highlightSeries();
return;
}
points = item._points;
path = points.length == 2? ['M', points[0][0], points[0][1], 'L', points[1][0], points[1][1]]
: ['M', points[0][0], points[0][1], 'L', points[0][0], me.bbox.y + me.bbox.height];
me.highlightSprite.setAttributes({
path: path,
hidden: false
}, true);
},
unHighlightItem: function(item) {
if (!item) {
this.unHighlightSeries();
}
if (this.highlightSprite) {
this.highlightSprite.hide(true);
}
},
hideAll: function() {
if (!isNaN(this._index)) {
this.__excludes[this._index] = true;
this.areas[this._index].hide(true);
this.drawSeries();
}
},
showAll: function() {
if (!isNaN(this._index)) {
this.__excludes[this._index] = false;
this.areas[this._index].show(true);
this.drawSeries();
}
},
getLegendColor: function(index) {
var me = this;
return me.colorArrayStyle[index % me.colorArrayStyle.length];
}
});
Ext.define('Ext.chart.series.Bar', {
extend: 'Ext.chart.series.Cartesian',
alternateClassName: ['Ext.chart.BarSeries', 'Ext.chart.BarChart', 'Ext.chart.StackedBarChart'],
requires: ['Ext.chart.axis.Axis', 'Ext.fx.Anim'],
type: 'bar',
alias: 'series.bar',
column: false,
style: {},
gutter: 38.2,
groupGutter: 38.2,
xPadding: 0,
yPadding: 10,
constructor: function(config) {
this.callParent(arguments);
var me = this,
surface = me.chart.surface,
shadow = me.chart.shadow,
i, l;
Ext.apply(me, config, {
highlightCfg: {
lineWidth: 3,
stroke: '#55c',
opacity: 0.8,
color: '#f00'
},
shadowAttributes: [{
"stroke-width": 6,
"stroke-opacity": 0.05,
stroke: 'rgb(200, 200, 200)',
translate: {
x: 1.2,
y: 1.2
}
}, {
"stroke-width": 4,
"stroke-opacity": 0.1,
stroke: 'rgb(150, 150, 150)',
translate: {
x: 0.9,
y: 0.9
}
}, {
"stroke-width": 2,
"stroke-opacity": 0.15,
stroke: 'rgb(100, 100, 100)',
translate: {
x: 0.6,
y: 0.6
}
}]
});
me.group = surface.getGroup(me.seriesId + '-bars');
if (shadow) {
for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
}
},
getBarGirth: function() {
var me = this,
store = me.chart.store,
column = me.column,
ln = store.getCount(),
gutter = me.gutter / 100;
return (me.chart.chartBBox[column ? 'width' : 'height'] - me[column ? 'xPadding' : 'yPadding'] * 2) / (ln * (gutter + 1) - gutter);
},
getGutters: function() {
var me = this,
column = me.column,
gutter = Math.ceil(me[column ? 'xPadding' : 'yPadding'] + me.getBarGirth() / 2);
return me.column ? [gutter, 0] : [0, gutter];
},
getBounds: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
bars = [].concat(me.yField),
barsLen = bars.length,
groupBarsLen = barsLen,
groupGutter = me.groupGutter / 100,
column = me.column,
xPadding = me.xPadding,
yPadding = me.yPadding,
stacked = me.stacked,
barWidth = me.getBarGirth(),
math = Math,
mmax = math.max,
mabs = math.abs,
groupBarWidth, bbox, minY, maxY, axis, out,
scale, zero, total, rec, j, plus, minus;
me.setBBox(true);
bbox = me.bbox;
if (me.__excludes) {
for (j = 0, total = me.__excludes.length; j < total; j++) {
if (me.__excludes[j]) {
groupBarsLen--;
}
}
}
if (me.axis) {
axis = chart.axes.get(me.axis);
if (axis) {
out = axis.calcEnds();
minY = out.from || axis.prevMin;
maxY = mmax(out.to || axis.prevMax, 0);
}
}
if (me.yField && !Ext.isNumber(minY)) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.yField)
});
out = axis.calcEnds();
minY = out.from || axis.prevMin;
maxY = mmax(out.to || axis.prevMax, 0);
}
if (!Ext.isNumber(minY)) {
minY = 0;
}
if (!Ext.isNumber(maxY)) {
maxY = 0;
}
scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (maxY - minY);
groupBarWidth = barWidth / ((stacked ? 1 : groupBarsLen) * (groupGutter + 1) - groupGutter);
zero = (column) ? bbox.y + bbox.height - yPadding : bbox.x + xPadding;
if (stacked) {
total = [[], []];
store.each(function(record, i) {
total[0][i] = total[0][i] || 0;
total[1][i] = total[1][i] || 0;
for (j = 0; j < barsLen; j++) {
if (me.__excludes && me.__excludes[j]) {
continue;
}
rec = record.get(bars[j]);
total[+(rec > 0)][i] += mabs(rec);
}
});
total[+(maxY > 0)].push(mabs(maxY));
total[+(minY > 0)].push(mabs(minY));
minus = mmax.apply(math, total[0]);
plus = mmax.apply(math, total[1]);
scale = (column ? bbox.height - yPadding * 2 : bbox.width - xPadding * 2) / (plus + minus);
zero = zero + minus * scale * (column ? -1 : 1);
}
else if (minY / maxY < 0) {
zero = zero - minY * scale * (column ? -1 : 1);
}
return {
bars: bars,
bbox: bbox,
barsLen: barsLen,
groupBarsLen: groupBarsLen,
barWidth: barWidth,
groupBarWidth: groupBarWidth,
scale: scale,
zero: zero,
xPadding: xPadding,
yPadding: yPadding,
signed: minY / maxY < 0,
minY: minY,
maxY: maxY
};
},
getPaths: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
bounds = me.bounds = me.getBounds(),
items = me.items = [],
gutter = me.gutter / 100,
groupGutter = me.groupGutter / 100,
animate = chart.animate,
column = me.column,
group = me.group,
enableShadows = chart.shadow,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
shadowGroupsLn = shadowGroups.length,
bbox = bounds.bbox,
xPadding = me.xPadding,
yPadding = me.yPadding,
stacked = me.stacked,
barsLen = bounds.barsLen,
colors = me.colorArrayStyle,
colorLength = colors && colors.length || 0,
math = Math,
mmax = math.max,
mmin = math.min,
mabs = math.abs,
j, yValue, height, totalDim, totalNegDim, bottom, top, hasShadow, barAttr, attrs, counter,
shadowIndex, shadow, sprite, offset, floorY;
store.each(function(record, i, total) {
bottom = bounds.zero;
top = bounds.zero;
totalDim = 0;
totalNegDim = 0;
hasShadow = false;
for (j = 0, counter = 0; j < barsLen; j++) {
if (me.__excludes && me.__excludes[j]) {
continue;
}
yValue = record.get(bounds.bars[j]);
height = Math.round((yValue - ((bounds.minY < 0) ? 0 : bounds.minY)) * bounds.scale);
barAttr = {
fill: colors[(barsLen > 1 ? j : 0) % colorLength]
};
if (column) {
Ext.apply(barAttr, {
height: height,
width: mmax(bounds.groupBarWidth, 0),
x: (bbox.x + xPadding + i * bounds.barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked),
y: bottom - height
});
}
else {
offset = (total - 1) - i;
Ext.apply(barAttr, {
height: mmax(bounds.groupBarWidth, 0),
width: height + (bottom == bounds.zero),
x: bottom + (bottom != bounds.zero),
y: (bbox.y + yPadding + offset * bounds.barWidth * (1 + gutter) + counter * bounds.groupBarWidth * (1 + groupGutter) * !stacked + 1)
});
}
if (height < 0) {
if (column) {
barAttr.y = top;
barAttr.height = mabs(height);
} else {
barAttr.x = top + height;
barAttr.width = mabs(height);
}
}
if (stacked) {
if (height < 0) {
top += height * (column ? -1 : 1);
} else {
bottom += height * (column ? -1 : 1);
}
totalDim += mabs(height);
if (height < 0) {
totalNegDim += mabs(height);
}
}
barAttr.x = Math.floor(barAttr.x) + 1;
floorY = Math.floor(barAttr.y);
if (!Ext.isIE9 && barAttr.y > floorY) {
floorY--;
}
barAttr.y = floorY;
barAttr.width = Math.floor(barAttr.width);
barAttr.height = Math.floor(barAttr.height);
items.push({
series: me,
storeItem: record,
value: [record.get(me.xField), yValue],
attr: barAttr,
point: column ? [barAttr.x + barAttr.width / 2, yValue >= 0 ? barAttr.y : barAttr.y + barAttr.height] :
[yValue >= 0 ? barAttr.x + barAttr.width : barAttr.x, barAttr.y + barAttr.height / 2]
});
if (animate && chart.resizing) {
attrs = column ? {
x: barAttr.x,
y: bounds.zero,
width: barAttr.width,
height: 0
} : {
x: bounds.zero,
y: barAttr.y,
width: 0,
height: barAttr.height
};
if (enableShadows && (stacked && !hasShadow || !stacked)) {
hasShadow = true;
for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
shadow = shadowGroups[shadowIndex].getAt(stacked ? i : (i * barsLen + j));
if (shadow) {
shadow.setAttributes(attrs, true);
}
}
}
sprite = group.getAt(i * barsLen + j);
if (sprite) {
sprite.setAttributes(attrs, true);
}
}
counter++;
}
if (stacked && items.length) {
items[i * counter].totalDim = totalDim;
items[i * counter].totalNegDim = totalNegDim;
}
}, me);
},
renderShadows: function(i, barAttr, baseAttrs, bounds) {
var me = this,
chart = me.chart,
surface = chart.surface,
animate = chart.animate,
stacked = me.stacked,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
shadowGroupsLn = shadowGroups.length,
store = chart.substore || chart.store,
column = me.column,
items = me.items,
shadows = [],
zero = bounds.zero,
shadowIndex, shadowBarAttr, shadow, totalDim, totalNegDim, j, rendererAttributes;
if ((stacked && (i % bounds.groupBarsLen === 0)) || !stacked) {
j = i / bounds.groupBarsLen;
for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
shadowBarAttr = Ext.apply({}, shadowAttributes[shadowIndex]);
shadow = shadowGroups[shadowIndex].getAt(stacked ? j : i);
Ext.copyTo(shadowBarAttr, barAttr, 'x,y,width,height');
if (!shadow) {
shadow = surface.add(Ext.apply({
type: 'rect',
group: shadowGroups[shadowIndex]
}, Ext.apply({}, baseAttrs, shadowBarAttr)));
}
if (stacked) {
totalDim = items[i].totalDim;
totalNegDim = items[i].totalNegDim;
if (column) {
shadowBarAttr.y = zero - totalNegDim;
shadowBarAttr.height = totalDim;
}
else {
shadowBarAttr.x = zero - totalNegDim;
shadowBarAttr.width = totalDim;
}
}
if (animate) {
if (!stacked) {
rendererAttributes = me.renderer(shadow, store.getAt(j), shadowBarAttr, i, store);
me.onAnimate(shadow, { to: rendererAttributes });
}
else {
rendererAttributes = me.renderer(shadow, store.getAt(j), Ext.apply(shadowBarAttr, { hidden: true }), i, store);
shadow.setAttributes(rendererAttributes, true);
}
}
else {
rendererAttributes = me.renderer(shadow, store.getAt(j), Ext.apply(shadowBarAttr, { hidden: false }), i, store);
shadow.setAttributes(rendererAttributes, true);
}
shadows.push(shadow);
}
}
return shadows;
},
drawSeries: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
surface = chart.surface,
animate = chart.animate,
stacked = me.stacked,
column = me.column,
enableShadows = chart.shadow,
shadowGroups = me.shadowGroups,
shadowGroupsLn = shadowGroups.length,
group = me.group,
seriesStyle = me.seriesStyle,
items, ln, i, j, baseAttrs, sprite, rendererAttributes, shadowIndex, shadowGroup,
bounds, endSeriesStyle, barAttr, attrs, anim;
if (!store || !store.getCount()) {
return;
}
delete seriesStyle.fill;
endSeriesStyle = Ext.apply(seriesStyle, this.style);
me.unHighlightItem();
me.cleanHighlights();
me.getPaths();
bounds = me.bounds;
items = me.items;
baseAttrs = column ? {
y: bounds.zero,
height: 0
} : {
x: bounds.zero,
width: 0
};
ln = items.length;
for (i = 0; i < ln; i++) {
sprite = group.getAt(i);
barAttr = items[i].attr;
if (enableShadows) {
items[i].shadows = me.renderShadows(i, barAttr, baseAttrs, bounds);
}
if (!sprite) {
attrs = Ext.apply({}, baseAttrs, barAttr);
attrs = Ext.apply(attrs, endSeriesStyle || {});
sprite = surface.add(Ext.apply({}, {
type: 'rect',
group: group
}, attrs));
}
if (animate) {
rendererAttributes = me.renderer(sprite, store.getAt(i), barAttr, i, store);
sprite._to = rendererAttributes;
anim = me.onAnimate(sprite, { to: Ext.apply(rendererAttributes, endSeriesStyle) });
if (enableShadows && stacked && (i % bounds.barsLen === 0)) {
j = i / bounds.barsLen;
for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
anim.on('afteranimate', function() {
this.show(true);
}, shadowGroups[shadowIndex].getAt(j));
}
}
}
else {
rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(barAttr, { hidden: false }), i, store);
sprite.setAttributes(Ext.apply(rendererAttributes, endSeriesStyle), true);
}
items[i].sprite = sprite;
}
ln = group.getCount();
for (j = i; j < ln; j++) {
group.getAt(j).hide(true);
}
if (enableShadows) {
for (shadowIndex = 0; shadowIndex < shadowGroupsLn; shadowIndex++) {
shadowGroup = shadowGroups[shadowIndex];
ln = shadowGroup.getCount();
for (j = i; j < ln; j++) {
shadowGroup.getAt(j).hide(true);
}
}
}
me.renderLabels();
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
surface = me.chart.surface,
group = me.labelsGroup,
config = me.label,
endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle || {}),
sprite;
return surface.add(Ext.apply({
type: 'text',
group: group
}, endLabelStyle || {}));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate, j, index) {
var me = this,
opt = me.bounds,
groupBarWidth = opt.groupBarWidth,
column = me.column,
chart = me.chart,
chartBBox = chart.chartBBox,
resizing = chart.resizing,
xValue = item.value[0],
yValue = item.value[1],
attr = item.attr,
config = me.label,
rotate = config.orientation == 'vertical',
field = [].concat(config.field),
format = config.renderer,
text = format(storeItem.get(field[index])),
size = me.getLabelSize(text),
width = size.width,
height = size.height,
zero = opt.zero,
outside = 'outside',
insideStart = 'insideStart',
insideEnd = 'insideEnd',
offsetX = 10,
offsetY = 6,
signed = opt.signed,
x, y, finalAttr;
label.setAttributes({
text: text
});
label.isOutside = false;
if (column) {
if (display == outside) {
if (height + offsetY + attr.height > (yValue >= 0 ? zero - chartBBox.y : chartBBox.y + chartBBox.height - zero)) {
display = insideEnd;
}
} else {
if (height + offsetY > attr.height) {
display = outside;
label.isOutside = true;
}
}
x = attr.x + groupBarWidth / 2;
y = display == insideStart ?
(zero + ((height / 2 + 3) * (yValue >= 0 ? -1 : 1))) :
(yValue >= 0 ? (attr.y + ((height / 2 + 3) * (display == outside ? -1 : 1))) :
(attr.y + attr.height + ((height / 2 + 3) * (display === outside ? 1 : -1))));
}
else {
if (display == outside) {
if (width + offsetX + attr.width > (yValue >= 0 ? chartBBox.x + chartBBox.width - zero : zero - chartBBox.x)) {
display = insideEnd;
}
}
else {
if (width + offsetX > attr.width) {
display = outside;
label.isOutside = true;
}
}
x = display == insideStart ?
(zero + ((width / 2 + 5) * (yValue >= 0 ? 1 : -1))) :
(yValue >= 0 ? (attr.x + attr.width + ((width / 2 + 5) * (display === outside ? 1 : -1))) :
(attr.x + ((width / 2 + 5) * (display === outside ? -1 : 1))));
y = attr.y + groupBarWidth / 2;
}
finalAttr = {
x: x,
y: y
};
if (rotate) {
finalAttr.rotate = {
x: x,
y: y,
degrees: 270
};
}
if (animate && resizing) {
if (column) {
x = attr.x + attr.width / 2;
y = zero;
} else {
x = zero;
y = attr.y + attr.height / 2;
}
label.setAttributes({
x: x,
y: y
}, true);
if (rotate) {
label.setAttributes({
rotate: {
x: x,
y: y,
degrees: 270
}
}, true);
}
}
if (animate) {
me.onAnimate(label, { to: finalAttr });
}
else {
label.setAttributes(Ext.apply(finalAttr, {
hidden: false
}), true);
}
},
getLabelSize: function(value) {
var tester = this.testerLabel,
config = this.label,
endLabelStyle = Ext.apply({}, config, this.seriesLabelStyle || {}),
rotated = config.orientation === 'vertical',
bbox, w, h,
undef;
if (!tester) {
tester = this.testerLabel = this.chart.surface.add(Ext.apply({
type: 'text',
opacity: 0
}, endLabelStyle));
}
tester.setAttributes({
text: value
}, true);
bbox = tester.getBBox();
w = bbox.width;
h = bbox.height;
return {
width: rotated ? h : w,
height: rotated ? w : h
};
},
onAnimate: function(sprite, attr) {
sprite.show();
return this.callParent(arguments);
},
isItemInPoint: function(x, y, item) {
var bbox = item.sprite.getBBox();
return bbox.x <= x && bbox.y <= y
&& (bbox.x + bbox.width) >= x
&& (bbox.y + bbox.height) >= y;
},
hideAll: function() {
var axes = this.chart.axes;
if (!isNaN(this._index)) {
if (!this.__excludes) {
this.__excludes = [];
}
this.__excludes[this._index] = true;
this.drawSeries();
axes.each(function(axis) {
axis.drawAxis();
});
}
},
showAll: function() {
var axes = this.chart.axes;
if (!isNaN(this._index)) {
if (!this.__excludes) {
this.__excludes = [];
}
this.__excludes[this._index] = false;
this.drawSeries();
axes.each(function(axis) {
axis.drawAxis();
});
}
},
getLegendColor: function(index) {
var me = this,
colorLength = me.colorArrayStyle.length;
if (me.style && me.style.fill) {
return me.style.fill;
} else {
return me.colorArrayStyle[index % colorLength];
}
},
highlightItem: function(item) {
this.callParent(arguments);
this.renderLabels();
},
unHighlightItem: function() {
this.callParent(arguments);
this.renderLabels();
},
cleanHighlights: function() {
this.callParent(arguments);
this.renderLabels();
}
});
Ext.define('Ext.chart.series.Column', {
alternateClassName: ['Ext.chart.ColumnSeries', 'Ext.chart.ColumnChart', 'Ext.chart.StackedColumnChart'],
extend: 'Ext.chart.series.Bar',
type: 'column',
alias: 'series.column',
column: true,
xPadding: 10,
yPadding: 0
});
Ext.define('Ext.chart.series.Gauge', {
extend: 'Ext.chart.series.Series',
type: "gauge",
alias: 'series.gauge',
rad: Math.PI / 180,
highlightDuration: 150,
angleField: false,
needle: false,
donut: false,
showInLegend: false,
style: {},
constructor: function(config) {
this.callParent(arguments);
var me = this,
chart = me.chart,
surface = chart.surface,
store = chart.store,
shadow = chart.shadow, i, l, cfg;
Ext.apply(me, config, {
shadowAttributes: [{
"stroke-width": 6,
"stroke-opacity": 1,
stroke: 'rgb(200, 200, 200)',
translate: {
x: 1.2,
y: 2
}
},
{
"stroke-width": 4,
"stroke-opacity": 1,
stroke: 'rgb(150, 150, 150)',
translate: {
x: 0.9,
y: 1.5
}
},
{
"stroke-width": 2,
"stroke-opacity": 1,
stroke: 'rgb(100, 100, 100)',
translate: {
x: 0.6,
y: 1
}
}]
});
me.group = surface.getGroup(me.seriesId);
if (shadow) {
for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
}
surface.customAttributes.segment = function(opt) {
return me.getSegment(opt);
};
},
//@private updates some onbefore render parameters.
initialize: function() {
var me = this,
store = me.chart.substore || me.chart.store;
me.yField = [];
if (me.label.field) {
store.each(function(rec) {
me.yField.push(rec.get(me.label.field));
});
}
},
getSegment: function(opt) {
var me = this,
rad = me.rad,
cos = Math.cos,
sin = Math.sin,
abs = Math.abs,
x = me.centerX,
y = me.centerY,
x1 = 0, x2 = 0, x3 = 0, x4 = 0,
y1 = 0, y2 = 0, y3 = 0, y4 = 0,
delta = 1e-2,
r = opt.endRho - opt.startRho,
startAngle = opt.startAngle,
endAngle = opt.endAngle,
midAngle = (startAngle + endAngle) / 2 * rad,
margin = opt.margin || 0,
flag = abs(endAngle - startAngle) > 180,
a1 = Math.min(startAngle, endAngle) * rad,
a2 = Math.max(startAngle, endAngle) * rad,
singleSlice = false;
x += margin * cos(midAngle);
y += margin * sin(midAngle);
x1 = x + opt.startRho * cos(a1);
y1 = y + opt.startRho * sin(a1);
x2 = x + opt.endRho * cos(a1);
y2 = y + opt.endRho * sin(a1);
x3 = x + opt.startRho * cos(a2);
y3 = y + opt.startRho * sin(a2);
x4 = x + opt.endRho * cos(a2);
y4 = y + opt.endRho * sin(a2);
if (abs(x1 - x3) <= delta && abs(y1 - y3) <= delta) {
singleSlice = true;
}
if (singleSlice) {
return {
path: [
["M", x1, y1],
["L", x2, y2],
["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
["Z"]]
};
} else {
return {
path: [
["M", x1, y1],
["L", x2, y2],
["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
["L", x3, y3],
["A", opt.startRho, opt.startRho, 0, +flag, 0, x1, y1],
["Z"]]
};
}
},
calcMiddle: function(item) {
var me = this,
rad = me.rad,
slice = item.slice,
x = me.centerX,
y = me.centerY,
startAngle = slice.startAngle,
endAngle = slice.endAngle,
radius = Math.max(('rho' in slice) ? slice.rho: me.radius, me.label.minMargin),
donut = +me.donut,
a1 = Math.min(startAngle, endAngle) * rad,
a2 = Math.max(startAngle, endAngle) * rad,
midAngle = -(a1 + (a2 - a1) / 2),
xm = x + (item.endRho + item.startRho) / 2 * Math.cos(midAngle),
ym = y - (item.endRho + item.startRho) / 2 * Math.sin(midAngle);
item.middle = {
x: xm,
y: ym
};
},
drawSeries: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
group = me.group,
animate = me.chart.animate,
axis = me.chart.axes.get(0),
minimum = axis && axis.minimum || me.minimum || 0,
maximum = axis && axis.maximum || me.maximum || 0,
field = me.angleField || me.field || me.xField,
surface = chart.surface,
chartBBox = chart.chartBBox,
rad = me.rad,
donut = +me.donut,
values = {},
items = [],
seriesStyle = me.seriesStyle,
seriesLabelStyle = me.seriesLabelStyle,
colorArrayStyle = me.colorArrayStyle,
colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
gutterX = chart.maxGutter[0],
gutterY = chart.maxGutter[1],
cos = Math.cos,
sin = Math.sin,
rendererAttributes, centerX, centerY, slice, slices, sprite, value,
item, ln, record, i, j, startAngle, endAngle, middleAngle, sliceLength, path,
p, spriteOptions, bbox, splitAngle, sliceA, sliceB;
Ext.apply(seriesStyle, me.style || {});
me.setBBox();
bbox = me.bbox;
if (me.colorSet) {
colorArrayStyle = me.colorSet;
colorArrayLength = colorArrayStyle.length;
}
if (!store || !store.getCount()) {
return;
}
centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
centerY = me.centerY = chartBBox.y + chartBBox.height;
me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
me.slices = slices = [];
me.items = items = [];
if (!me.value) {
record = store.getAt(0);
me.value = record.get(field);
}
value = me.value;
if (me.needle) {
sliceA = {
series: me,
value: value,
startAngle: -180,
endAngle: 0,
rho: me.radius
};
splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
slices.push(sliceA);
} else {
splitAngle = -180 * (1 - (value - minimum) / (maximum - minimum));
sliceA = {
series: me,
value: value,
startAngle: -180,
endAngle: splitAngle,
rho: me.radius
};
sliceB = {
series: me,
value: me.maximum - value,
startAngle: splitAngle,
endAngle: 0,
rho: me.radius
};
slices.push(sliceA, sliceB);
}
for (i = 0, ln = slices.length; i < ln; i++) {
slice = slices[i];
sprite = group.getAt(i);
rendererAttributes = Ext.apply({
segment: {
startAngle: slice.startAngle,
endAngle: slice.endAngle,
margin: 0,
rho: slice.rho,
startRho: slice.rho * +donut / 100,
endRho: slice.rho
}
}, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
item = Ext.apply({},
rendererAttributes.segment, {
slice: slice,
series: me,
storeItem: record,
index: i
});
items[i] = item;
if (!sprite) {
spriteOptions = Ext.apply({
type: "path",
group: group
}, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[i % colorArrayLength] } || {}));
sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
}
slice.sprite = slice.sprite || [];
item.sprite = sprite;
slice.sprite.push(sprite);
if (animate) {
rendererAttributes = me.renderer(sprite, record, rendererAttributes, i, store);
sprite._to = rendererAttributes;
me.onAnimate(sprite, {
to: rendererAttributes
});
} else {
rendererAttributes = me.renderer(sprite, record, Ext.apply(rendererAttributes, {
hidden: false
}), i, store);
sprite.setAttributes(rendererAttributes, true);
}
}
if (me.needle) {
splitAngle = splitAngle * Math.PI / 180;
if (!me.needleSprite) {
me.needleSprite = me.chart.surface.add({
type: 'path',
path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
'L', centerX + me.radius * cos(splitAngle),
centerY + -Math.abs(me.radius * sin(splitAngle))],
'stroke-width': 4,
'stroke': '#222'
});
} else {
if (animate) {
me.onAnimate(me.needleSprite, {
to: {
path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
'L', centerX + me.radius * cos(splitAngle),
centerY + -Math.abs(me.radius * sin(splitAngle))]
}
});
} else {
me.needleSprite.setAttributes({
type: 'path',
path: ['M', centerX + (me.radius * +donut / 100) * cos(splitAngle),
centerY + -Math.abs((me.radius * +donut / 100) * sin(splitAngle)),
'L', centerX + me.radius * cos(splitAngle),
centerY + -Math.abs(me.radius * sin(splitAngle))]
});
}
}
me.needleSprite.setAttributes({
hidden: false
}, true);
}
delete me.value;
},
setValue: function (value) {
this.value = value;
this.drawSeries();
},
onCreateLabel: function(storeItem, item, i, display) {},
onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {},
onPlaceCallout: function() {},
onAnimate: function(sprite, attr) {
sprite.show();
return this.callParent(arguments);
},
isItemInPoint: function(x, y, item, i) {
return false;
},
showAll: function() {
if (!isNaN(this._index)) {
this.__excludes[this._index] = false;
this.drawSeries();
}
},
getLegendColor: function(index) {
var me = this;
return me.colorArrayStyle[index % me.colorArrayStyle.length];
}
});
Ext.define('Ext.chart.series.Line', {
extend: 'Ext.chart.series.Cartesian',
alternateClassName: ['Ext.chart.LineSeries', 'Ext.chart.LineChart'],
requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.draw.Draw', 'Ext.fx.Anim'],
type: 'line',
alias: 'series.line',
selectionTolerance: 20,
showMarkers: true,
markerConfig: {},
style: {},
smooth: false,
defaultSmoothness: 3,
fill: false,
constructor: function(config) {
this.callParent(arguments);
var me = this,
surface = me.chart.surface,
shadow = me.chart.shadow,
i, l;
Ext.apply(me, config, {
highlightCfg: {
'stroke-width': 3
},
shadowAttributes: [{
"stroke-width": 6,
"stroke-opacity": 0.05,
stroke: 'rgb(0, 0, 0)',
translate: {
x: 1,
y: 1
}
}, {
"stroke-width": 4,
"stroke-opacity": 0.1,
stroke: 'rgb(0, 0, 0)',
translate: {
x: 1,
y: 1
}
}, {
"stroke-width": 2,
"stroke-opacity": 0.15,
stroke: 'rgb(0, 0, 0)',
translate: {
x: 1,
y: 1
}
}]
});
me.group = surface.getGroup(me.seriesId);
if (me.showMarkers) {
me.markerGroup = surface.getGroup(me.seriesId + '-markers');
}
if (shadow) {
for (i = 0, l = this.shadowAttributes.length; i < l; i++) {
me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
}
},
shrink: function(xValues, yValues, size) {
var len = xValues.length,
ratio = Math.floor(len / size),
i = 1,
xSum = 0,
ySum = 0,
xRes = [xValues[0]],
yRes = [yValues[0]];
for (; i < len; ++i) {
xSum += xValues[i] || 0;
ySum += yValues[i] || 0;
if (i % ratio == 0) {
xRes.push(xSum/ratio);
yRes.push(ySum/ratio);
xSum = 0;
ySum = 0;
}
}
return {
x: xRes,
y: yRes
};
},
drawSeries: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
surface = chart.surface,
chartBBox = chart.chartBBox,
bbox = {},
group = me.group,
gutterX = chart.maxGutter[0],
gutterY = chart.maxGutter[1],
showMarkers = me.showMarkers,
markerGroup = me.markerGroup,
enableShadows = chart.shadow,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
smooth = me.smooth,
lnsh = shadowGroups.length,
dummyPath = ["M"],
path = ["M"],
markerIndex = chart.markerIndex,
axes = [].concat(me.axis),
shadowGroup,
shadowBarAttr,
xValues = [],
yValues = [],
storeIndices = [],
numericAxis = true,
axisCount = 0,
onbreak = false,
markerStyle = me.markerStyle,
seriesStyle = me.seriesStyle,
seriesLabelStyle = me.seriesLabelStyle,
colorArrayStyle = me.colorArrayStyle,
colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
posHash = {
'left': 'right',
'right': 'left',
'top': 'bottom',
'bottom': 'top'
},
isNumber = Ext.isNumber,
seriesIdx = me.seriesIdx, shadows, shadow, shindex, fromPath, fill, fillPath, rendererAttributes,
x, y, prevX, prevY, firstY, markerCount, i, j, ln, axis, ends, marker, markerAux, item, xValue,
yValue, coords, xScale, yScale, minX, maxX, minY, maxY, line, animation, endMarkerStyle,
endLineStyle, type, props, firstMarker, count, smoothPath, renderPath;
if (!store || !store.getCount()) {
return;
}
endMarkerStyle = Ext.apply(markerStyle, me.markerConfig);
type = endMarkerStyle.type;
delete endMarkerStyle.type;
endLineStyle = Ext.apply(seriesStyle, me.style);
if (!endLineStyle['stroke-width']) {
endLineStyle['stroke-width'] = 0.5;
}
if (markerIndex && markerGroup && markerGroup.getCount()) {
for (i = 0; i < markerIndex; i++) {
marker = markerGroup.getAt(i);
markerGroup.remove(marker);
markerGroup.add(marker);
markerAux = markerGroup.getAt(markerGroup.getCount() - 2);
marker.setAttributes({
x: 0,
y: 0,
translate: {
x: markerAux.attr.translation.x,
y: markerAux.attr.translation.y
}
}, true);
}
}
me.unHighlightItem();
me.cleanHighlights();
me.setBBox();
bbox = me.bbox;
me.clipRect = [bbox.x, bbox.y, bbox.width, bbox.height];
chart.axes.each(function(axis) {
if (axis.position == me.axis || axis.position != posHash[me.axis]) {
axisCount++;
if (axis.type != 'Numeric') {
numericAxis = false;
return;
}
numericAxis = (numericAxis && axis.type == 'Numeric');
if (axis) {
ends = axis.calcEnds();
if (axis.position == 'top' || axis.position == 'bottom') {
minX = ends.from;
maxX = ends.to;
}
else {
minY = ends.from;
maxY = ends.to;
}
}
}
});
if (numericAxis && axisCount == 1) {
numericAxis = false;
}
if (me.xField && !isNumber(minX)) {
if (me.axis == 'bottom' || me.axis == 'top') {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.xField)
}).calcEnds();
minX = axis.from;
maxX = axis.to;
} else if (numericAxis) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.xField),
forceMinMax: true
}).calcEnds();
minX = axis.from;
maxX = axis.to;
}
}
if (me.yField && !isNumber(minY)) {
if (me.axis == 'right' || me.axis == 'left') {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.yField)
}).calcEnds();
minY = axis.from;
maxY = axis.to;
} else if (numericAxis) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.yField),
forceMinMax: true
}).calcEnds();
minY = axis.from;
maxY = axis.to;
}
}
if (isNaN(minX)) {
minX = 0;
xScale = bbox.width / (store.getCount() - 1);
}
else {
xScale = bbox.width / ((maxX - minX) || (store.getCount() - 1));
}
if (isNaN(minY)) {
minY = 0;
yScale = bbox.height / (store.getCount() - 1);
}
else {
yScale = bbox.height / ((maxY - minY) || (store.getCount() - 1));
}
store.each(function(record, i) {
xValue = record.get(me.xField);
yValue = record.get(me.yField);
if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)) {
return;
}
if (typeof xValue == 'string' || typeof xValue == 'object'
|| (me.axis != 'top' && me.axis != 'bottom' && !numericAxis)) {
xValue = i;
}
if (typeof yValue == 'string' || typeof yValue == 'object'
|| (me.axis != 'left' && me.axis != 'right' && !numericAxis)) {
yValue = i;
}
storeIndices.push(i);
xValues.push(xValue);
yValues.push(yValue);
}, me);
ln = xValues.length;
if (ln > bbox.width) {
coords = me.shrink(xValues, yValues, bbox.width);
xValues = coords.x;
yValues = coords.y;
}
me.items = [];
count = 0;
ln = xValues.length;
for (i = 0; i < ln; i++) {
xValue = xValues[i];
yValue = yValues[i];
if (yValue === false) {
if (path.length == 1) {
path = [];
}
onbreak = true;
me.items.push(false);
continue;
} else {
x = (bbox.x + (xValue - minX) * xScale).toFixed(2);
y = ((bbox.y + bbox.height) - (yValue - minY) * yScale).toFixed(2);
if (onbreak) {
onbreak = false;
path.push('M');
}
path = path.concat([x, y]);
}
if ((typeof firstY == 'undefined') && (typeof y != 'undefined')) {
firstY = y;
}
if (!me.line || chart.resizing) {
dummyPath = dummyPath.concat([x, bbox.y + bbox.height / 2]);
}
if (chart.animate && chart.resizing && me.line) {
me.line.setAttributes({
path: dummyPath
}, true);
if (me.fillPath) {
me.fillPath.setAttributes({
path: dummyPath,
opacity: 0.2
}, true);
}
if (me.line.shadows) {
shadows = me.line.shadows;
for (j = 0, lnsh = shadows.length; j < lnsh; j++) {
shadow = shadows[j];
shadow.setAttributes({
path: dummyPath
}, true);
}
}
}
if (showMarkers) {
marker = markerGroup.getAt(count++);
if (!marker) {
marker = Ext.chart.Shape[type](surface, Ext.apply({
group: [group, markerGroup],
x: 0, y: 0,
translate: {
x: prevX || x,
y: prevY || (bbox.y + bbox.height / 2)
},
value: '"' + xValue + ', ' + yValue + '"'
}, endMarkerStyle));
marker._to = {
translate: {
x: x,
y: y
}
};
} else {
marker.setAttributes({
value: '"' + xValue + ', ' + yValue + '"',
x: 0, y: 0,
hidden: false
}, true);
marker._to = {
translate: {
x: x, y: y
}
};
}
}
me.items.push({
series: me,
value: [xValue, yValue],
point: [x, y],
sprite: marker,
storeItem: store.getAt(storeIndices[i])
});
prevX = x;
prevY = y;
}
if (path.length <= 1) {
return;
}
if (smooth) {
smoothPath = Ext.draw.Draw.smooth(path, isNumber(smooth) ? smooth : me.defaultSmoothness);
}
renderPath = smooth ? smoothPath : path;
if (chart.markerIndex && me.previousPath) {
fromPath = me.previousPath;
if (!smooth) {
Ext.Array.erase(fromPath, 1, 2);
}
} else {
fromPath = path;
}
if (!me.line) {
me.line = surface.add(Ext.apply({
type: 'path',
group: group,
path: dummyPath,
stroke: endLineStyle.stroke || endLineStyle.fill
}, endLineStyle || {}));
me.line.setAttributes({
fill: 'none'
});
if (!endLineStyle.stroke && colorArrayLength) {
me.line.setAttributes({
stroke: colorArrayStyle[seriesIdx % colorArrayLength]
}, true);
}
if (enableShadows) {
shadows = me.line.shadows = [];
for (shindex = 0; shindex < lnsh; shindex++) {
shadowBarAttr = shadowAttributes[shindex];
shadowBarAttr = Ext.apply({}, shadowBarAttr, { path: dummyPath });
shadow = chart.surface.add(Ext.apply({}, {
type: 'path',
group: shadowGroups[shindex]
}, shadowBarAttr));
shadows.push(shadow);
}
}
}
if (me.fill) {
fillPath = renderPath.concat([
["L", x, bbox.y + bbox.height],
["L", bbox.x, bbox.y + bbox.height],
["L", bbox.x, firstY]
]);
if (!me.fillPath) {
me.fillPath = surface.add({
group: group,
type: 'path',
opacity: endLineStyle.opacity || 0.3,
fill: endLineStyle.fill || colorArrayStyle[seriesIdx % colorArrayLength],
path: dummyPath
});
}
}
markerCount = showMarkers && markerGroup.getCount();
if (chart.animate) {
fill = me.fill;
line = me.line;
rendererAttributes = me.renderer(line, false, { path: renderPath }, i, store);
Ext.apply(rendererAttributes, endLineStyle || {}, {
stroke: endLineStyle.stroke || endLineStyle.fill
});
delete rendererAttributes.fill;
if (chart.markerIndex && me.previousPath) {
me.animation = animation = me.onAnimate(line, {
to: rendererAttributes,
from: {
path: fromPath
}
});
} else {
me.animation = animation = me.onAnimate(line, {
to: rendererAttributes
});
}
if (enableShadows) {
shadows = line.shadows;
for(j = 0; j < lnsh; j++) {
if (chart.markerIndex && me.previousPath) {
me.onAnimate(shadows[j], {
to: { path: renderPath },
from: { path: fromPath }
});
} else {
me.onAnimate(shadows[j], {
to: { path: renderPath }
});
}
}
}
if (fill) {
me.onAnimate(me.fillPath, {
to: Ext.apply({}, {
path: fillPath,
fill: endLineStyle.fill || colorArrayStyle[seriesIdx % colorArrayLength]
}, endLineStyle || {})
});
}
if (showMarkers) {
count = 0;
for(i = 0; i < ln; i++) {
if (me.items[i]) {
item = markerGroup.getAt(count++);
if (item) {
rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
me.onAnimate(item, {
to: Ext.apply(rendererAttributes, endMarkerStyle || {})
});
}
}
}
for(; count < markerCount; count++) {
item = markerGroup.getAt(count);
item.hide(true);
}
}
} else {
rendererAttributes = me.renderer(me.line, false, { path: renderPath, hidden: false }, i, store);
Ext.apply(rendererAttributes, endLineStyle || {}, {
stroke: endLineStyle.stroke || endLineStyle.fill
});
delete rendererAttributes.fill;
me.line.setAttributes(rendererAttributes, true);
if (enableShadows) {
shadows = me.line.shadows;
for(j = 0; j < lnsh; j++) {
shadows[j].setAttributes({
path: renderPath
}, true);
}
}
if (me.fill) {
me.fillPath.setAttributes({
path: fillPath
}, true);
}
if (showMarkers) {
count = 0;
for(i = 0; i < ln; i++) {
if (me.items[i]) {
item = markerGroup.getAt(count++);
if (item) {
rendererAttributes = me.renderer(item, store.getAt(i), item._to, i, store);
item.setAttributes(Ext.apply(endMarkerStyle || {}, rendererAttributes || {}), true);
}
}
}
for(; count < markerCount; count++) {
item = markerGroup.getAt(count);
item.hide(true);
}
}
}
if (chart.markerIndex) {
if (me.smooth) {
Ext.Array.erase(path, 1, 2);
} else {
Ext.Array.splice(path, 1, 0, path[1], path[2]);
}
me.previousPath = path;
}
me.renderLabels();
me.renderCallouts();
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
group = me.labelsGroup,
config = me.label,
bbox = me.bbox,
endLabelStyle = Ext.apply(config, me.seriesLabelStyle);
return me.chart.surface.add(Ext.apply({
'type': 'text',
'text-anchor': 'middle',
'group': group,
'x': item.point[0],
'y': bbox.y + bbox.height / 2
}, endLabelStyle || {}));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.label,
format = config.renderer,
field = config.field,
bbox = me.bbox,
x = item.point[0],
y = item.point[1],
radius = item.sprite.attr.radius,
bb, width, height;
label.setAttributes({
text: format(storeItem.get(field)),
hidden: true
}, true);
if (display == 'rotate') {
label.setAttributes({
'text-anchor': 'start',
'rotation': {
x: x,
y: y,
degrees: -45
}
}, true);
bb = label.getBBox();
width = bb.width;
height = bb.height;
x = x < bbox.x? bbox.x : x;
x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
y = (y - height < bbox.y)? bbox.y + height : y;
} else if (display == 'under' || display == 'over') {
bb = item.sprite.getBBox();
bb.width = bb.width || (radius * 2);
bb.height = bb.height || (radius * 2);
y = y + (display == 'over'? -bb.height : bb.height);
bb = label.getBBox();
width = bb.width/2;
height = bb.height/2;
x = x - width < bbox.x? bbox.x + width : x;
x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
y = y - height < bbox.y? bbox.y + height : y;
y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
}
if (me.chart.animate && !me.chart.resizing) {
label.show(true);
me.onAnimate(label, {
to: {
x: x,
y: y
}
});
} else {
label.setAttributes({
x: x,
y: y
}, true);
if (resizing) {
me.animation.on('afteranimate', function() {
label.show(true);
});
} else {
label.show(true);
}
}
},
//@private Overriding highlights.js highlightItem method.
highlightItem: function() {
var me = this;
me.callParent(arguments);
if (this.line && !this.highlighted) {
if (!('__strokeWidth' in this.line)) {
this.line.__strokeWidth = this.line.attr['stroke-width'] || 0;
}
if (this.line.__anim) {
this.line.__anim.paused = true;
}
this.line.__anim = Ext.create('Ext.fx.Anim', {
target: this.line,
to: {
'stroke-width': this.line.__strokeWidth + 3
}
});
this.highlighted = true;
}
},
//@private Overriding highlights.js unHighlightItem method.
unHighlightItem: function() {
var me = this;
me.callParent(arguments);
if (this.line && this.highlighted) {
this.line.__anim = Ext.create('Ext.fx.Anim', {
target: this.line,
to: {
'stroke-width': this.line.__strokeWidth
}
});
this.highlighted = false;
}
},
//@private called when a callout needs to be placed.
onPlaceCallout : function(callout, storeItem, item, i, display, animate, index) {
if (!display) {
return;
}
var me = this,
chart = me.chart,
surface = chart.surface,
resizing = chart.resizing,
config = me.callouts,
items = me.items,
prev = i == 0? false : items[i -1].point,
next = (i == items.length -1)? false : items[i +1].point,
cur = [+item.point[0], +item.point[1]],
dir, norm, normal, a, aprev, anext,
offsetFromViz = config.offsetFromViz || 30,
offsetToSide = config.offsetToSide || 10,
offsetBox = config.offsetBox || 3,
boxx, boxy, boxw, boxh,
p, clipRect = me.clipRect,
bbox = {
width: config.styles.width || 10,
height: config.styles.height || 10
},
x, y;
if (!prev) {
prev = cur;
}
if (!next) {
next = cur;
}
a = (next[1] - prev[1]) / (next[0] - prev[0]);
aprev = (cur[1] - prev[1]) / (cur[0] - prev[0]);
anext = (next[1] - cur[1]) / (next[0] - cur[0]);
norm = Math.sqrt(1 + a * a);
dir = [1 / norm, a / norm];
normal = [-dir[1], dir[0]];
if (aprev > 0 && anext < 0 && normal[1] < 0
|| aprev < 0 && anext > 0 && normal[1] > 0) {
normal[0] *= -1;
normal[1] *= -1;
} else if (Math.abs(aprev) < Math.abs(anext) && normal[0] < 0
|| Math.abs(aprev) > Math.abs(anext) && normal[0] > 0) {
normal[0] *= -1;
normal[1] *= -1;
}
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
normal[0] *= -1;
}
if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
normal[1] *= -1;
}
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
if (chart.animate) {
me.onAnimate(callout.lines, {
to: {
path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}
});
if (callout.panel) {
callout.panel.setPosition(boxx, boxy, true);
}
}
else {
callout.lines.setAttributes({
path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}, true);
if (callout.panel) {
callout.panel.setPosition(boxx, boxy);
}
}
for (p in callout) {
callout[p].show(true);
}
},
isItemInPoint: function(x, y, item, i) {
var me = this,
items = me.items,
tolerance = me.selectionTolerance,
result = null,
prevItem,
nextItem,
prevPoint,
nextPoint,
ln,
x1,
y1,
x2,
y2,
xIntersect,
yIntersect,
dist1, dist2, dist, midx, midy,
sqrt = Math.sqrt, abs = Math.abs;
nextItem = items[i];
prevItem = i && items[i - 1];
if (i >= ln) {
prevItem = items[ln - 1];
}
prevPoint = prevItem && prevItem.point;
nextPoint = nextItem && nextItem.point;
x1 = prevItem ? prevPoint[0] : nextPoint[0] - tolerance;
y1 = prevItem ? prevPoint[1] : nextPoint[1];
x2 = nextItem ? nextPoint[0] : prevPoint[0] + tolerance;
y2 = nextItem ? nextPoint[1] : prevPoint[1];
dist1 = sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
dist2 = sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
dist = Math.min(dist1, dist2);
if (dist <= tolerance) {
return dist == dist1? prevItem : nextItem;
}
return false;
},
toggleAll: function(show) {
var me = this,
i, ln, shadow, shadows;
if (!show) {
Ext.chart.series.Line.superclass.hideAll.call(me);
}
else {
Ext.chart.series.Line.superclass.showAll.call(me);
}
if (me.line) {
me.line.setAttributes({
hidden: !show
}, true);
if (me.line.shadows) {
for (i = 0, shadows = me.line.shadows, ln = shadows.length; i < ln; i++) {
shadow = shadows[i];
shadow.setAttributes({
hidden: !show
}, true);
}
}
}
if (me.fillPath) {
me.fillPath.setAttributes({
hidden: !show
}, true);
}
},
hideAll: function() {
this.toggleAll(false);
},
showAll: function() {
this.toggleAll(true);
}
});
Ext.define('Ext.chart.series.Pie', {
alternateClassName: ['Ext.chart.PieSeries', 'Ext.chart.PieChart'],
extend: 'Ext.chart.series.Series',
type: "pie",
alias: 'series.pie',
rad: Math.PI / 180,
highlightDuration: 150,
angleField: false,
lengthField: false,
donut: false,
showInLegend: false,
style: {},
constructor: function(config) {
this.callParent(arguments);
var me = this,
chart = me.chart,
surface = chart.surface,
store = chart.store,
shadow = chart.shadow, i, l, cfg;
Ext.applyIf(me, {
highlightCfg: {
segment: {
margin: 20
}
}
});
Ext.apply(me, config, {
shadowAttributes: [{
"stroke-width": 6,
"stroke-opacity": 1,
stroke: 'rgb(200, 200, 200)',
translate: {
x: 1.2,
y: 2
}
},
{
"stroke-width": 4,
"stroke-opacity": 1,
stroke: 'rgb(150, 150, 150)',
translate: {
x: 0.9,
y: 1.5
}
},
{
"stroke-width": 2,
"stroke-opacity": 1,
stroke: 'rgb(100, 100, 100)',
translate: {
x: 0.6,
y: 1
}
}]
});
me.group = surface.getGroup(me.seriesId);
if (shadow) {
for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
}
surface.customAttributes.segment = function(opt) {
return me.getSegment(opt);
};
},
//@private updates some onbefore render parameters.
initialize: function() {
var me = this,
store = me.chart.substore || me.chart.store;
me.yField = [];
if (me.label.field) {
store.each(function(rec) {
me.yField.push(rec.get(me.label.field));
});
}
},
getSegment: function(opt) {
var me = this,
rad = me.rad,
cos = Math.cos,
sin = Math.sin,
abs = Math.abs,
x = me.centerX,
y = me.centerY,
x1 = 0, x2 = 0, x3 = 0, x4 = 0,
y1 = 0, y2 = 0, y3 = 0, y4 = 0,
delta = 1e-2,
r = opt.endRho - opt.startRho,
startAngle = opt.startAngle,
endAngle = opt.endAngle,
midAngle = (startAngle + endAngle) / 2 * rad,
margin = opt.margin || 0,
flag = abs(endAngle - startAngle) > 180,
a1 = Math.min(startAngle, endAngle) * rad,
a2 = Math.max(startAngle, endAngle) * rad,
singleSlice = false;
x += margin * cos(midAngle);
y += margin * sin(midAngle);
x1 = x + opt.startRho * cos(a1);
y1 = y + opt.startRho * sin(a1);
x2 = x + opt.endRho * cos(a1);
y2 = y + opt.endRho * sin(a1);
x3 = x + opt.startRho * cos(a2);
y3 = y + opt.startRho * sin(a2);
x4 = x + opt.endRho * cos(a2);
y4 = y + opt.endRho * sin(a2);
if (abs(x1 - x3) <= delta && abs(y1 - y3) <= delta) {
singleSlice = true;
}
if (singleSlice) {
return {
path: [
["M", x1, y1],
["L", x2, y2],
["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
["Z"]]
};
} else {
return {
path: [
["M", x1, y1],
["L", x2, y2],
["A", opt.endRho, opt.endRho, 0, +flag, 1, x4, y4],
["L", x3, y3],
["A", opt.startRho, opt.startRho, 0, +flag, 0, x1, y1],
["Z"]]
};
}
},
calcMiddle: function(item) {
var me = this,
rad = me.rad,
slice = item.slice,
x = me.centerX,
y = me.centerY,
startAngle = slice.startAngle,
endAngle = slice.endAngle,
donut = +me.donut,
a1 = Math.min(startAngle, endAngle) * rad,
a2 = Math.max(startAngle, endAngle) * rad,
midAngle = -(a1 + (a2 - a1) / 2),
xm = x + (item.endRho + item.startRho) / 2 * Math.cos(midAngle),
ym = y - (item.endRho + item.startRho) / 2 * Math.sin(midAngle);
item.middle = {
x: xm,
y: ym
};
},
drawSeries: function() {
var me = this,
store = me.chart.substore || me.chart.store,
group = me.group,
animate = me.chart.animate,
field = me.angleField || me.field || me.xField,
lenField = [].concat(me.lengthField),
totalLenField = 0,
colors = me.colorSet,
chart = me.chart,
surface = chart.surface,
chartBBox = chart.chartBBox,
enableShadows = chart.shadow,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
lnsh = shadowGroups.length,
rad = me.rad,
layers = lenField.length,
rhoAcum = 0,
donut = +me.donut,
layerTotals = [],
values = {},
fieldLength,
items = [],
passed = false,
totalField = 0,
maxLenField = 0,
cut = 9,
defcut = true,
angle = 0,
seriesStyle = me.seriesStyle,
seriesLabelStyle = me.seriesLabelStyle,
colorArrayStyle = me.colorArrayStyle,
colorArrayLength = colorArrayStyle && colorArrayStyle.length || 0,
gutterX = chart.maxGutter[0],
gutterY = chart.maxGutter[1],
rendererAttributes,
shadowGroup,
shadowAttr,
shadows,
shadow,
shindex,
centerX,
centerY,
deltaRho,
first = 0,
slice,
slices,
sprite,
value,
item,
lenValue,
ln,
record,
i,
j,
startAngle,
endAngle,
middleAngle,
sliceLength,
path,
p,
spriteOptions, bbox;
Ext.apply(seriesStyle, me.style || {});
me.setBBox();
bbox = me.bbox;
if (me.colorSet) {
colorArrayStyle = me.colorSet;
colorArrayLength = colorArrayStyle.length;
}
if (!store || !store.getCount()) {
return;
}
me.unHighlightItem();
me.cleanHighlights();
centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
me.radius = Math.min(centerX - chartBBox.x, centerY - chartBBox.y);
me.slices = slices = [];
me.items = items = [];
store.each(function(record, i) {
if (this.__excludes && this.__excludes[i]) {
return;
}
totalField += +record.get(field);
if (lenField[0]) {
for (j = 0, totalLenField = 0; j < layers; j++) {
totalLenField += +record.get(lenField[j]);
}
layerTotals[i] = totalLenField;
maxLenField = Math.max(maxLenField, totalLenField);
}
}, this);
store.each(function(record, i) {
if (this.__excludes && this.__excludes[i]) {
return;
}
value = record.get(field);
middleAngle = angle - 360 * value / totalField / 2;
if (isNaN(middleAngle)) {
middleAngle = 360;
value = 1;
totalField = 1;
}
if (!i || first == 0) {
angle = 360 - middleAngle;
me.firstAngle = angle;
middleAngle = angle - 360 * value / totalField / 2;
}
endAngle = angle - 360 * value / totalField;
slice = {
series: me,
value: value,
startAngle: angle,
endAngle: endAngle,
storeItem: record
};
if (lenField[0]) {
lenValue = layerTotals[i];
slice.rho = me.radius * (lenValue / maxLenField);
} else {
slice.rho = me.radius;
}
slices[i] = slice;
if((slice.startAngle % 360) == (slice.endAngle % 360)) {
slice.startAngle -= 0.0001;
}
angle = endAngle;
first++;
}, me);
if (enableShadows) {
for (i = 0, ln = slices.length; i < ln; i++) {
if (this.__excludes && this.__excludes[i]) {
continue;
}
slice = slices[i];
slice.shadowAttrs = [];
for (j = 0, rhoAcum = 0, shadows = []; j < layers; j++) {
sprite = group.getAt(i * layers + j);
deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
rendererAttributes = {
segment: {
startAngle: slice.startAngle,
endAngle: slice.endAngle,
margin: 0,
rho: slice.rho,
startRho: rhoAcum + (deltaRho * donut / 100),
endRho: rhoAcum + deltaRho
}
};
for (shindex = 0, shadows = []; shindex < lnsh; shindex++) {
shadowAttr = shadowAttributes[shindex];
shadow = shadowGroups[shindex].getAt(i);
if (!shadow) {
shadow = chart.surface.add(Ext.apply({}, {
type: 'path',
group: shadowGroups[shindex],
strokeLinejoin: "round"
}, rendererAttributes, shadowAttr));
}
if (animate) {
shadowAttr = me.renderer(shadow, store.getAt(i), Ext.apply({}, rendererAttributes, shadowAttr), i, store);
me.onAnimate(shadow, {
to: shadowAttr
});
} else {
shadowAttr = me.renderer(shadow, store.getAt(i), Ext.apply(shadowAttr, {
hidden: false
}), i, store);
shadow.setAttributes(shadowAttr, true);
}
shadows.push(shadow);
}
slice.shadowAttrs[j] = shadows;
}
}
}
for (i = 0, ln = slices.length; i < ln; i++) {
if (this.__excludes && this.__excludes[i]) {
continue;
}
slice = slices[i];
for (j = 0, rhoAcum = 0; j < layers; j++) {
sprite = group.getAt(i * layers + j);
deltaRho = lenField[j] ? store.getAt(i).get(lenField[j]) / layerTotals[i] * slice.rho: slice.rho;
rendererAttributes = Ext.apply({
segment: {
startAngle: slice.startAngle,
endAngle: slice.endAngle,
margin: 0,
rho: slice.rho,
startRho: rhoAcum + (deltaRho * donut / 100),
endRho: rhoAcum + deltaRho
}
}, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
item = Ext.apply({},
rendererAttributes.segment, {
slice: slice,
series: me,
storeItem: slice.storeItem,
index: i
});
me.calcMiddle(item);
if (enableShadows) {
item.shadows = slice.shadowAttrs[j];
}
items[i] = item;
if (!sprite) {
spriteOptions = Ext.apply({
type: "path",
group: group,
middle: item.middle
}, Ext.apply(seriesStyle, colorArrayStyle && { fill: colorArrayStyle[(layers > 1? j : i) % colorArrayLength] } || {}));
sprite = surface.add(Ext.apply(spriteOptions, rendererAttributes));
}
slice.sprite = slice.sprite || [];
item.sprite = sprite;
slice.sprite.push(sprite);
slice.point = [item.middle.x, item.middle.y];
if (animate) {
rendererAttributes = me.renderer(sprite, store.getAt(i), rendererAttributes, i, store);
sprite._to = rendererAttributes;
sprite._animating = true;
me.onAnimate(sprite, {
to: rendererAttributes,
listeners: {
afteranimate: {
fn: function() {
this._animating = false;
},
scope: sprite
}
}
});
} else {
rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply(rendererAttributes, {
hidden: false
}), i, store);
sprite.setAttributes(rendererAttributes, true);
}
rhoAcum += deltaRho;
}
}
ln = group.getCount();
for (i = 0; i < ln; i++) {
if (!slices[(i / layers) >> 0] && group.getAt(i)) {
group.getAt(i).hide(true);
}
}
if (enableShadows) {
lnsh = shadowGroups.length;
for (shindex = 0; shindex < ln; shindex++) {
if (!slices[(shindex / layers) >> 0]) {
for (j = 0; j < lnsh; j++) {
if (shadowGroups[j].getAt(shindex)) {
shadowGroups[j].getAt(shindex).hide(true);
}
}
}
}
}
me.renderLabels();
me.renderCallouts();
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
group = me.labelsGroup,
config = me.label,
centerX = me.centerX,
centerY = me.centerY,
middle = item.middle,
endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config || {});
return me.chart.surface.add(Ext.apply({
'type': 'text',
'text-anchor': 'middle',
'group': group,
'x': middle.x,
'y': middle.y
}, endLabelStyle));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate, index) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.label,
format = config.renderer,
field = [].concat(config.field),
centerX = me.centerX,
centerY = me.centerY,
middle = item.middle,
opt = {
x: middle.x,
y: middle.y
},
x = middle.x - centerX,
y = middle.y - centerY,
from = {},
rho = 1,
theta = Math.atan2(y, x || 1),
dg = theta * 180 / Math.PI,
prevDg;
function fixAngle(a) {
if (a < 0) a += 360;
return a % 360;
}
label.setAttributes({
text: format(storeItem.get(field[index]))
}, true);
switch (display) {
case 'outside':
rho = Math.sqrt(x * x + y * y) * 2;
opt.x = rho * Math.cos(theta) + centerX;
opt.y = rho * Math.sin(theta) + centerY;
break;
case 'rotate':
dg = fixAngle(dg);
dg = (dg > 90 && dg < 270) ? dg + 180: dg;
prevDg = label.attr.rotation.degrees;
if (prevDg != null && Math.abs(prevDg - dg) > 180) {
if (dg > prevDg) {
dg -= 360;
} else {
dg += 360;
}
dg = dg % 360;
} else {
dg = fixAngle(dg);
}
opt.rotate = {
degrees: dg,
x: opt.x,
y: opt.y
};
break;
default:
break;
}
opt.translate = {
x: 0, y: 0
};
if (animate && !resizing && (display != 'rotate' || prevDg != null)) {
me.onAnimate(label, {
to: opt
});
} else {
label.setAttributes(opt, true);
}
label._from = from;
},
onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.callouts,
centerX = me.centerX,
centerY = me.centerY,
middle = item.middle,
opt = {
x: middle.x,
y: middle.y
},
x = middle.x - centerX,
y = middle.y - centerY,
rho = 1,
rhoCenter,
theta = Math.atan2(y, x || 1),
bbox = callout.label.getBBox(),
offsetFromViz = 20,
offsetToSide = 10,
offsetBox = 10,
p;
rho = item.endRho + offsetFromViz;
rhoCenter = (item.endRho + item.startRho) / 2 + (item.endRho - item.startRho) / 3;
opt.x = rho * Math.cos(theta) + centerX;
opt.y = rho * Math.sin(theta) + centerY;
x = rhoCenter * Math.cos(theta);
y = rhoCenter * Math.sin(theta);
if (chart.animate) {
me.onAnimate(callout.lines, {
to: {
path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
}
});
me.onAnimate(callout.box, {
to: {
x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
width: bbox.width + 2 * offsetBox,
height: bbox.height + 2 * offsetBox
}
});
me.onAnimate(callout.label, {
to: {
x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
}
});
} else {
callout.lines.setAttributes({
path: ["M", x + centerX, y + centerY, "L", opt.x, opt.y, "Z", "M", opt.x, opt.y, "l", x > 0 ? offsetToSide: -offsetToSide, 0, "z"]
},
true);
callout.box.setAttributes({
x: opt.x + (x > 0 ? offsetToSide: -(offsetToSide + bbox.width + 2 * offsetBox)),
y: opt.y + (y > 0 ? ( - bbox.height - offsetBox / 2) : ( - bbox.height - offsetBox / 2)),
width: bbox.width + 2 * offsetBox,
height: bbox.height + 2 * offsetBox
},
true);
callout.label.setAttributes({
x: opt.x + (x > 0 ? (offsetToSide + offsetBox) : -(offsetToSide + bbox.width + offsetBox)),
y: opt.y + (y > 0 ? -bbox.height / 4: -bbox.height / 4)
},
true);
}
for (p in callout) {
callout[p].show(true);
}
},
onAnimate: function(sprite, attr) {
sprite.show();
return this.callParent(arguments);
},
isItemInPoint: function(x, y, item, i) {
var me = this,
cx = me.centerX,
cy = me.centerY,
abs = Math.abs,
dx = abs(x - cx),
dy = abs(y - cy),
startAngle = item.startAngle,
endAngle = item.endAngle,
rho = Math.sqrt(dx * dx + dy * dy),
angle = Math.atan2(y - cy, x - cx) / me.rad + 360;
if (angle > me.firstAngle) {
angle -= 360;
}
return (angle <= startAngle && angle > endAngle
&& rho >= item.startRho && rho <= item.endRho);
},
hideAll: function() {
var i, l, shadow, shadows, sh, lsh, sprite;
if (!isNaN(this._index)) {
this.__excludes = this.__excludes || [];
this.__excludes[this._index] = true;
sprite = this.slices[this._index].sprite;
for (sh = 0, lsh = sprite.length; sh < lsh; sh++) {
sprite[sh].setAttributes({
hidden: true
}, true);
}
if (this.slices[this._index].shadowAttrs) {
for (i = 0, shadows = this.slices[this._index].shadowAttrs, l = shadows.length; i < l; i++) {
shadow = shadows[i];
for (sh = 0, lsh = shadow.length; sh < lsh; sh++) {
shadow[sh].setAttributes({
hidden: true
}, true);
}
}
}
this.drawSeries();
}
},
showAll: function() {
if (!isNaN(this._index)) {
this.__excludes[this._index] = false;
this.drawSeries();
}
},
highlightItem: function(item) {
var me = this,
rad = me.rad;
item = item || this.items[this._index];
this.unHighlightItem();
if (!item || item.sprite && item.sprite._animating) {
return;
}
me.callParent([item]);
if (!me.highlight) {
return;
}
if ('segment' in me.highlightCfg) {
var highlightSegment = me.highlightCfg.segment,
animate = me.chart.animate,
attrs, i, shadows, shadow, ln, to, itemHighlightSegment, prop;
if (me.labelsGroup) {
var group = me.labelsGroup,
display = me.label.display,
label = group.getAt(item.index),
middle = (item.startAngle + item.endAngle) / 2 * rad,
r = highlightSegment.margin || 0,
x = r * Math.cos(middle),
y = r * Math.sin(middle);
if (Math.abs(x) < 1e-10) {
x = 0;
}
if (Math.abs(y) < 1e-10) {
y = 0;
}
if (animate) {
label.stopAnimation();
label.animate({
to: {
translate: {
x: x,
y: y
}
},
duration: me.highlightDuration
});
}
else {
label.setAttributes({
translate: {
x: x,
y: y
}
}, true);
}
}
if (me.chart.shadow && item.shadows) {
i = 0;
shadows = item.shadows;
ln = shadows.length;
for (; i < ln; i++) {
shadow = shadows[i];
to = {};
itemHighlightSegment = item.sprite._from.segment;
for (prop in itemHighlightSegment) {
if (! (prop in highlightSegment)) {
to[prop] = itemHighlightSegment[prop];
}
}
attrs = {
segment: Ext.applyIf(to, me.highlightCfg.segment)
};
if (animate) {
shadow.stopAnimation();
shadow.animate({
to: attrs,
duration: me.highlightDuration
});
}
else {
shadow.setAttributes(attrs, true);
}
}
}
}
},
unHighlightItem: function() {
var me = this;
if (!me.highlight) {
return;
}
if (('segment' in me.highlightCfg) && me.items) {
var items = me.items,
animate = me.chart.animate,
shadowsEnabled = !!me.chart.shadow,
group = me.labelsGroup,
len = items.length,
i = 0,
j = 0,
display = me.label.display,
shadowLen, p, to, ihs, hs, sprite, shadows, shadow, item, label, attrs;
for (; i < len; i++) {
item = items[i];
if (!item) {
continue;
}
sprite = item.sprite;
if (sprite && sprite._highlighted) {
if (group) {
label = group.getAt(item.index);
attrs = Ext.apply({
translate: {
x: 0,
y: 0
}
},
display == 'rotate' ? {
rotate: {
x: label.attr.x,
y: label.attr.y,
degrees: label.attr.rotation.degrees
}
}: {});
if (animate) {
label.stopAnimation();
label.animate({
to: attrs,
duration: me.highlightDuration
});
}
else {
label.setAttributes(attrs, true);
}
}
if (shadowsEnabled) {
shadows = item.shadows;
shadowLen = shadows.length;
for (; j < shadowLen; j++) {
to = {};
ihs = item.sprite._to.segment;
hs = item.sprite._from.segment;
Ext.apply(to, hs);
for (p in ihs) {
if (! (p in hs)) {
to[p] = ihs[p];
}
}
shadow = shadows[j];
if (animate) {
shadow.stopAnimation();
shadow.animate({
to: {
segment: to
},
duration: me.highlightDuration
});
}
else {
shadow.setAttributes({ segment: to }, true);
}
}
}
}
}
}
me.callParent(arguments);
},
getLegendColor: function(index) {
var me = this;
return (me.colorSet && me.colorSet[index % me.colorSet.length]) || me.colorArrayStyle[index % me.colorArrayStyle.length];
}
});
Ext.define('Ext.chart.series.Radar', {
extend: 'Ext.chart.series.Series',
requires: ['Ext.chart.Shape', 'Ext.fx.Anim'],
type: "radar",
alias: 'series.radar',
rad: Math.PI / 180,
showInLegend: false,
style: {},
constructor: function(config) {
this.callParent(arguments);
var me = this,
surface = me.chart.surface, i, l;
me.group = surface.getGroup(me.seriesId);
if (me.showMarkers) {
me.markerGroup = surface.getGroup(me.seriesId + '-markers');
}
},
drawSeries: function() {
var me = this,
store = me.chart.substore || me.chart.store,
group = me.group,
sprite,
chart = me.chart,
animate = chart.animate,
field = me.field || me.yField,
surface = chart.surface,
chartBBox = chart.chartBBox,
rendererAttributes,
centerX, centerY,
items,
radius,
maxValue = 0,
fields = [],
max = Math.max,
cos = Math.cos,
sin = Math.sin,
pi2 = Math.PI * 2,
l = store.getCount(),
startPath, path, x, y, rho,
i, nfields,
seriesStyle = me.seriesStyle,
seriesLabelStyle = me.seriesLabelStyle,
first = chart.resizing || !me.radar,
axis = chart.axes && chart.axes.get(0),
aggregate = !(axis && axis.maximum);
me.setBBox();
maxValue = aggregate? 0 : (axis.maximum || 0);
Ext.apply(seriesStyle, me.style || {});
if (!store || !store.getCount()) {
return;
}
me.unHighlightItem();
me.cleanHighlights();
centerX = me.centerX = chartBBox.x + (chartBBox.width / 2);
centerY = me.centerY = chartBBox.y + (chartBBox.height / 2);
me.radius = radius = Math.min(chartBBox.width, chartBBox.height) /2;
me.items = items = [];
if (aggregate) {
chart.series.each(function(series) {
fields.push(series.yField);
});
store.each(function(record, i) {
for (i = 0, nfields = fields.length; i < nfields; i++) {
maxValue = max(+record.get(fields[i]), maxValue);
}
});
}
maxValue = maxValue || 1;
startPath = []; path = [];
store.each(function(record, i) {
rho = radius * record.get(field) / maxValue;
x = rho * cos(i / l * pi2);
y = rho * sin(i / l * pi2);
if (i == 0) {
path.push('M', x + centerX, y + centerY);
startPath.push('M', 0.01 * x + centerX, 0.01 * y + centerY);
} else {
path.push('L', x + centerX, y + centerY);
startPath.push('L', 0.01 * x + centerX, 0.01 * y + centerY);
}
items.push({
sprite: false,
point: [centerX + x, centerY + y],
series: me
});
});
path.push('Z');
if (!me.radar) {
me.radar = surface.add(Ext.apply({
type: 'path',
group: group,
path: startPath
}, seriesStyle || {}));
}
if (chart.resizing) {
me.radar.setAttributes({
path: startPath
}, true);
}
if (chart.animate) {
me.onAnimate(me.radar, {
to: Ext.apply({
path: path
}, seriesStyle || {})
});
} else {
me.radar.setAttributes(Ext.apply({
path: path
}, seriesStyle || {}), true);
}
if (me.showMarkers) {
me.drawMarkers();
}
me.renderLabels();
me.renderCallouts();
},
drawMarkers: function() {
var me = this,
chart = me.chart,
surface = chart.surface,
markerStyle = Ext.apply({}, me.markerStyle || {}),
endMarkerStyle = Ext.apply(markerStyle, me.markerConfig),
items = me.items,
type = endMarkerStyle.type,
markerGroup = me.markerGroup,
centerX = me.centerX,
centerY = me.centerY,
item, i, l, marker;
delete endMarkerStyle.type;
for (i = 0, l = items.length; i < l; i++) {
item = items[i];
marker = markerGroup.getAt(i);
if (!marker) {
marker = Ext.chart.Shape[type](surface, Ext.apply({
group: markerGroup,
x: 0,
y: 0,
translate: {
x: centerX,
y: centerY
}
}, endMarkerStyle));
}
else {
marker.show();
}
if (chart.resizing) {
marker.setAttributes({
x: 0,
y: 0,
translate: {
x: centerX,
y: centerY
}
}, true);
}
marker._to = {
translate: {
x: item.point[0],
y: item.point[1]
}
};
if (chart.animate) {
me.onAnimate(marker, {
to: marker._to
});
}
else {
marker.setAttributes(Ext.apply(marker._to, endMarkerStyle || {}), true);
}
}
},
isItemInPoint: function(x, y, item) {
var point,
tolerance = 10,
abs = Math.abs;
point = item.point;
return (abs(point[0] - x) <= tolerance &&
abs(point[1] - y) <= tolerance);
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
group = me.labelsGroup,
config = me.label,
centerX = me.centerX,
centerY = me.centerY,
point = item.point,
endLabelStyle = Ext.apply(me.seriesLabelStyle || {}, config);
return me.chart.surface.add(Ext.apply({
'type': 'text',
'text-anchor': 'middle',
'group': group,
'x': centerX,
'y': centerY
}, config || {}));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.label,
format = config.renderer,
field = config.field,
centerX = me.centerX,
centerY = me.centerY,
opt = {
x: item.point[0],
y: item.point[1]
},
x = opt.x - centerX,
y = opt.y - centerY;
label.setAttributes({
text: format(storeItem.get(field)),
hidden: true
},
true);
if (resizing) {
label.setAttributes({
x: centerX,
y: centerY
}, true);
}
if (animate) {
label.show(true);
me.onAnimate(label, {
to: opt
});
} else {
label.setAttributes(opt, true);
label.show(true);
}
},
toggleAll: function(show) {
var me = this,
i, ln, shadow, shadows;
if (!show) {
Ext.chart.series.Radar.superclass.hideAll.call(me);
}
else {
Ext.chart.series.Radar.superclass.showAll.call(me);
}
if (me.radar) {
me.radar.setAttributes({
hidden: !show
}, true);
if (me.radar.shadows) {
for (i = 0, shadows = me.radar.shadows, ln = shadows.length; i < ln; i++) {
shadow = shadows[i];
shadow.setAttributes({
hidden: !show
}, true);
}
}
}
},
hideAll: function() {
this.toggleAll(false);
this.hideMarkers(0);
},
showAll: function() {
this.toggleAll(true);
},
hideMarkers: function(index) {
var me = this,
count = me.markerGroup && me.markerGroup.getCount() || 0,
i = index || 0;
for (; i < count; i++) {
me.markerGroup.getAt(i).hide(true);
}
}
});
Ext.define('Ext.chart.series.Scatter', {
extend: 'Ext.chart.series.Cartesian',
requires: ['Ext.chart.axis.Axis', 'Ext.chart.Shape', 'Ext.fx.Anim'],
type: 'scatter',
alias: 'series.scatter',
constructor: function(config) {
this.callParent(arguments);
var me = this,
shadow = me.chart.shadow,
surface = me.chart.surface, i, l;
Ext.apply(me, config, {
style: {},
markerConfig: {},
shadowAttributes: [{
"stroke-width": 6,
"stroke-opacity": 0.05,
stroke: 'rgb(0, 0, 0)'
}, {
"stroke-width": 4,
"stroke-opacity": 0.1,
stroke: 'rgb(0, 0, 0)'
}, {
"stroke-width": 2,
"stroke-opacity": 0.15,
stroke: 'rgb(0, 0, 0)'
}]
});
me.group = surface.getGroup(me.seriesId);
if (shadow) {
for (i = 0, l = me.shadowAttributes.length; i < l; i++) {
me.shadowGroups.push(surface.getGroup(me.seriesId + '-shadows' + i));
}
}
},
getBounds: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
axes = [].concat(me.axis),
bbox, xScale, yScale, ln, minX, minY, maxX, maxY, i, axis, ends;
me.setBBox();
bbox = me.bbox;
for (i = 0, ln = axes.length; i < ln; i++) {
axis = chart.axes.get(axes[i]);
if (axis) {
ends = axis.calcEnds();
if (axis.position == 'top' || axis.position == 'bottom') {
minX = ends.from;
maxX = ends.to;
}
else {
minY = ends.from;
maxY = ends.to;
}
}
}
if (me.xField && !Ext.isNumber(minX)) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.xField)
}).calcEnds();
minX = axis.from;
maxX = axis.to;
}
if (me.yField && !Ext.isNumber(minY)) {
axis = Ext.create('Ext.chart.axis.Axis', {
chart: chart,
fields: [].concat(me.yField)
}).calcEnds();
minY = axis.from;
maxY = axis.to;
}
if (isNaN(minX)) {
minX = 0;
maxX = store.getCount() - 1;
xScale = bbox.width / (store.getCount() - 1);
}
else {
xScale = bbox.width / (maxX - minX);
}
if (isNaN(minY)) {
minY = 0;
maxY = store.getCount() - 1;
yScale = bbox.height / (store.getCount() - 1);
}
else {
yScale = bbox.height / (maxY - minY);
}
return {
bbox: bbox,
minX: minX,
minY: minY,
xScale: xScale,
yScale: yScale
};
},
getPaths: function() {
var me = this,
chart = me.chart,
enableShadows = chart.shadow,
store = chart.substore || chart.store,
group = me.group,
bounds = me.bounds = me.getBounds(),
bbox = me.bbox,
xScale = bounds.xScale,
yScale = bounds.yScale,
minX = bounds.minX,
minY = bounds.minY,
boxX = bbox.x,
boxY = bbox.y,
boxHeight = bbox.height,
items = me.items = [],
attrs = [],
x, y, xValue, yValue, sprite;
store.each(function(record, i) {
xValue = record.get(me.xField);
yValue = record.get(me.yField);
if (typeof yValue == 'undefined' || (typeof yValue == 'string' && !yValue)) {
return;
}
if (typeof xValue == 'string' || typeof xValue == 'object') {
xValue = i;
}
if (typeof yValue == 'string' || typeof yValue == 'object') {
yValue = i;
}
x = boxX + (xValue - minX) * xScale;
y = boxY + boxHeight - (yValue - minY) * yScale;
attrs.push({
x: x,
y: y
});
me.items.push({
series: me,
value: [xValue, yValue],
point: [x, y],
storeItem: record
});
if (chart.animate && chart.resizing) {
sprite = group.getAt(i);
if (sprite) {
me.resetPoint(sprite);
if (enableShadows) {
me.resetShadow(sprite);
}
}
}
});
return attrs;
},
resetPoint: function(sprite) {
var bbox = this.bbox;
sprite.setAttributes({
translate: {
x: (bbox.x + bbox.width) / 2,
y: (bbox.y + bbox.height) / 2
}
}, true);
},
resetShadow: function(sprite) {
var me = this,
shadows = sprite.shadows,
shadowAttributes = me.shadowAttributes,
ln = me.shadowGroups.length,
bbox = me.bbox,
i, attr;
for (i = 0; i < ln; i++) {
attr = Ext.apply({}, shadowAttributes[i]);
if (attr.translate) {
attr.translate.x += (bbox.x + bbox.width) / 2;
attr.translate.y += (bbox.y + bbox.height) / 2;
}
else {
attr.translate = {
x: (bbox.x + bbox.width) / 2,
y: (bbox.y + bbox.height) / 2
};
}
shadows[i].setAttributes(attr, true);
}
},
createPoint: function(attr, type) {
var me = this,
chart = me.chart,
group = me.group,
bbox = me.bbox;
return Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
x: 0,
y: 0,
group: group,
translate: {
x: (bbox.x + bbox.width) / 2,
y: (bbox.y + bbox.height) / 2
}
}, attr));
},
createShadow: function(sprite, endMarkerStyle, type) {
var me = this,
chart = me.chart,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
lnsh = shadowGroups.length,
bbox = me.bbox,
i, shadow, shadows, attr;
sprite.shadows = shadows = [];
for (i = 0; i < lnsh; i++) {
attr = Ext.apply({}, shadowAttributes[i]);
if (attr.translate) {
attr.translate.x += (bbox.x + bbox.width) / 2;
attr.translate.y += (bbox.y + bbox.height) / 2;
}
else {
Ext.apply(attr, {
translate: {
x: (bbox.x + bbox.width) / 2,
y: (bbox.y + bbox.height) / 2
}
});
}
Ext.apply(attr, endMarkerStyle);
shadow = Ext.chart.Shape[type](chart.surface, Ext.apply({}, {
x: 0,
y: 0,
group: shadowGroups[i]
}, attr));
shadows.push(shadow);
}
},
drawSeries: function() {
var me = this,
chart = me.chart,
store = chart.substore || chart.store,
group = me.group,
enableShadows = chart.shadow,
shadowGroups = me.shadowGroups,
shadowAttributes = me.shadowAttributes,
lnsh = shadowGroups.length,
sprite, attrs, attr, ln, i, endMarkerStyle, shindex, type, shadows,
rendererAttributes, shadowAttribute;
endMarkerStyle = Ext.apply(me.markerStyle, me.markerConfig);
type = endMarkerStyle.type;
delete endMarkerStyle.type;
if (!store || !store.getCount()) {
return;
}
me.unHighlightItem();
me.cleanHighlights();
attrs = me.getPaths();
ln = attrs.length;
for (i = 0; i < ln; i++) {
attr = attrs[i];
sprite = group.getAt(i);
Ext.apply(attr, endMarkerStyle);
if (!sprite) {
sprite = me.createPoint(attr, type);
if (enableShadows) {
me.createShadow(sprite, endMarkerStyle, type);
}
}
shadows = sprite.shadows;
if (chart.animate) {
rendererAttributes = me.renderer(sprite, store.getAt(i), { translate: attr }, i, store);
sprite._to = rendererAttributes;
me.onAnimate(sprite, {
to: rendererAttributes
});
for (shindex = 0; shindex < lnsh; shindex++) {
shadowAttribute = Ext.apply({}, shadowAttributes[shindex]);
rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({}, {
translate: {
x: attr.x + (shadowAttribute.translate? shadowAttribute.translate.x : 0),
y: attr.y + (shadowAttribute.translate? shadowAttribute.translate.y : 0)
}
}, shadowAttribute), i, store);
me.onAnimate(shadows[shindex], { to: rendererAttributes });
}
}
else {
rendererAttributes = me.renderer(sprite, store.getAt(i), Ext.apply({ translate: attr }, { hidden: false }), i, store);
sprite.setAttributes(rendererAttributes, true);
for (shindex = 0; shindex < lnsh; shindex++) {
shadowAttribute = shadowAttributes[shindex];
rendererAttributes = me.renderer(shadows[shindex], store.getAt(i), Ext.apply({
x: attr.x,
y: attr.y
}, shadowAttribute), i, store);
shadows[shindex].setAttributes(rendererAttributes, true);
}
}
me.items[i].sprite = sprite;
}
ln = group.getCount();
for (i = attrs.length; i < ln; i++) {
group.getAt(i).hide(true);
}
me.renderLabels();
me.renderCallouts();
},
onCreateLabel: function(storeItem, item, i, display) {
var me = this,
group = me.labelsGroup,
config = me.label,
endLabelStyle = Ext.apply({}, config, me.seriesLabelStyle),
bbox = me.bbox;
return me.chart.surface.add(Ext.apply({
type: 'text',
group: group,
x: item.point[0],
y: bbox.y + bbox.height / 2
}, endLabelStyle));
},
onPlaceLabel: function(label, storeItem, item, i, display, animate) {
var me = this,
chart = me.chart,
resizing = chart.resizing,
config = me.label,
format = config.renderer,
field = config.field,
bbox = me.bbox,
x = item.point[0],
y = item.point[1],
radius = item.sprite.attr.radius,
bb, width, height, anim;
label.setAttributes({
text: format(storeItem.get(field)),
hidden: true
}, true);
if (display == 'rotate') {
label.setAttributes({
'text-anchor': 'start',
'rotation': {
x: x,
y: y,
degrees: -45
}
}, true);
bb = label.getBBox();
width = bb.width;
height = bb.height;
x = x < bbox.x? bbox.x : x;
x = (x + width > bbox.x + bbox.width)? (x - (x + width - bbox.x - bbox.width)) : x;
y = (y - height < bbox.y)? bbox.y + height : y;
} else if (display == 'under' || display == 'over') {
bb = item.sprite.getBBox();
bb.width = bb.width || (radius * 2);
bb.height = bb.height || (radius * 2);
y = y + (display == 'over'? -bb.height : bb.height);
bb = label.getBBox();
width = bb.width/2;
height = bb.height/2;
x = x - width < bbox.x ? bbox.x + width : x;
x = (x + width > bbox.x + bbox.width) ? (x - (x + width - bbox.x - bbox.width)) : x;
y = y - height < bbox.y? bbox.y + height : y;
y = (y + height > bbox.y + bbox.height) ? (y - (y + height - bbox.y - bbox.height)) : y;
}
if (!chart.animate) {
label.setAttributes({
x: x,
y: y
}, true);
label.show(true);
}
else {
if (resizing) {
anim = item.sprite.getActiveAnimation();
if (anim) {
anim.on('afteranimate', function() {
label.setAttributes({
x: x,
y: y
}, true);
label.show(true);
});
}
else {
label.show(true);
}
}
else {
me.onAnimate(label, {
to: {
x: x,
y: y
}
});
}
}
},
onPlaceCallout: function(callout, storeItem, item, i, display, animate, index) {
var me = this,
chart = me.chart,
surface = chart.surface,
resizing = chart.resizing,
config = me.callouts,
items = me.items,
cur = item.point,
normal,
bbox = callout.label.getBBox(),
offsetFromViz = 30,
offsetToSide = 10,
offsetBox = 3,
boxx, boxy, boxw, boxh,
p, clipRect = me.bbox,
x, y;
normal = [Math.cos(Math.PI /4), -Math.sin(Math.PI /4)];
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
if (boxx < clipRect[0] || (boxx + boxw) > (clipRect[0] + clipRect[2])) {
normal[0] *= -1;
}
if (boxy < clipRect[1] || (boxy + boxh) > (clipRect[1] + clipRect[3])) {
normal[1] *= -1;
}
x = cur[0] + normal[0] * offsetFromViz;
y = cur[1] + normal[1] * offsetFromViz;
boxx = x + (normal[0] > 0? 0 : -(bbox.width + 2 * offsetBox));
boxy = y - bbox.height /2 - offsetBox;
boxw = bbox.width + 2 * offsetBox;
boxh = bbox.height + 2 * offsetBox;
if (chart.animate) {
me.onAnimate(callout.lines, {
to: {
path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}
}, true);
me.onAnimate(callout.box, {
to: {
x: boxx,
y: boxy,
width: boxw,
height: boxh
}
}, true);
me.onAnimate(callout.label, {
to: {
x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
y: y
}
}, true);
} else {
callout.lines.setAttributes({
path: ["M", cur[0], cur[1], "L", x, y, "Z"]
}, true);
callout.box.setAttributes({
x: boxx,
y: boxy,
width: boxw,
height: boxh
}, true);
callout.label.setAttributes({
x: x + (normal[0] > 0? offsetBox : -(bbox.width + offsetBox)),
y: y
}, true);
}
for (p in callout) {
callout[p].show(true);
}
},
onAnimate: function(sprite, attr) {
sprite.show();
return this.callParent(arguments);
},
isItemInPoint: function(x, y, item) {
var point,
tolerance = 10,
abs = Math.abs;
function dist(point) {
var dx = abs(point[0] - x),
dy = abs(point[1] - y);
return Math.sqrt(dx * dx + dy * dy);
}
point = item.point;
return (point[0] - tolerance <= x && point[0] + tolerance >= x &&
point[1] - tolerance <= y && point[1] + tolerance >= y);
}
});
Ext.define('Ext.chart.theme.Base', {
requires: ['Ext.chart.theme.Theme'],
constructor: function(config) {
Ext.chart.theme.call(this, config, {
background: false,
axis: {
stroke: '#444',
'stroke-width': 1
},
axisLabelTop: {
fill: '#444',
font: '12px Arial, Helvetica, sans-serif',
spacing: 2,
padding: 5,
renderer: function(v) { return v; }
},
axisLabelRight: {
fill: '#444',
font: '12px Arial, Helvetica, sans-serif',
spacing: 2,
padding: 5,
renderer: function(v) { return v; }
},
axisLabelBottom: {
fill: '#444',
font: '12px Arial, Helvetica, sans-serif',
spacing: 2,
padding: 5,
renderer: function(v) { return v; }
},
axisLabelLeft: {
fill: '#444',
font: '12px Arial, Helvetica, sans-serif',
spacing: 2,
padding: 5,
renderer: function(v) { return v; }
},
axisTitleTop: {
font: 'bold 18px Arial',
fill: '#444'
},
axisTitleRight: {
font: 'bold 18px Arial',
fill: '#444',
rotate: {
x:0, y:0,
degrees: 270
}
},
axisTitleBottom: {
font: 'bold 18px Arial',
fill: '#444'
},
axisTitleLeft: {
font: 'bold 18px Arial',
fill: '#444',
rotate: {
x:0, y:0,
degrees: 270
}
},
series: {
'stroke-width': 0
},
seriesLabel: {
font: '12px Arial',
fill: '#333'
},
marker: {
stroke: '#555',
fill: '#000',
radius: 3,
size: 3
},
colors: [ "#94ae0a", "#115fa6","#a61120", "#ff8809", "#ffd13e", "#a61187", "#24ad9a", "#7c7474", "#a66111"],
seriesThemes: [{
fill: "#115fa6"
}, {
fill: "#94ae0a"
}, {
fill: "#a61120"
}, {
fill: "#ff8809"
}, {
fill: "#ffd13e"
}, {
fill: "#a61187"
}, {
fill: "#24ad9a"
}, {
fill: "#7c7474"
}, {
fill: "#a66111"
}],
markerThemes: [{
fill: "#115fa6",
type: 'circle'
}, {
fill: "#94ae0a",
type: 'cross'
}, {
fill: "#a61120",
type: 'plus'
}]
});
}
}, function() {
var palette = ['#b1da5a', '#4ce0e7', '#e84b67', '#da5abd', '#4d7fe6', '#fec935'],
names = ['Green', 'Sky', 'Red', 'Purple', 'Blue', 'Yellow'],
i = 0, j = 0, l = palette.length, themes = Ext.chart.theme,
categories = [['#f0a50a', '#c20024', '#2044ba', '#810065', '#7eae29'],
['#6d9824', '#87146e', '#2a9196', '#d39006', '#1e40ac'],
['#fbbc29', '#ce2e4e', '#7e0062', '#158b90', '#57880e'],
['#ef5773', '#fcbd2a', '#4f770d', '#1d3eaa', '#9b001f'],
['#7eae29', '#fdbe2a', '#910019', '#27b4bc', '#d74dbc'],
['#44dce1', '#0b2592', '#996e05', '#7fb325', '#b821a1']],
cats = categories.length;
for (; i < l; i++) {
themes[names[i]] = (function(color) {
return Ext.extend(themes.Base, {
constructor: function(config) {
themes.Base.prototype.constructor.call(this, Ext.apply({
baseColor: color
}, config));
}
});
})(palette[i]);
}
for (i = 0; i < cats; i++) {
themes['Category' + (i + 1)] = (function(category) {
return Ext.extend(themes.Base, {
constructor: function(config) {
themes.Base.prototype.constructor.call(this, Ext.apply({
colors: category
}, config));
}
});
})(categories[i]);
}
});
Ext.define('Ext.data.ArrayStore', {
extend: 'Ext.data.Store',
alias: 'store.array',
uses: ['Ext.data.reader.Array'],
constructor: function(config) {
config = config || {};
Ext.applyIf(config, {
proxy: {
type: 'memory',
reader: 'array'
}
});
this.callParent([config]);
},
loadData: function(data, append) {
if (this.expandData === true) {
var r = [],
i = 0,
ln = data.length;
for (; i < ln; i++) {
r[r.length] = [data[i]];
}
data = r;
}
this.callParent([data, append]);
}
}, function() {
Ext.data.SimpleStore = Ext.data.ArrayStore;
});
Ext.define('Ext.data.Batch', {
mixins: {
observable: 'Ext.util.Observable'
},
autoStart: false,
current: -1,
total: 0,
isRunning: false,
isComplete: false,
hasException: false,
pauseOnException: true,
constructor: function(config) {
var me = this;
me.addEvents(
'complete',
'exception',
'operationcomplete'
);
me.mixins.observable.constructor.call(me, config);
me.operations = [];
},
add: function(operation) {
this.total++;
operation.setBatch(this);
this.operations.push(operation);
},
start: function() {
this.hasException = false;
this.isRunning = true;
this.runNextOperation();
},
runNextOperation: function() {
this.runOperation(this.current + 1);
},
pause: function() {
this.isRunning = false;
},
runOperation: function(index) {
var me = this,
operations = me.operations,
operation = operations[index],
onProxyReturn;
if (operation === undefined) {
me.isRunning = false;
me.isComplete = true;
me.fireEvent('complete', me, operations[operations.length - 1]);
} else {
me.current = index;
onProxyReturn = function(operation) {
var hasException = operation.hasException();
if (hasException) {
me.hasException = true;
me.fireEvent('exception', me, operation);
} else {
me.fireEvent('operationcomplete', me, operation);
}
if (hasException && me.pauseOnException) {
me.pause();
} else {
operation.setCompleted();
me.runNextOperation();
}
};
operation.setStarted();
me.proxy[operation.action](operation, onProxyReturn, me);
}
}
});
Ext.define('Ext.data.BelongsToAssociation', {
extend: 'Ext.data.Association',
alias: 'association.belongsto',
constructor: function(config) {
this.callParent(arguments);
var me = this,
ownerProto = me.ownerModel.prototype,
associatedName = me.associatedName,
getterName = me.getterName || 'get' + associatedName,
setterName = me.setterName || 'set' + associatedName;
Ext.applyIf(me, {
name : associatedName,
foreignKey : associatedName.toLowerCase() + "_id",
instanceName: associatedName + 'BelongsToInstance',
associationKey: associatedName.toLowerCase()
});
ownerProto[getterName] = me.createGetter();
ownerProto[setterName] = me.createSetter();
},
createSetter: function() {
var me = this,
ownerModel = me.ownerModel,
associatedModel = me.associatedModel,
foreignKey = me.foreignKey,
primaryKey = me.primaryKey;
return function(value, options, scope) {
this.set(foreignKey, value);
if (typeof options == 'function') {
options = {
callback: options,
scope: scope || this
};
}
if (Ext.isObject(options)) {
return this.save(options);
}
};
},
createGetter: function() {
var me = this,
ownerModel = me.ownerModel,
associatedName = me.associatedName,
associatedModel = me.associatedModel,
foreignKey = me.foreignKey,
primaryKey = me.primaryKey,
instanceName = me.instanceName;
return function(options, scope) {
options = options || {};
var model = this,
foreignKeyId = model.get(foreignKey),
instance,
args;
if (model[instanceName] === undefined) {
instance = Ext.ModelManager.create({}, associatedName);
instance.set(primaryKey, foreignKeyId);
if (typeof options == 'function') {
options = {
callback: options,
scope: scope || model
};
}
associatedModel.load(foreignKeyId, options);
model[instanceName] = associatedModel;
return associatedModel;
} else {
instance = model[instanceName];
args = [instance];
scope = scope || model;
Ext.callback(options, scope, args);
Ext.callback(options.success, scope, args);
Ext.callback(options.failure, scope, args);
Ext.callback(options.callback, scope, args);
return instance;
}
};
},
read: function(record, reader, associationData){
record[this.instanceName] = reader.read([associationData]).records[0];
}
});
Ext.define('Ext.data.BufferStore', {
extend: 'Ext.data.Store',
alias: 'store.buffer',
sortOnLoad: false,
filterOnLoad: false,
constructor: function() {
Ext.Error.raise('The BufferStore class has been deprecated. Instead, specify the buffered config option on Ext.data.Store');
}
});
Ext.define('Ext.direct.Manager', {
singleton: true,
mixins: {
observable: 'Ext.util.Observable'
},
requires: ['Ext.util.MixedCollection'],
statics: {
exceptions: {
TRANSPORT: 'xhr',
PARSE: 'parse',
LOGIN: 'login',
SERVER: 'exception'
}
},
constructor: function(){
var me = this;
me.addEvents(
'event',
'exception'
);
me.transactions = Ext.create('Ext.util.MixedCollection');
me.providers = Ext.create('Ext.util.MixedCollection');
me.mixins.observable.constructor.call(me);
},
addProvider : function(provider){
var me = this,
args = arguments,
i = 0,
len;
if (args.length > 1) {
for (len = args.length; i < len; ++i) {
me.addProvider(args[i]);
}
return;
}
if (!provider.isProvider) {
provider = Ext.create('direct.' + provider.type + 'provider', provider);
}
me.providers.add(provider);
provider.on('data', me.onProviderData, me);
if (!provider.isConnected()) {
provider.connect();
}
return provider;
},
getProvider : function(id){
return id.isProvider ? id : this.providers.get(id);
},
removeProvider : function(provider){
var me = this,
providers = me.providers,
provider = provider.isProvider ? provider : providers.get(provider);
if (provider) {
provider.un('data', me.onProviderData, me);
providers.remove(provider);
return provider;
}
return null;
},
addTransaction: function(transaction){
this.transactions.add(transaction);
return transaction;
},
removeTransaction: function(transaction){
transaction = this.getTransaction(transaction);
this.transactions.remove(transaction);
return transaction;
},
getTransaction: function(transaction){
return transaction.isTransaction ? transaction : this.transactions.get(transaction);
},
onProviderData : function(provider, event){
var me = this,
i = 0,
len;
if (Ext.isArray(event)) {
for (len = event.length; i < len; ++i) {
me.onProviderData(provider, event[i]);
}
return;
}
if (event.name && event.name != 'event' && event.name != 'exception') {
me.fireEvent(event.name, event);
} else if (event.type == 'exception') {
me.fireEvent('exception', event);
}
me.fireEvent('event', event, provider);
}
}, function(){
Ext.Direct = Ext.direct.Manager;
});
Ext.define('Ext.data.proxy.Direct', {
extend: 'Ext.data.proxy.Server',
alternateClassName: 'Ext.data.DirectProxy',
alias: 'proxy.direct',
requires: ['Ext.direct.Manager'],
paramOrder: undefined,
paramsAsHash: true,
directFn : undefined,
paramOrderRe: /[\s,|]/,
constructor: function(config){
var me = this;
Ext.apply(me, config);
if (Ext.isString(me.paramOrder)) {
me.paramOrder = me.paramOrder.split(me.paramOrderRe);
}
me.callParent(arguments);
},
doRequest: function(operation, callback, scope) {
var me = this,
writer = me.getWriter(),
request = me.buildRequest(operation, callback, scope),
fn = me.api[request.action] || me.directFn,
args = [],
params = request.params,
paramOrder = me.paramOrder,
method,
i = 0,
len;
if (operation.allowWrite()) {
request = writer.write(request);
}
if (operation.action == 'read') {
method = fn.directCfg.method;
if (method.ordered) {
if (method.len > 0) {
if (paramOrder) {
for (len = paramOrder.length; i < len; ++i) {
args.push(params[paramOrder[i]]);
}
} else if (me.paramsAsHash) {
args.push(params);
}
}
} else {
args.push(params);
}
} else {
args.push(request.jsonData);
}
Ext.apply(request, {
args: args,
directFn: fn
});
args.push(me.createRequestCallback(request, operation, callback, scope), me);
fn.apply(window, args);
},
applyEncoding: function(value){
return value;
},
createRequestCallback: function(request, operation, callback, scope){
var me = this;
return function(data, event){
me.processResponse(event.status, operation, request, event, callback, scope);
};
},
extractResponseData: function(response){
return Ext.isDefined(response.result) ? response.result : response.data;
},
setException: function(operation, response) {
operation.setException(response.message);
},
buildUrl: function(){
return '';
}
});
Ext.define('Ext.data.DirectStore', {
extend: 'Ext.data.Store',
alias: 'store.direct',
requires: ['Ext.data.proxy.Direct'],
constructor : function(config){
config = Ext.apply({}, config);
if (!config.proxy) {
var proxy = {
type: 'direct',
reader: {
type: 'json'
}
};
Ext.copyTo(proxy, config, 'paramOrder,paramsAsHash,directFn,api,simpleSortMode');
Ext.copyTo(proxy.reader, config, 'totalProperty,root,idProperty');
config.proxy = proxy;
}
this.callParent([config]);
}
});
Ext.define('Ext.util.Inflector', {
singleton: true,
plurals: [
[(/(quiz)$/i), "$1zes" ],
[(/^(ox)$/i), "$1en" ],
[(/([m|l])ouse$/i), "$1ice" ],
[(/(matr|vert|ind)ix|ex$/i), "$1ices" ],
[(/(x|ch|ss|sh)$/i), "$1es" ],
[(/([^aeiouy]|qu)y$/i), "$1ies" ],
[(/(hive)$/i), "$1s" ],
[(/(?:([^f])fe|([lr])f)$/i), "$1$2ves"],
[(/sis$/i), "ses" ],
[(/([ti])um$/i), "$1a" ],
[(/(buffal|tomat|potat)o$/i), "$1oes" ],
[(/(bu)s$/i), "$1ses" ],
[(/(alias|status|sex)$/i), "$1es" ],
[(/(octop|vir)us$/i), "$1i" ],
[(/(ax|test)is$/i), "$1es" ],
[(/^person$/), "people" ],
[(/^man$/), "men" ],
[(/^(child)$/), "$1ren" ],
[(/s$/i), "s" ],
[(/$/), "s" ]
],
singulars: [
[(/(quiz)zes$/i), "$1" ],
[(/(matr)ices$/i), "$1ix" ],
[(/(vert|ind)ices$/i), "$1ex" ],
[(/^(ox)en/i), "$1" ],
[(/(alias|status)es$/i), "$1" ],
[(/(octop|vir)i$/i), "$1us" ],
[(/(cris|ax|test)es$/i), "$1is" ],
[(/(shoe)s$/i), "$1" ],
[(/(o)es$/i), "$1" ],
[(/(bus)es$/i), "$1" ],
[(/([m|l])ice$/i), "$1ouse" ],
[(/(x|ch|ss|sh)es$/i), "$1" ],
[(/(m)ovies$/i), "$1ovie" ],
[(/(s)eries$/i), "$1eries"],
[(/([^aeiouy]|qu)ies$/i), "$1y" ],
[(/([lr])ves$/i), "$1f" ],
[(/(tive)s$/i), "$1" ],
[(/(hive)s$/i), "$1" ],
[(/([^f])ves$/i), "$1fe" ],
[(/(^analy)ses$/i), "$1sis" ],
[(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i), "$1$2sis"],
[(/([ti])a$/i), "$1um" ],
[(/(n)ews$/i), "$1ews" ],
[(/people$/i), "person" ],
[(/s$/i), "" ]
],
uncountable: [
"sheep",
"fish",
"series",
"species",
"money",
"rice",
"information",
"equipment",
"grass",
"mud",
"offspring",
"deer",
"means"
],
singular: function(matcher, replacer) {
this.singulars.unshift([matcher, replacer]);
},
plural: function(matcher, replacer) {
this.plurals.unshift([matcher, replacer]);
},
clearSingulars: function() {
this.singulars = [];
},
clearPlurals: function() {
this.plurals = [];
},
isTransnumeral: function(word) {
return Ext.Array.indexOf(this.uncountable, word) != -1;
},
pluralize: function(word) {
if (this.isTransnumeral(word)) {
return word;
}
var plurals = this.plurals,
length = plurals.length,
tuple, regex, i;
for (i = 0; i < length; i++) {
tuple = plurals[i];
regex = tuple[0];
if (regex == word || (regex.test && regex.test(word))) {
return word.replace(regex, tuple[1]);
}
}
return word;
},
singularize: function(word) {
if (this.isTransnumeral(word)) {
return word;
}
var singulars = this.singulars,
length = singulars.length,
tuple, regex, i;
for (i = 0; i < length; i++) {
tuple = singulars[i];
regex = tuple[0];
if (regex == word || (regex.test && regex.test(word))) {
return word.replace(regex, tuple[1]);
}
}
return word;
},
classify: function(word) {
return Ext.String.capitalize(this.singularize(word));
},
ordinalize: function(number) {
var parsed = parseInt(number, 10),
mod10 = parsed % 10,
mod100 = parsed % 100;
if (11 <= mod100 && mod100 <= 13) {
return number + "th";
} else {
switch(mod10) {
case 1 : return number + "st";
case 2 : return number + "nd";
case 3 : return number + "rd";
default: return number + "th";
}
}
}
}, function() {
var irregulars = {
alumnus: 'alumni',
cactus : 'cacti',
focus : 'foci',
nucleus: 'nuclei',
radius: 'radii',
stimulus: 'stimuli',
ellipsis: 'ellipses',
paralysis: 'paralyses',
oasis: 'oases',
appendix: 'appendices',
index: 'indexes',
beau: 'beaux',
bureau: 'bureaux',
tableau: 'tableaux',
woman: 'women',
child: 'children',
man: 'men',
corpus: 'corpora',
criterion: 'criteria',
curriculum: 'curricula',
genus: 'genera',
memorandum: 'memoranda',
phenomenon: 'phenomena',
foot: 'feet',
goose: 'geese',
tooth: 'teeth',
antenna: 'antennae',
formula: 'formulae',
nebula: 'nebulae',
vertebra: 'vertebrae',
vita: 'vitae'
},
singular;
for (singular in irregulars) {
this.plural(singular, irregulars[singular]);
this.singular(irregulars[singular], singular);
}
});
Ext.define('Ext.data.HasManyAssociation', {
extend: 'Ext.data.Association',
requires: ['Ext.util.Inflector'],
alias: 'association.hasmany',
constructor: function(config) {
var me = this,
ownerProto,
name;
me.callParent(arguments);
me.name = me.name || Ext.util.Inflector.pluralize(me.associatedName.toLowerCase());
ownerProto = me.ownerModel.prototype;
name = me.name;
Ext.applyIf(me, {
storeName : name + "Store",
foreignKey: me.ownerName.toLowerCase() + "_id"
});
ownerProto[name] = me.createStore();
},
createStore: function() {
var that = this,
associatedModel = that.associatedModel,
storeName = that.storeName,
foreignKey = that.foreignKey,
primaryKey = that.primaryKey,
filterProperty = that.filterProperty,
autoLoad = that.autoLoad,
storeConfig = that.storeConfig || {};
return function() {
var me = this,
config, filter,
modelDefaults = {};
if (me[storeName] === undefined) {
if (filterProperty) {
filter = {
property : filterProperty,
value : me.get(filterProperty),
exactMatch: true
};
} else {
filter = {
property : foreignKey,
value : me.get(primaryKey),
exactMatch: true
};
}
modelDefaults[foreignKey] = me.get(primaryKey);
config = Ext.apply({}, storeConfig, {
model : associatedModel,
filters : [filter],
remoteFilter : false,
modelDefaults: modelDefaults
});
me[storeName] = Ext.create('Ext.data.Store', config);
if (autoLoad) {
me[storeName].load();
}
}
return me[storeName];
};
},
read: function(record, reader, associationData){
var store = record[this.name](),
inverse;
store.add(reader.read(associationData).records);
inverse = this.associatedModel.prototype.associations.findBy(function(assoc){
return assoc.type === 'belongsTo' && assoc.associatedName === record.$className;
});
if (inverse) {
store.data.each(function(associatedRecord){
associatedRecord[inverse.instanceName] = record;
});
}
}
});
Ext.define('Ext.data.JsonP', {
singleton: true,
statics: {
requestCount: 0,
requests: {}
},
timeout: 30000,
disableCaching: true,
disableCachingParam: '_dc',
callbackKey: 'callback',
request: function(options){
options = Ext.apply({}, options);
var me = this,
disableCaching = Ext.isDefined(options.disableCaching) ? options.disableCaching : me.disableCaching,
cacheParam = options.disableCachingParam || me.disableCachingParam,
id = ++me.statics().requestCount,
callbackName = options.callbackName || 'callback' + id,
callbackKey = options.callbackKey || me.callbackKey,
timeout = Ext.isDefined(options.timeout) ? options.timeout : me.timeout,
params = Ext.apply({}, options.params),
url = options.url,
request,
script;
params[callbackKey] = 'Ext.data.JsonP.' + callbackName;
if (disableCaching) {
params[cacheParam] = new Date().getTime();
}
script = me.createScript(url, params);
me.statics().requests[id] = request = {
url: url,
params: params,
script: script,
id: id,
scope: options.scope,
success: options.success,
failure: options.failure,
callback: options.callback,
callbackName: callbackName
};
if (timeout > 0) {
request.timeout = setTimeout(Ext.bind(me.handleTimeout, me, [request]), timeout);
}
me.setupErrorHandling(request);
me[callbackName] = Ext.bind(me.handleResponse, me, [request], true);
Ext.getHead().appendChild(script);
return request;
},
abort: function(request){
var requests = this.statics().requests,
key;
if (request) {
if (!request.id) {
request = requests[request];
}
this.abort(request);
} else {
for (key in requests) {
if (requests.hasOwnProperty(key)) {
this.abort(requests[key]);
}
}
}
},
setupErrorHandling: function(request){
request.script.onerror = Ext.bind(this.handleError, this, [request]);
},
handleAbort: function(request){
request.errorType = 'abort';
this.handleResponse(null, request);
},
handleError: function(request){
request.errorType = 'error';
this.handleResponse(null, request);
},
cleanupErrorHandling: function(request){
request.script.onerror = null;
},
handleTimeout: function(request){
request.errorType = 'timeout';
this.handleResponse(null, request);
},
handleResponse: function(result, request){
var success = true;
if (request.timeout) {
clearTimeout(request.timeout);
}
delete this[request.callbackName];
delete this.statics()[request.id];
this.cleanupErrorHandling(request);
Ext.fly(request.script).remove();
if (request.errorType) {
success = false;
Ext.callback(request.failure, request.scope, [request.errorType]);
} else {
Ext.callback(request.success, request.scope, [result]);
}
Ext.callback(request.callback, request.scope, [success, result, request.errorType]);
},
createScript: function(url, params) {
var script = document.createElement('script');
script.setAttribute("src", Ext.urlAppend(url, Ext.Object.toQueryString(params)));
script.setAttribute("async", true);
script.setAttribute("type", "text/javascript");
return script;
}
});
Ext.define('Ext.data.JsonPStore', {
extend: 'Ext.data.Store',
alias : 'store.jsonp',
constructor: function(config) {
this.callParent(Ext.apply(config, {
reader: Ext.create('Ext.data.reader.Json', config),
proxy : Ext.create('Ext.data.proxy.JsonP', config)
}));
}
});
Ext.define('Ext.data.NodeInterface', {
requires: ['Ext.data.Field'],
statics: {
decorate: function(record) {
if (!record.isNode) {
var mgr = Ext.ModelManager,
modelName = record.modelName,
modelClass = mgr.getModel(modelName),
idName = modelClass.prototype.idProperty,
newFields = [],
i, newField, len;
modelClass.override(this.getPrototypeBody());
newFields = this.applyFields(modelClass, [
{name: idName, type: 'string', defaultValue: null},
{name: 'parentId', type: 'string', defaultValue: null},
{name: 'index', type: 'int', defaultValue: null},
{name: 'depth', type: 'int', defaultValue: 0},
{name: 'expanded', type: 'bool', defaultValue: false, persist: false},
{name: 'expandable', type: 'bool', defaultValue: true, persist: false},
{name: 'checked', type: 'auto', defaultValue: null},
{name: 'leaf', type: 'bool', defaultValue: false, persist: false},
{name: 'cls', type: 'string', defaultValue: null, persist: false},
{name: 'iconCls', type: 'string', defaultValue: null, persist: false},
{name: 'root', type: 'boolean', defaultValue: false, persist: false},
{name: 'isLast', type: 'boolean', defaultValue: false, persist: false},
{name: 'isFirst', type: 'boolean', defaultValue: false, persist: false},
{name: 'allowDrop', type: 'boolean', defaultValue: true, persist: false},
{name: 'allowDrag', type: 'boolean', defaultValue: true, persist: false},
{name: 'loaded', type: 'boolean', defaultValue: false, persist: false},
{name: 'loading', type: 'boolean', defaultValue: false, persist: false},
{name: 'href', type: 'string', defaultValue: null, persist: false},
{name: 'hrefTarget', type: 'string', defaultValue: null, persist: false},
{name: 'qtip', type: 'string', defaultValue: null, persist: false},
{name: 'qtitle', type: 'string', defaultValue: null, persist: false}
]);
len = newFields.length;
for (i = 0; i < len; ++i) {
newField = newFields[i];
if (record.get(newField.name) === undefined) {
record.data[newField.name] = newField.defaultValue;
}
}
}
Ext.applyIf(record, {
firstChild: null,
lastChild: null,
parentNode: null,
previousSibling: null,
nextSibling: null,
childNodes: []
});
record.commit(true);
record.enableBubble([
"append",
"remove",
"move",
"insert",
"beforeappend",
"beforeremove",
"beforemove",
"beforeinsert",
"expand",
"collapse",
"beforeexpand",
"beforecollapse",
"sort"
]);
return record;
},
applyFields: function(modelClass, addFields) {
var modelPrototype = modelClass.prototype,
fields = modelPrototype.fields,
keys = fields.keys,
ln = addFields.length,
addField, i, name,
newFields = [];
for (i = 0; i < ln; i++) {
addField = addFields[i];
if (!Ext.Array.contains(keys, addField.name)) {
addField = Ext.create('data.field', addField);
newFields.push(addField);
fields.add(addField);
}
}
return newFields;
},
getPrototypeBody: function() {
return {
isNode: true,
createNode: function(node) {
if (Ext.isObject(node) && !node.isModel) {
node = Ext.ModelManager.create(node, this.modelName);
}
return Ext.data.NodeInterface.decorate(node);
},
isLeaf : function() {
return this.get('leaf') === true;
},
setFirstChild : function(node) {
this.firstChild = node;
},
setLastChild : function(node) {
this.lastChild = node;
},
updateInfo: function(silent) {
var me = this,
isRoot = me.isRoot(),
parentNode = me.parentNode,
isFirst = (!parentNode ? true : parentNode.firstChild == me),
isLast = (!parentNode ? true : parentNode.lastChild == me),
depth = 0,
parent = me,
children = me.childNodes,
len = children.length,
i = 0;
while (parent.parentNode) {
++depth;
parent = parent.parentNode;
}
me.beginEdit();
me.set({
isFirst: isFirst,
isLast: isLast,
depth: depth,
index: parentNode ? parentNode.indexOf(me) : 0,
parentId: parentNode ? parentNode.getId() : null
});
me.endEdit(silent);
if (silent) {
me.commit();
}
for (i = 0; i < len; i++) {
children[i].updateInfo(silent);
}
},
isLast : function() {
return this.get('isLast');
},
isFirst : function() {
return this.get('isFirst');
},
hasChildNodes : function() {
return !this.isLeaf() && this.childNodes.length > 0;
},
isExpandable : function() {
var me = this;
if (me.get('expandable')) {
return !(me.isLeaf() || (me.isLoaded() && !me.hasChildNodes()));
}
return false;
},
appendChild : function(node, suppressEvents, suppressNodeUpdate) {
var me = this,
i, ln,
index,
oldParent,
ps;
if (Ext.isArray(node)) {
for (i = 0, ln = node.length; i < ln; i++) {
me.appendChild(node[i]);
}
} else {
node = me.createNode(node);
if (suppressEvents !== true && me.fireEvent("beforeappend", me, node) === false) {
return false;
}
index = me.childNodes.length;
oldParent = node.parentNode;
if (oldParent) {
if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index) === false) {
return false;
}
oldParent.removeChild(node, null, false, true);
}
index = me.childNodes.length;
if (index === 0) {
me.setFirstChild(node);
}
me.childNodes.push(node);
node.parentNode = me;
node.nextSibling = null;
me.setLastChild(node);
ps = me.childNodes[index - 1];
if (ps) {
node.previousSibling = ps;
ps.nextSibling = node;
ps.updateInfo(suppressNodeUpdate);
} else {
node.previousSibling = null;
}
node.updateInfo(suppressNodeUpdate);
if (!me.isLoaded()) {
me.set('loaded', true);
}
else if (me.childNodes.length === 1) {
me.set('loaded', me.isLoaded());
}
if (suppressEvents !== true) {
me.fireEvent("append", me, node, index);
if (oldParent) {
node.fireEvent("move", node, oldParent, me, index);
}
}
return node;
}
},
getBubbleTarget: function() {
return this.parentNode;
},
removeChild : function(node, destroy, suppressEvents, suppressNodeUpdate) {
var me = this,
index = me.indexOf(node);
if (index == -1 || (suppressEvents !== true && me.fireEvent("beforeremove", me, node) === false)) {
return false;
}
Ext.Array.erase(me.childNodes, index, 1);
if (me.firstChild == node) {
me.setFirstChild(node.nextSibling);
}
if (me.lastChild == node) {
me.setLastChild(node.previousSibling);
}
if (node.previousSibling) {
node.previousSibling.nextSibling = node.nextSibling;
node.previousSibling.updateInfo(suppressNodeUpdate);
}
if (node.nextSibling) {
node.nextSibling.previousSibling = node.previousSibling;
node.nextSibling.updateInfo(suppressNodeUpdate);
}
if (suppressEvents !== true) {
me.fireEvent("remove", me, node);
}
if (!me.childNodes.length) {
me.set('loaded', me.isLoaded());
}
if (destroy) {
node.destroy(true);
} else {
node.clear();
}
return node;
},
copy: function(newId, deep) {
var me = this,
result = me.callOverridden(arguments),
len = me.childNodes ? me.childNodes.length : 0,
i;
if (deep) {
for (i = 0; i < len; i++) {
result.appendChild(me.childNodes[i].copy(true));
}
}
return result;
},
clear : function(destroy) {
var me = this;
me.parentNode = me.previousSibling = me.nextSibling = null;
if (destroy) {
me.firstChild = me.lastChild = null;
}
},
destroy : function(silent) {
var me = this,
options = me.destroyOptions;
if (silent === true) {
me.clear(true);
Ext.each(me.childNodes, function(n) {
n.destroy(true);
});
me.childNodes = null;
delete me.destroyOptions;
me.callOverridden([options]);
} else {
me.destroyOptions = silent;
me.remove(true);
}
},
insertBefore : function(node, refNode, suppressEvents) {
var me = this,
index = me.indexOf(refNode),
oldParent = node.parentNode,
refIndex = index,
ps;
if (!refNode) {
return me.appendChild(node);
}
if (node == refNode) {
return false;
}
node = me.createNode(node);
if (suppressEvents !== true && me.fireEvent("beforeinsert", me, node, refNode) === false) {
return false;
}
if (oldParent == me && me.indexOf(node) < index) {
refIndex--;
}
if (oldParent) {
if (suppressEvents !== true && node.fireEvent("beforemove", node, oldParent, me, index, refNode) === false) {
return false;
}
oldParent.removeChild(node);
}
if (refIndex === 0) {
me.setFirstChild(node);
}
Ext.Array.splice(me.childNodes, refIndex, 0, node);
node.parentNode = me;
node.nextSibling = refNode;
refNode.previousSibling = node;
ps = me.childNodes[refIndex - 1];
if (ps) {
node.previousSibling = ps;
ps.nextSibling = node;
ps.updateInfo();
} else {
node.previousSibling = null;
}
node.updateInfo();
if (!me.isLoaded()) {
me.set('loaded', true);
}
else if (me.childNodes.length === 1) {
me.set('loaded', me.isLoaded());
}
if (suppressEvents !== true) {
me.fireEvent("insert", me, node, refNode);
if (oldParent) {
node.fireEvent("move", node, oldParent, me, refIndex, refNode);
}
}
return node;
},
insertChild: function(index, node) {
var sibling = this.childNodes[index];
if (sibling) {
return this.insertBefore(node, sibling);
}
else {
return this.appendChild(node);
}
},
remove : function(destroy, suppressEvents) {
var parentNode = this.parentNode;
if (parentNode) {
parentNode.removeChild(this, destroy, suppressEvents, true);
}
return this;
},
removeAll : function(destroy, suppressEvents) {
var cn = this.childNodes,
n;
while ((n = cn[0])) {
this.removeChild(n, destroy, suppressEvents);
}
return this;
},
getChildAt : function(index) {
return this.childNodes[index];
},
replaceChild : function(newChild, oldChild, suppressEvents) {
var s = oldChild ? oldChild.nextSibling : null;
this.removeChild(oldChild, suppressEvents);
this.insertBefore(newChild, s, suppressEvents);
return oldChild;
},
indexOf : function(child) {
return Ext.Array.indexOf(this.childNodes, child);
},
getDepth : function() {
return this.get('depth');
},
bubble : function(fn, scope, args) {
var p = this;
while (p) {
if (fn.apply(scope || p, args || [p]) === false) {
break;
}
p = p.parentNode;
}
},
cascade: function() {
if (Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Ext.data.Node: cascade has been deprecated. Please use cascadeBy instead.');
}
return this.cascadeBy.apply(this, arguments);
},
cascadeBy : function(fn, scope, args) {
if (fn.apply(scope || this, args || [this]) !== false) {
var childNodes = this.childNodes,
length = childNodes.length,
i;
for (i = 0; i < length; i++) {
childNodes[i].cascadeBy(fn, scope, args);
}
}
},
eachChild : function(fn, scope, args) {
var childNodes = this.childNodes,
length = childNodes.length,
i;
for (i = 0; i < length; i++) {
if (fn.apply(scope || this, args || [childNodes[i]]) === false) {
break;
}
}
},
findChild : function(attribute, value, deep) {
return this.findChildBy(function() {
return this.get(attribute) == value;
}, null, deep);
},
findChildBy : function(fn, scope, deep) {
var cs = this.childNodes,
len = cs.length,
i = 0, n, res;
for (; i < len; i++) {
n = cs[i];
if (fn.call(scope || n, n) === true) {
return n;
}
else if (deep) {
res = n.findChildBy(fn, scope, deep);
if (res !== null) {
return res;
}
}
}
return null;
},
contains : function(node) {
return node.isAncestor(this);
},
isAncestor : function(node) {
var p = this.parentNode;
while (p) {
if (p == node) {
return true;
}
p = p.parentNode;
}
return false;
},
sort : function(sortFn, recursive, suppressEvent) {
var cs = this.childNodes,
ln = cs.length,
i, n;
if (ln > 0) {
Ext.Array.sort(cs, sortFn);
for (i = 0; i < ln; i++) {
n = cs[i];
n.previousSibling = cs[i-1];
n.nextSibling = cs[i+1];
if (i === 0) {
this.setFirstChild(n);
n.updateInfo();
}
if (i == ln - 1) {
this.setLastChild(n);
n.updateInfo();
}
if (recursive && !n.isLeaf()) {
n.sort(sortFn, true, true);
}
}
if (suppressEvent !== true) {
this.fireEvent('sort', this, cs);
}
}
},
isExpanded: function() {
return this.get('expanded');
},
isLoaded: function() {
return this.get('loaded');
},
isLoading: function() {
return this.get('loading');
},
isRoot: function() {
return !this.parentNode;
},
isVisible: function() {
var parent = this.parentNode;
while (parent) {
if (!parent.isExpanded()) {
return false;
}
parent = parent.parentNode;
}
return true;
},
expand: function(recursive, callback, scope) {
var me = this;
if (!me.isLeaf()) {
if (!me.isLoading() && !me.isExpanded()) {
me.fireEvent('beforeexpand', me, function() {
me.set('expanded', true);
me.fireEvent('expand', me, me.childNodes, false);
if (recursive) {
me.expandChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}, me);
}
else if (recursive) {
me.expandChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}
else {
Ext.callback(callback, scope || me);
}
},
expandChildren: function(recursive, callback, scope) {
var me = this,
i = 0,
nodes = me.childNodes,
ln = nodes.length,
node,
expanding = 0;
for (; i < ln; ++i) {
node = nodes[i];
if (!node.isLeaf() && !node.isExpanded()) {
expanding++;
nodes[i].expand(recursive, function () {
expanding--;
if (callback && !expanding) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
});
}
}
if (!expanding && callback) {
Ext.callback(callback, scope || me, [me.childNodes]); }
},
collapse: function(recursive, callback, scope) {
var me = this;
if (!me.isLeaf()) {
if (!me.collapsing && me.isExpanded()) {
me.fireEvent('beforecollapse', me, function() {
me.set('expanded', false);
me.fireEvent('collapse', me, me.childNodes, false);
if (recursive) {
me.collapseChildren(true, callback, scope);
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}, me);
}
else if (recursive) {
me.collapseChildren(true, callback, scope);
}
}
else {
Ext.callback(callback, scope || me, [me.childNodes]);
}
},
collapseChildren: function(recursive, callback, scope) {
var me = this,
i = 0,
nodes = me.childNodes,
ln = nodes.length,
node,
collapsing = 0;
for (; i < ln; ++i) {
node = nodes[i];
if (!node.isLeaf() && node.isExpanded()) {
collapsing++;
nodes[i].collapse(recursive, function () {
collapsing--;
if (callback && !collapsing) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
});
}
}
if (!collapsing && callback) {
Ext.callback(callback, scope || me, [me.childNodes]);
}
}
};
}
}
});
Ext.define('Ext.data.NodeStore', {
extend: 'Ext.data.Store',
alias: 'store.node',
requires: ['Ext.data.NodeInterface'],
node: null,
recursive: false,
rootVisible: false,
constructor: function(config) {
var me = this,
node;
config = config || {};
Ext.apply(me, config);
config.proxy = {type: 'proxy'};
me.callParent([config]);
me.addEvents('expand', 'collapse', 'beforeexpand', 'beforecollapse');
node = me.node;
if (node) {
me.node = null;
me.setNode(node);
}
},
setNode: function(node) {
var me = this;
if (me.node && me.node != node) {
me.mun(me.node, {
expand: me.onNodeExpand,
collapse: me.onNodeCollapse,
append: me.onNodeAppend,
insert: me.onNodeInsert,
remove: me.onNodeRemove,
sort: me.onNodeSort,
scope: me
});
me.node = null;
}
if (node) {
Ext.data.NodeInterface.decorate(node);
me.removeAll();
if (me.rootVisible) {
me.add(node);
}
me.mon(node, {
expand: me.onNodeExpand,
collapse: me.onNodeCollapse,
append: me.onNodeAppend,
insert: me.onNodeInsert,
remove: me.onNodeRemove,
sort: me.onNodeSort,
scope: me
});
me.node = node;
if (node.isExpanded() && node.isLoaded()) {
me.onNodeExpand(node, node.childNodes, true);
}
}
},
onNodeSort: function(node, childNodes) {
var me = this;
if ((me.indexOf(node) !== -1 || (node === me.node && !me.rootVisible) && node.isExpanded())) {
me.onNodeCollapse(node, childNodes, true);
me.onNodeExpand(node, childNodes, true);
}
},
onNodeExpand: function(parent, records, suppressEvent) {
var me = this,
insertIndex = me.indexOf(parent) + 1,
ln = records ? records.length : 0,
i, record;
if (!me.recursive && parent !== me.node) {
return;
}
if (!me.isVisible(parent)) {
return;
}
if (!suppressEvent && me.fireEvent('beforeexpand', parent, records, insertIndex) === false) {
return;
}
if (ln) {
me.insert(insertIndex, records);
for (i = 0; i < ln; i++) {
record = records[i];
if (record.isExpanded()) {
if (record.isLoaded()) {
me.onNodeExpand(record, record.childNodes, true);
}
else {
record.set('expanded', false);
record.expand();
}
}
}
}
if (!suppressEvent) {
me.fireEvent('expand', parent, records);
}
},
onNodeCollapse: function(parent, records, suppressEvent) {
var me = this,
ln = records.length,
collapseIndex = me.indexOf(parent) + 1,
i, record;
if (!me.recursive && parent !== me.node) {
return;
}
if (!suppressEvent && me.fireEvent('beforecollapse', parent, records, collapseIndex) === false) {
return;
}
for (i = 0; i < ln; i++) {
record = records[i];
me.remove(record);
if (record.isExpanded()) {
me.onNodeCollapse(record, record.childNodes, true);
}
}
if (!suppressEvent) {
me.fireEvent('collapse', parent, records, collapseIndex);
}
},
onNodeAppend: function(parent, node, index) {
var me = this,
refNode, sibling;
if (me.isVisible(node)) {
if (index === 0) {
refNode = parent;
} else {
sibling = node.previousSibling;
while (sibling.isExpanded() && sibling.lastChild) {
sibling = sibling.lastChild;
}
refNode = sibling;
}
me.insert(me.indexOf(refNode) + 1, node);
if (!node.isLeaf() && node.isExpanded()) {
if (node.isLoaded()) {
me.onNodeExpand(node, node.childNodes, true);
}
else {
node.set('expanded', false);
node.expand();
}
}
}
},
onNodeInsert: function(parent, node, refNode) {
var me = this,
index = this.indexOf(refNode);
if (index != -1 && me.isVisible(node)) {
me.insert(index, node);
if (!node.isLeaf() && node.isExpanded()) {
if (node.isLoaded()) {
me.onNodeExpand(node, node.childNodes, true);
}
else {
node.set('expanded', false);
node.expand();
}
}
}
},
onNodeRemove: function(parent, node, index) {
var me = this;
if (me.indexOf(node) != -1) {
if (!node.isLeaf() && node.isExpanded()) {
me.onNodeCollapse(node, node.childNodes, true);
}
me.remove(node);
}
},
isVisible: function(node) {
var parent = node.parentNode;
while (parent) {
if (parent === this.node && !this.rootVisible && parent.isExpanded()) {
return true;
}
if (this.indexOf(parent) === -1 || !parent.isExpanded()) {
return false;
}
parent = parent.parentNode;
}
return true;
}
});
Ext.define('Ext.data.Request', {
action: undefined,
params: undefined,
method: 'GET',
url: undefined,
constructor: function(config) {
Ext.apply(this, config);
}
});
Ext.define('Ext.data.Tree', {
alias: 'data.tree',
mixins: {
observable: "Ext.util.Observable"
},
root: null,
constructor: function(root) {
var me = this;
me.nodeHash = {};
me.mixins.observable.constructor.call(me);
if (root) {
me.setRootNode(root);
}
},
getRootNode : function() {
return this.root;
},
setRootNode : function(node) {
var me = this;
me.root = node;
Ext.data.NodeInterface.decorate(node);
if (me.fireEvent('beforeappend', null, node) !== false) {
node.set('root', true);
node.updateInfo();
me.relayEvents(node, [
"append",
"remove",
"move",
"insert",
"beforeappend",
"beforeremove",
"beforemove",
"beforeinsert",
"expand",
"collapse",
"beforeexpand",
"beforecollapse" ,
"rootchange"
]);
node.on({
scope: me,
insert: me.onNodeInsert,
append: me.onNodeAppend,
remove: me.onNodeRemove
});
me.registerNode(node);
me.fireEvent('append', null, node);
me.fireEvent('rootchange', node);
}
return node;
},
flatten: function(){
var nodes = [],
hash = this.nodeHash,
key;
for (key in hash) {
if (hash.hasOwnProperty(key)) {
nodes.push(hash[key]);
}
}
return nodes;
},
onNodeInsert: function(parent, node) {
this.registerNode(node);
},
onNodeAppend: function(parent, node) {
this.registerNode(node);
},
onNodeRemove: function(parent, node) {
this.unregisterNode(node);
},
getNodeById : function(id) {
return this.nodeHash[id];
},
registerNode : function(node) {
this.nodeHash[node.getId() || node.internalId] = node;
},
unregisterNode : function(node) {
delete this.nodeHash[node.getId() || node.internalId];
},
sort: function(sorterFn, recursive) {
this.getRootNode().sort(sorterFn, recursive);
},
filter: function(filters, recursive) {
this.getRootNode().filter(filters, recursive);
}
});
Ext.define('Ext.data.TreeStore', {
extend: 'Ext.data.AbstractStore',
alias: 'store.tree',
requires: ['Ext.data.Tree', 'Ext.data.NodeInterface', 'Ext.data.NodeStore'],
clearOnLoad : true,
nodeParam: 'node',
defaultRootId: 'root',
defaultRootProperty: 'children',
folderSort: false,
constructor: function(config) {
var me = this,
root,
fields;
config = Ext.apply({}, config);
fields = config.fields || me.fields;
if (!fields) {
config.fields = [{name: 'text', type: 'string'}];
}
me.callParent([config]);
me.tree = Ext.create('Ext.data.Tree');
me.relayEvents(me.tree, [
"append",
"remove",
"move",
"insert",
"beforeappend",
"beforeremove",
"beforemove",
"beforeinsert",
"expand",
"collapse",
"beforeexpand",
"beforecollapse",
"sort",
"rootchange"
]);
me.tree.on({
scope: me,
remove: me.onNodeRemove,
beforeexpand: me.onBeforeNodeExpand,
beforecollapse: me.onBeforeNodeCollapse,
append: me.onNodeAdded,
insert: me.onNodeAdded
});
me.onBeforeSort();
root = me.root;
if (root) {
delete me.root;
me.setRootNode(root);
}
me.addEvents(
'rootchange'
);
if (Ext.isDefined(me.nodeParameter)) {
if (Ext.isDefined(Ext.global.console)) {
Ext.global.console.warn('Ext.data.TreeStore: nodeParameter has been deprecated. Please use nodeParam instead.');
}
me.nodeParam = me.nodeParameter;
delete me.nodeParameter;
}
},
setProxy: function(proxy) {
var reader,
needsRoot;
if (proxy instanceof Ext.data.proxy.Proxy) {
needsRoot = Ext.isEmpty(proxy.getReader().root);
} else if (Ext.isString(proxy)) {
needsRoot = true;
} else {
reader = proxy.reader;
needsRoot = !(reader && !Ext.isEmpty(reader.root));
}
proxy = this.callParent(arguments);
if (needsRoot) {
reader = proxy.getReader();
reader.root = this.defaultRootProperty;
reader.buildExtractors(true);
}
},
onBeforeSort: function() {
if (this.folderSort) {
this.sort({
property: 'leaf',
direction: 'ASC'
}, 'prepend', false);
}
},
onBeforeNodeExpand: function(node, callback, scope) {
if (node.isLoaded()) {
Ext.callback(callback, scope || node, [node.childNodes]);
}
else if (node.isLoading()) {
this.on('load', function() {
Ext.callback(callback, scope || node, [node.childNodes]);
}, this, {single: true});
}
else {
this.read({
node: node,
callback: function() {
Ext.callback(callback, scope || node, [node.childNodes]);
}
});
}
},
getNewRecords: function() {
return Ext.Array.filter(this.tree.flatten(), this.filterNew);
},
getUpdatedRecords: function() {
return Ext.Array.filter(this.tree.flatten(), this.filterUpdated);
},
onBeforeNodeCollapse: function(node, callback, scope) {
callback.call(scope || node, node.childNodes);
},
onNodeRemove: function(parent, node) {
var removed = this.removed;
if (!node.isReplace && Ext.Array.indexOf(removed, node) == -1) {
removed.push(node);
}
},
onNodeAdded: function(parent, node) {
var proxy = this.getProxy(),
reader = proxy.getReader(),
data = node.raw || node.data,
dataRoot, children;
Ext.Array.remove(this.removed, node);
if (!node.isLeaf() && !node.isLoaded()) {
dataRoot = reader.getRoot(data);
if (dataRoot) {
this.fillNode(node, reader.extractData(dataRoot));
delete data[reader.root];
}
}
},
setRootNode: function(root) {
var me = this;
root = root || {};
if (!root.isNode) {
Ext.applyIf(root, {
id: me.defaultRootId,
text: 'Root',
allowDrag: false
});
root = Ext.ModelManager.create(root, me.model);
}
Ext.data.NodeInterface.decorate(root);
me.getProxy().getReader().buildExtractors(true);
me.tree.setRootNode(root);
if (!root.isLoaded() && root.isExpanded()) {
me.load({
node: root
});
}
return root;
},
getRootNode: function() {
return this.tree.getRootNode();
},
getNodeById: function(id) {
return this.tree.getNodeById(id);
},
load: function(options) {
options = options || {};
options.params = options.params || {};
var me = this,
node = options.node || me.tree.getRootNode(),
root;
if (!node) {
node = me.setRootNode({
expanded: true
});
}
if (me.clearOnLoad) {
node.removeAll();
}
Ext.applyIf(options, {
node: node
});
options.params[me.nodeParam] = node ? node.getId() : 'root';
if (node) {
node.set('loading', true);
}
return me.callParent([options]);
},
fillNode: function(node, records) {
var me = this,
ln = records ? records.length : 0,
i = 0, sortCollection;
if (ln && me.sortOnLoad && !me.remoteSort && me.sorters && me.sorters.items) {
sortCollection = Ext.create('Ext.util.MixedCollection');
sortCollection.addAll(records);
sortCollection.sort(me.sorters.items);
records = sortCollection.items;
}
node.set('loaded', true);
for (; i < ln; i++) {
node.appendChild(records[i], undefined, true);
}
return records;
},
onProxyLoad: function(operation) {
var me = this,
successful = operation.wasSuccessful(),
records = operation.getRecords(),
node = operation.node;
node.set('loading', false);
if (successful) {
records = me.fillNode(node, records);
}
me.fireEvent('read', me, operation.node, records, successful);
me.fireEvent('load', me, operation.node, records, successful);
Ext.callback(operation.callback, operation.scope || me, [records, operation, successful]);
},
onCreateRecords: function(records, operation, success) {
if (success) {
var i = 0,
length = records.length,
originalRecords = operation.records,
parentNode,
record,
original,
index;
for (; i < length; ++i) {
record = records[i];
original = originalRecords[i];
if (original) {
parentNode = original.parentNode;
if (parentNode) {
original.isReplace = true;
parentNode.replaceChild(record, original);
delete original.isReplace;
}
record.phantom = false;
}
}
}
},
onUpdateRecords: function(records, operation, success){
if (success) {
var me = this,
i = 0,
length = records.length,
data = me.data,
original,
parentNode,
record;
for (; i < length; ++i) {
record = records[i];
original = me.tree.getNodeById(record.getId());
parentNode = original.parentNode;
if (parentNode) {
original.isReplace = true;
parentNode.replaceChild(record, original);
original.isReplace = false;
}
}
}
},
onDestroyRecords: function(records, operation, success){
if (success) {
this.removed = [];
}
},
removeAll: function() {
this.getRootNode().destroy(true);
this.fireEvent('clear', this);
},
doSort: function(sorterFn) {
var me = this;
if (me.remoteSort) {
me.load();
} else {
me.tree.sort(sorterFn, true);
me.fireEvent('datachanged', me);
}
me.fireEvent('sort', me);
}
});
Ext.define('Ext.data.XmlStore', {
extend: 'Ext.data.Store',
alternateClassName: 'Ext.data.XmlStore',
alias: 'store.xml',
constructor: function(config){
config = config || {};
config = config || {};
Ext.applyIf(config, {
proxy: {
type: 'ajax',
reader: 'xml',
writer: 'xml'
}
});
this.callParent([config]);
}
});
Ext.define('Ext.data.proxy.Client', {
extend: 'Ext.data.proxy.Proxy',
alternateClassName: 'Ext.data.ClientProxy',
clear: function() {
}
});
Ext.define('Ext.data.proxy.JsonP', {
extend: 'Ext.data.proxy.Server',
alternateClassName: 'Ext.data.ScriptTagProxy',
alias: ['proxy.jsonp', 'proxy.scripttag'],
requires: ['Ext.data.JsonP'],
defaultWriterType: 'base',
callbackKey : 'callback',
recordParam: 'records',
autoAppendParams: true,
constructor: function(){
this.addEvents(
'exception'
);
this.callParent(arguments);
},
doRequest: function(operation, callback, scope) {
var me = this,
writer = me.getWriter(),
request = me.buildRequest(operation),
params = request.params;
if (operation.allowWrite()) {
request = writer.write(request);
}
Ext.apply(request, {
callbackKey: me.callbackKey,
timeout: me.timeout,
scope: me,
disableCaching: false,
callback: me.createRequestCallback(request, operation, callback, scope)
});
if (me.autoAppendParams) {
request.params = {};
}
request.jsonp = Ext.data.JsonP.request(request);
request.params = params;
operation.setStarted();
me.lastRequest = request;
return request;
},
createRequestCallback: function(request, operation, callback, scope) {
var me = this;
return function(success, response, errorType) {
delete me.lastRequest;
me.processResponse(success, operation, request, response, callback, scope);
};
},
setException: function(operation, response) {
operation.setException(operation.request.jsonp.errorType);
},
buildUrl: function(request) {
var me = this,
url = me.callParent(arguments),
params = Ext.apply({}, request.params),
filters = params.filters,
records,
filter, i;
delete params.filters;
if (me.autoAppendParams) {
url = Ext.urlAppend(url, Ext.Object.toQueryString(params));
}
if (filters && filters.length) {
for (i = 0; i < filters.length; i++) {
filter = filters[i];
if (filter.value) {
url = Ext.urlAppend(url, filter.property + "=" + filter.value);
}
}
}
records = request.records;
if (Ext.isArray(records) && records.length > 0) {
url = Ext.urlAppend(url, Ext.String.format("{0}={1}", me.recordParam, me.encodeRecords(records)));
}
return url;
},
destroy: function() {
this.abort();
this.callParent();
},
abort: function() {
var lastRequest = this.lastRequest;
if (lastRequest) {
Ext.data.JsonP.abort(lastRequest.jsonp);
}
},
encodeRecords: function(records) {
var encoded = "",
i = 0,
len = records.length;
for (; i < len; i++) {
encoded += Ext.Object.toQueryString(records[i].data);
}
return encoded;
}
});
Ext.define('Ext.data.proxy.WebStorage', {
extend: 'Ext.data.proxy.Client',
alternateClassName: 'Ext.data.WebStorageProxy',
id: undefined,
constructor: function(config) {
this.callParent(arguments);
this.cache = {};
this.id = this.id || (this.store ? this.store.storeId : undefined);
this.initialize();
},
create: function(operation, callback, scope) {
var records = operation.records,
length = records.length,
ids = this.getIds(),
id, record, i;
operation.setStarted();
for (i = 0; i < length; i++) {
record = records[i];
if (record.phantom) {
record.phantom = false;
id = this.getNextId();
} else {
id = record.getId();
}
this.setRecord(record, id);
ids.push(id);
}
this.setIds(ids);
operation.setCompleted();
operation.setSuccessful();
if (typeof callback == 'function') {
callback.call(scope || this, operation);
}
},
read: function(operation, callback, scope) {
var records = [],
ids = this.getIds(),
length = ids.length,
i, recordData, record;
if (operation.id) {
record = this.getRecord(operation.id);
if (record) {
records.push(record);
operation.setSuccessful();
}
} else {
for (i = 0; i < length; i++) {
records.push(this.getRecord(ids[i]));
}
operation.setSuccessful();
}
operation.setCompleted();
operation.resultSet = Ext.create('Ext.data.ResultSet', {
records: records,
total : records.length,
loaded : true
});
if (typeof callback == 'function') {
callback.call(scope || this, operation);
}
},
update: function(operation, callback, scope) {
var records = operation.records,
length = records.length,
ids = this.getIds(),
record, id, i;
operation.setStarted();
for (i = 0; i < length; i++) {
record = records[i];
this.setRecord(record);
id = record.getId();
if (id !== undefined && Ext.Array.indexOf(ids, id) == -1) {
ids.push(id);
}
}
this.setIds(ids);
operation.setCompleted();
operation.setSuccessful();
if (typeof callback == 'function') {
callback.call(scope || this, operation);
}
},
destroy: function(operation, callback, scope) {
var records = operation.records,
length = records.length,
ids = this.getIds(),
newIds = [].concat(ids),
i;
for (i = 0; i < length; i++) {
Ext.Array.remove(newIds, records[i].getId());
this.removeRecord(records[i], false);
}
this.setIds(newIds);
operation.setCompleted();
operation.setSuccessful();
if (typeof callback == 'function') {
callback.call(scope || this, operation);
}
},
getRecord: function(id) {
if (this.cache[id] === undefined) {
var rawData = Ext.decode(this.getStorageObject().getItem(this.getRecordKey(id))),
data = {},
Model = this.model,
fields = Model.prototype.fields.items,
length = fields.length,
i, field, name, record;
for (i = 0; i < length; i++) {
field = fields[i];
name = field.name;
if (typeof field.decode == 'function') {
data[name] = field.decode(rawData[name]);
} else {
data[name] = rawData[name];
}
}
record = new Model(data, id);
record.phantom = false;
this.cache[id] = record;
}
return this.cache[id];
},
setRecord: function(record, id) {
if (id) {
record.setId(id);
} else {
id = record.getId();
}
var me = this,
rawData = record.data,
data = {},
model = me.model,
fields = model.prototype.fields.items,
length = fields.length,
i = 0,
field, name, obj, key;
for (; i < length; i++) {
field = fields[i];
name = field.name;
if (typeof field.encode == 'function') {
data[name] = field.encode(rawData[name], record);
} else {
data[name] = rawData[name];
}
}
obj = me.getStorageObject();
key = me.getRecordKey(id);
me.cache[id] = record;
obj.removeItem(key);
obj.setItem(key, Ext.encode(data));
},
removeRecord: function(id, updateIds) {
var me = this,
ids;
if (id.isModel) {
id = id.getId();
}
if (updateIds !== false) {
ids = me.getIds();
Ext.Array.remove(ids, id);
me.setIds(ids);
}
me.getStorageObject().removeItem(me.getRecordKey(id));
},
getRecordKey: function(id) {
if (id.isModel) {
id = id.getId();
}
return Ext.String.format("{0}-{1}", this.id, id);
},
getRecordCounterKey: function() {
return Ext.String.format("{0}-counter", this.id);
},
getIds: function() {
var ids = (this.getStorageObject().getItem(this.id) || "").split(","),
length = ids.length,
i;
if (length == 1 && ids[0] === "") {
ids = [];
} else {
for (i = 0; i < length; i++) {
ids[i] = parseInt(ids[i], 10);
}
}
return ids;
},
setIds: function(ids) {
var obj = this.getStorageObject(),
str = ids.join(",");
obj.removeItem(this.id);
if (!Ext.isEmpty(str)) {
obj.setItem(this.id, str);
}
},
getNextId: function() {
var obj = this.getStorageObject(),
key = this.getRecordCounterKey(),
last = obj.getItem(key),
ids, id;
if (last === null) {
ids = this.getIds();
last = ids[ids.length - 1] || 0;
}
id = parseInt(last, 10) + 1;
obj.setItem(key, id);
return id;
},
initialize: function() {
var storageObject = this.getStorageObject();
storageObject.setItem(this.id, storageObject.getItem(this.id) || "");
},
clear: function() {
var obj = this.getStorageObject(),
ids = this.getIds(),
len = ids.length,
i;
for (i = 0; i < len; i++) {
this.removeRecord(ids[i]);
}
obj.removeItem(this.getRecordCounterKey());
obj.removeItem(this.id);
},
getStorageObject: function() {
}
});
Ext.define('Ext.data.proxy.LocalStorage', {
extend: 'Ext.data.proxy.WebStorage',
alias: 'proxy.localstorage',
alternateClassName: 'Ext.data.LocalStorageProxy',
getStorageObject: function() {
return window.localStorage;
}
});
Ext.define('Ext.data.proxy.Memory', {
extend: 'Ext.data.proxy.Client',
alias: 'proxy.memory',
alternateClassName: 'Ext.data.MemoryProxy',
constructor: function(config) {
this.callParent([config]);
this.setReader(this.reader);
},
read: function(operation, callback, scope) {
var me = this,
reader = me.getReader(),
result = reader.read(me.data);
Ext.apply(operation, {
resultSet: result
});
operation.setCompleted();
operation.setSuccessful();
Ext.callback(callback, scope || me, [operation]);
},
clear: Ext.emptyFn
});
Ext.define('Ext.data.proxy.Rest', {
extend: 'Ext.data.proxy.Ajax',
alternateClassName: 'Ext.data.RestProxy',
alias : 'proxy.rest',
appendId: true,
batchActions: false,
buildUrl: function(request) {
var me = this,
operation = request.operation,
records = operation.records || [],
record = records[0],
format = me.format,
url = me.getUrl(request),
id = record ? record.getId() : operation.id;
if (me.appendId && id) {
if (!url.match(/\/$/)) {
url += '/';
}
url += id;
}
if (format) {
if (!url.match(/\.$/)) {
url += '.';
}
url += format;
}
request.url = url;
return me.callParent(arguments);
}
}, function() {
Ext.apply(this.prototype, {
actionMethods: {
create : 'POST',
read : 'GET',
update : 'PUT',
destroy: 'DELETE'
}
});
});
Ext.define('Ext.data.proxy.SessionStorage', {
extend: 'Ext.data.proxy.WebStorage',
alias: 'proxy.sessionstorage',
alternateClassName: 'Ext.data.SessionStorageProxy',
getStorageObject: function() {
return window.sessionStorage;
}
});
Ext.define('Ext.data.reader.Array', {
extend: 'Ext.data.reader.Json',
alternateClassName: 'Ext.data.ArrayReader',
alias : 'reader.array',
buildExtractors: function() {
this.callParent(arguments);
var fields = this.model.prototype.fields.items,
length = fields.length,
extractorFunctions = [],
i;
for (i = 0; i < length; i++) {
extractorFunctions.push(function(index) {
return function(data) {
return data[index];
};
}(fields[i].mapping || i));
}
this.extractorFunctions = extractorFunctions;
}
});
Ext.define('Ext.data.reader.Xml', {
extend: 'Ext.data.reader.Reader',
alternateClassName: 'Ext.data.XmlReader',
alias : 'reader.xml',
createAccessor: function(expr) {
var me = this;
if (Ext.isEmpty(expr)) {
return Ext.emptyFn;
}
if (Ext.isFunction(expr)) {
return expr;
}
return function(root) {
return me.getNodeValue(Ext.DomQuery.selectNode(expr, root));
};
},
getNodeValue: function(node) {
if (node && node.firstChild) {
return node.firstChild.nodeValue;
}
return undefined;
},
getResponseData: function(response) {
var xml = response.responseXML;
return xml;
},
getData: function(data) {
return data.documentElement || data;
},
getRoot: function(data) {
var nodeName = data.nodeName,
root = this.root;
if (!root || (nodeName && nodeName == root)) {
return data;
} else if (Ext.DomQuery.isXml(data)) {
return Ext.DomQuery.selectNode(root, data);
}
},
extractData: function(root) {
var recordName = this.record;
if (recordName != root.nodeName) {
root = Ext.DomQuery.select(recordName, root);
} else {
root = [root];
}
return this.callParent([root]);
},
getAssociatedDataRoot: function(data, associationName) {
return Ext.DomQuery.select(associationName, data)[0];
},
readRecords: function(doc) {
if (Ext.isArray(doc)) {
doc = doc[0];
}
this.xmlData = doc;
return this.callParent([doc]);
}
});
Ext.define('Ext.data.writer.Xml', {
extend: 'Ext.data.writer.Writer',
alternateClassName: 'Ext.data.XmlWriter',
alias: 'writer.xml',
documentRoot: 'xmlData',
defaultDocumentRoot: 'xmlData',
header: '',
record: 'record',
writeRecords: function(request, data) {
var me = this,
xml = [],
i = 0,
len = data.length,
root = me.documentRoot,
record = me.record,
needsRoot = data.length !== 1,
item,
key;
xml.push(me.header || '');
if (!root && needsRoot) {
root = me.defaultDocumentRoot;
}
if (root) {
xml.push('<', root, '>');
}
for (; i < len; ++i) {
item = data[i];
xml.push('<', record, '>');
for (key in item) {
if (item.hasOwnProperty(key)) {
xml.push('<', key, '>', item[key], '');
}
}
xml.push('');
}
if (root) {
xml.push('');
}
request.xmlData = xml.join('');
return request;
}
});
Ext.define('Ext.direct.Event', {
alias: 'direct.event',
requires: ['Ext.direct.Manager'],
status: true,
constructor: function(config) {
Ext.apply(this, config);
},
getData: function(){
return this.data;
}
});
Ext.define('Ext.direct.RemotingEvent', {
extend: 'Ext.direct.Event',
alias: 'direct.rpc',
getTransaction: function(){
return this.transaction || Ext.direct.Manager.getTransaction(this.tid);
}
});
Ext.define('Ext.direct.ExceptionEvent', {
extend: 'Ext.direct.RemotingEvent',
alias: 'direct.exception',
status: false
});
Ext.define('Ext.direct.Provider', {
alias: 'direct.provider',
mixins: {
observable: 'Ext.util.Observable'
},
constructor : function(config){
var me = this;
Ext.apply(me, config);
me.addEvents(
'connect',
'disconnect',
'data',
'exception'
);
me.mixins.observable.constructor.call(me, config);
},
isConnected: function(){
return false;
},
connect: Ext.emptyFn,
disconnect: Ext.emptyFn
});
Ext.define('Ext.direct.JsonProvider', {
extend: 'Ext.direct.Provider',
alias: 'direct.jsonprovider',
uses: ['Ext.direct.ExceptionEvent'],
parseResponse: function(response){
if (!Ext.isEmpty(response.responseText)) {
if (Ext.isObject(response.responseText)) {
return response.responseText;
}
return Ext.decode(response.responseText);
}
return null;
},
createEvents: function(response){
var data = null,
events = [],
event,
i = 0,
len;
try{
data = this.parseResponse(response);
} catch(e) {
event = Ext.create('Ext.direct.ExceptionEvent', {
data: e,
xhr: response,
code: Ext.direct.Manager.self.exceptions.PARSE,
message: 'Error parsing json response: \n\n ' + data
});
return [event];
}
if (Ext.isArray(data)) {
for (len = data.length; i < len; ++i) {
events.push(this.createEvent(data[i]));
}
} else {
events.push(this.createEvent(data));
}
return events;
},
createEvent: function(response){
return Ext.create('direct.' + response.type, response);
}
});
Ext.define('Ext.direct.PollingProvider', {
extend: 'Ext.direct.JsonProvider',
alias: 'direct.pollingprovider',
uses: ['Ext.direct.ExceptionEvent'],
requires: ['Ext.Ajax', 'Ext.util.DelayedTask'],
interval: 3000,
constructor : function(config){
this.callParent(arguments);
this.addEvents(
'beforepoll',
'poll'
);
},
isConnected: function(){
return !!this.pollTask;
},
connect: function(){
var me = this, url = me.url;
if (url && !me.pollTask) {
me.pollTask = Ext.TaskManager.start({
run: function(){
if (me.fireEvent('beforepoll', me) !== false) {
if (Ext.isFunction(url)) {
url(me.baseParams);
} else {
Ext.Ajax.request({
url: url,
callback: me.onData,
scope: me,
params: me.baseParams
});
}
}
},
interval: me.interval,
scope: me
});
me.fireEvent('connect', me);
} else if (!url) {
}
},
disconnect: function(){
var me = this;
if (me.pollTask) {
Ext.TaskManager.stop(me.pollTask);
delete me.pollTask;
me.fireEvent('disconnect', me);
}
},
onData: function(opt, success, response){
var me = this,
i = 0,
len,
events;
if (success) {
events = me.createEvents(response);
for (len = events.length; i < len; ++i) {
me.fireEvent('data', me, events[i]);
}
} else {
me.fireEvent('data', me, Ext.create('Ext.direct.ExceptionEvent', {
data: null,
code: Ext.direct.Manager.self.exceptions.TRANSPORT,
message: 'Unable to connect to the server.',
xhr: response
}));
}
}
});
Ext.define('Ext.direct.RemotingMethod', {
constructor: function(config){
var me = this,
params = Ext.isDefined(config.params) ? config.params : config.len,
name;
me.name = config.name;
me.formHandler = config.formHandler;
if (Ext.isNumber(params)) {
me.len = params;
me.ordered = true;
} else {
me.params = [];
Ext.each(params, function(param){
name = Ext.isObject(param) ? param.name : param;
me.params.push(name);
});
}
},
getCallData: function(args){
var me = this,
data = null,
len = me.len,
params = me.params,
callback,
scope,
name;
if (me.ordered) {
callback = args[len];
scope = args[len + 1];
if (len !== 0) {
data = args.slice(0, len);
}
} else {
data = Ext.apply({}, args[0]);
callback = args[1];
scope = args[2];
for (name in data) {
if (data.hasOwnProperty(name)) {
if (!Ext.Array.contains(params, name)) {
delete data[name];
}
}
}
}
return {
data: data,
callback: callback,
scope: scope
};
}
});
Ext.define('Ext.direct.Transaction', {
alias: 'direct.transaction',
alternateClassName: 'Ext.Direct.Transaction',
statics: {
TRANSACTION_ID: 0
},
constructor: function(config){
var me = this;
Ext.apply(me, config);
me.id = ++me.self.TRANSACTION_ID;
me.retryCount = 0;
},
send: function(){
this.provider.queueTransaction(this);
},
retry: function(){
this.retryCount++;
this.send();
},
getProvider: function(){
return this.provider;
}
});
Ext.define('Ext.direct.RemotingProvider', {
alias: 'direct.remotingprovider',
extend: 'Ext.direct.JsonProvider',
requires: [
'Ext.util.MixedCollection',
'Ext.util.DelayedTask',
'Ext.direct.Transaction',
'Ext.direct.RemotingMethod'
],
enableBuffer: 10,
maxRetries: 1,
timeout: undefined,
constructor : function(config){
var me = this;
me.callParent(arguments);
me.addEvents(
'beforecall',
'call'
);
me.namespace = (Ext.isString(me.namespace)) ? Ext.ns(me.namespace) : me.namespace || window;
me.transactions = Ext.create('Ext.util.MixedCollection');
me.callBuffer = [];
},
initAPI : function(){
var actions = this.actions,
namespace = this.namespace,
action,
cls,
methods,
i,
len,
method;
for (action in actions) {
cls = namespace[action];
if (!cls) {
cls = namespace[action] = {};
}
methods = actions[action];
for (i = 0, len = methods.length; i < len; ++i) {
method = Ext.create('Ext.direct.RemotingMethod', methods[i]);
cls[method.name] = this.createHandler(action, method);
}
}
},
createHandler : function(action, method){
var me = this,
handler;
if (!method.formHandler) {
handler = function(){
me.configureRequest(action, method, Array.prototype.slice.call(arguments, 0));
};
} else {
handler = function(form, callback, scope){
me.configureFormRequest(action, method, form, callback, scope);
};
}
handler.directCfg = {
action: action,
method: method
};
return handler;
},
isConnected: function(){
return !!this.connected;
},
connect: function(){
var me = this;
if (me.url) {
me.initAPI();
me.connected = true;
me.fireEvent('connect', me);
} else if(!me.url) {
}
},
disconnect: function(){
var me = this;
if (me.connected) {
me.connected = false;
me.fireEvent('disconnect', me);
}
},
runCallback: function(transaction, event){
var funcName = event.status ? 'success' : 'failure',
callback,
result;
if (transaction && transaction.callback) {
callback = transaction.callback;
result = Ext.isDefined(event.result) ? event.result : event.data;
if (Ext.isFunction(callback)) {
callback(result, event);
} else {
Ext.callback(callback[funcName], callback.scope, [result, event]);
Ext.callback(callback.callback, callback.scope, [result, event]);
}
}
},
onData: function(options, success, response){
var me = this,
i = 0,
len,
events,
event,
transaction,
transactions;
if (success) {
events = me.createEvents(response);
for (len = events.length; i < len; ++i) {
event = events[i];
transaction = me.getTransaction(event);
me.fireEvent('data', me, event);
if (transaction) {
me.runCallback(transaction, event, true);
Ext.direct.Manager.removeTransaction(transaction);
}
}
} else {
transactions = [].concat(options.transaction);
for (len = transactions.length; i < len; ++i) {
transaction = me.getTransaction(transactions[i]);
if (transaction && transaction.retryCount < me.maxRetries) {
transaction.retry();
} else {
event = Ext.create('Ext.direct.ExceptionEvent', {
data: null,
transaction: transaction,
code: Ext.direct.Manager.self.exceptions.TRANSPORT,
message: 'Unable to connect to the server.',
xhr: response
});
me.fireEvent('data', me, event);
if (transaction) {
me.runCallback(transaction, event, false);
Ext.direct.Manager.removeTransaction(transaction);
}
}
}
}
},
getTransaction: function(options){
return options && options.tid ? Ext.direct.Manager.getTransaction(options.tid) : null;
},
configureRequest: function(action, method, args){
var me = this,
callData = method.getCallData(args),
data = callData.data,
callback = callData.callback,
scope = callData.scope,
transaction;
transaction = Ext.create('Ext.direct.Transaction', {
provider: me,
args: args,
action: action,
method: method.name,
data: data,
callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback
});
if (me.fireEvent('beforecall', me, transaction, method) !== false) {
Ext.direct.Manager.addTransaction(transaction);
me.queueTransaction(transaction);
me.fireEvent('call', me, transaction, method);
}
},
getCallData: function(transaction){
return {
action: transaction.action,
method: transaction.method,
data: transaction.data,
type: 'rpc',
tid: transaction.id
};
},
sendRequest : function(data){
var me = this,
request = {
url: me.url,
callback: me.onData,
scope: me,
transaction: data,
timeout: me.timeout
}, callData,
enableUrlEncode = me.enableUrlEncode,
i = 0,
len,
params;
if (Ext.isArray(data)) {
callData = [];
for (len = data.length; i < len; ++i) {
callData.push(me.getCallData(data[i]));
}
} else {
callData = me.getCallData(data);
}
if (enableUrlEncode) {
params = {};
params[Ext.isString(enableUrlEncode) ? enableUrlEncode : 'data'] = Ext.encode(callData);
request.params = params;
} else {
request.jsonData = callData;
}
Ext.Ajax.request(request);
},
queueTransaction: function(transaction){
var me = this,
enableBuffer = me.enableBuffer;
if (transaction.form) {
me.sendFormRequest(transaction);
return;
}
me.callBuffer.push(transaction);
if (enableBuffer) {
if (!me.callTask) {
me.callTask = Ext.create('Ext.util.DelayedTask', me.combineAndSend, me);
}
me.callTask.delay(Ext.isNumber(enableBuffer) ? enableBuffer : 10);
} else {
me.combineAndSend();
}
},
combineAndSend : function(){
var buffer = this.callBuffer,
len = buffer.length;
if (len > 0) {
this.sendRequest(len == 1 ? buffer[0] : buffer);
this.callBuffer = [];
}
},
configureFormRequest : function(action, method, form, callback, scope){
var me = this,
transaction = Ext.create('Ext.direct.Transaction', {
provider: me,
action: action,
method: method.name,
args: [form, callback, scope],
callback: scope && Ext.isFunction(callback) ? Ext.Function.bind(callback, scope) : callback,
isForm: true
}),
isUpload,
params;
if (me.fireEvent('beforecall', me, transaction, method) !== false) {
Ext.direct.Manager.addTransaction(transaction);
isUpload = String(form.getAttribute("enctype")).toLowerCase() == 'multipart/form-data';
params = {
extTID: transaction.id,
extAction: action,
extMethod: method.name,
extType: 'rpc',
extUpload: String(isUpload)
};
Ext.apply(transaction, {
form: Ext.getDom(form),
isUpload: isUpload,
params: callback && Ext.isObject(callback.params) ? Ext.apply(params, callback.params) : params
});
me.fireEvent('call', me, transaction, method);
me.sendFormRequest(transaction);
}
},
sendFormRequest: function(transaction){
Ext.Ajax.request({
url: this.url,
params: transaction.params,
callback: this.onData,
scope: this,
form: transaction.form,
isUpload: transaction.isUpload,
transaction: transaction
});
}
});
Ext.define('Ext.draw.Matrix', {
requires: ['Ext.draw.Draw'],
constructor: function(a, b, c, d, e, f) {
if (a != null) {
this.matrix = [[a, c, e], [b, d, f], [0, 0, 1]];
}
else {
this.matrix = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
}
},
add: function(a, b, c, d, e, f) {
var me = this,
out = [[], [], []],
matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
x,
y,
z,
res;
for (x = 0; x < 3; x++) {
for (y = 0; y < 3; y++) {
res = 0;
for (z = 0; z < 3; z++) {
res += me.matrix[x][z] * matrix[z][y];
}
out[x][y] = res;
}
}
me.matrix = out;
},
prepend: function(a, b, c, d, e, f) {
var me = this,
out = [[], [], []],
matrix = [[a, c, e], [b, d, f], [0, 0, 1]],
x,
y,
z,
res;
for (x = 0; x < 3; x++) {
for (y = 0; y < 3; y++) {
res = 0;
for (z = 0; z < 3; z++) {
res += matrix[x][z] * me.matrix[z][y];
}
out[x][y] = res;
}
}
me.matrix = out;
},
invert: function() {
var matrix = this.matrix,
a = matrix[0][0],
b = matrix[1][0],
c = matrix[0][1],
d = matrix[1][1],
e = matrix[0][2],
f = matrix[1][2],
x = a * d - b * c;
return new Ext.draw.Matrix(d / x, -b / x, -c / x, a / x, (c * f - d * e) / x, (b * e - a * f) / x);
},
clone: function() {
var matrix = this.matrix,
a = matrix[0][0],
b = matrix[1][0],
c = matrix[0][1],
d = matrix[1][1],
e = matrix[0][2],
f = matrix[1][2];
return new Ext.draw.Matrix(a, b, c, d, e, f);
},
translate: function(x, y) {
this.prepend(1, 0, 0, 1, x, y);
},
scale: function(x, y, cx, cy) {
var me = this;
if (y == null) {
y = x;
}
me.add(1, 0, 0, 1, cx, cy);
me.add(x, 0, 0, y, 0, 0);
me.add(1, 0, 0, 1, -cx, -cy);
},
rotate: function(a, x, y) {
a = Ext.draw.Draw.rad(a);
var me = this,
cos = +Math.cos(a).toFixed(9),
sin = +Math.sin(a).toFixed(9);
me.add(cos, sin, -sin, cos, x, y);
me.add(1, 0, 0, 1, -x, -y);
},
x: function(x, y) {
var matrix = this.matrix;
return x * matrix[0][0] + y * matrix[0][1] + matrix[0][2];
},
y: function(x, y) {
var matrix = this.matrix;
return x * matrix[1][0] + y * matrix[1][1] + matrix[1][2];
},
get: function(i, j) {
return + this.matrix[i][j].toFixed(4);
},
toString: function() {
var me = this;
return [me.get(0, 0), me.get(0, 1), me.get(1, 0), me.get(1, 1), 0, 0].join();
},
toSvg: function() {
var me = this;
return "matrix(" + [me.get(0, 0), me.get(1, 0), me.get(0, 1), me.get(1, 1), me.get(0, 2), me.get(1, 2)].join() + ")";
},
toFilter: function() {
var me = this;
return "progid:DXImageTransform.Microsoft.Matrix(M11=" + me.get(0, 0) +
", M12=" + me.get(0, 1) + ", M21=" + me.get(1, 0) + ", M22=" + me.get(1, 1) +
", Dx=" + me.get(0, 2) + ", Dy=" + me.get(1, 2) + ")";
},
offset: function() {
var matrix = this.matrix;
return [matrix[0][2].toFixed(4), matrix[1][2].toFixed(4)];
},
split: function () {
function norm(a) {
return a[0] * a[0] + a[1] * a[1];
}
function normalize(a) {
var mag = Math.sqrt(norm(a));
a[0] /= mag;
a[1] /= mag;
}
var matrix = this.matrix,
out = {
translateX: matrix[0][2],
translateY: matrix[1][2]
},
row;
row = [[matrix[0][0], matrix[0][1]], [matrix[1][1], matrix[1][1]]];
out.scaleX = Math.sqrt(norm(row[0]));
normalize(row[0]);
out.shear = row[0][0] * row[1][0] + row[0][1] * row[1][1];
row[1] = [row[1][0] - row[0][0] * out.shear, row[1][1] - row[0][1] * out.shear];
out.scaleY = Math.sqrt(norm(row[1]));
normalize(row[1]);
out.shear /= out.scaleY;
out.rotate = Math.asin(-row[0][1]);
out.isSimple = !+out.shear.toFixed(9) && (out.scaleX.toFixed(9) == out.scaleY.toFixed(9) || !out.rotate);
return out;
}
});
Ext.define('Ext.draw.SpriteDD', {
extend: 'Ext.dd.DragSource',
constructor : function(sprite, cfg){
var me = this,
el = sprite.el;
me.sprite = sprite;
me.el = el;
me.dragData = {el: el, sprite: sprite};
me.callParent([el, cfg]);
me.sprite.setStyle('cursor', 'move');
},
showFrame: Ext.emptyFn,
createFrame : Ext.emptyFn,
getDragEl : function(e){
return this.el;
},
getRegion: function() {
var me = this,
el = me.el,
pos, x1, x2, y1, y2, t, r, b, l, bbox, sprite;
sprite = me.sprite;
bbox = sprite.getBBox();
try {
pos = Ext.core.Element.getXY(el);
} catch (e) { }
if (!pos) {
return null;
}
x1 = pos[0];
x2 = x1 + bbox.width;
y1 = pos[1];
y2 = y1 + bbox.height;
return Ext.create('Ext.util.Region', y1, x2, y2, x1);
},
startDrag: function(x, y) {
var me = this,
attr = me.sprite.attr,
trans = attr.translation;
if (me.sprite.vml) {
me.prevX = x + attr.x;
me.prevY = y + attr.y;
} else {
me.prevX = x - trans.x;
me.prevY = y - trans.y;
}
},
onDrag: function(e) {
var xy = e.getXY(),
me = this,
sprite = me.sprite,
attr = sprite.attr;
me.translateX = xy[0] - me.prevX;
me.translateY = xy[1] - me.prevY;
sprite.setAttributes({
translate: {
x: me.translateX,
y: me.translateY
}
}, true);
if (sprite.vml) {
me.prevX = xy[0] + attr.x || 0;
me.prevY = xy[1] + attr.y || 0;
}
}
});
Ext.define('Ext.draw.Sprite', {
mixins: {
observable: 'Ext.util.Observable',
animate: 'Ext.util.Animate'
},
requires: ['Ext.draw.SpriteDD'],
dirty: false,
dirtyHidden: false,
dirtyTransform: false,
dirtyPath: true,
dirtyFont: true,
zIndexDirty: true,
isSprite: true,
zIndex: 0,
fontProperties: [
'font',
'font-size',
'font-weight',
'font-style',
'font-family',
'text-anchor',
'text'
],
pathProperties: [
'x',
'y',
'd',
'path',
'height',
'width',
'radius',
'r',
'rx',
'ry',
'cx',
'cy'
],
constructor: function(config) {
var me = this;
config = config || {};
me.id = Ext.id(null, 'ext-sprite-');
me.transformations = [];
Ext.copyTo(this, config, 'surface,group,type,draggable');
me.bbox = {};
me.attr = {
zIndex: 0,
translation: {
x: null,
y: null
},
rotation: {
degrees: null,
x: null,
y: null
},
scaling: {
x: null,
y: null,
cx: null,
cy: null
}
};
delete config.surface;
delete config.group;
delete config.type;
delete config.draggable;
me.setAttributes(config);
me.addEvents(
'beforedestroy',
'destroy',
'render',
'mousedown',
'mouseup',
'mouseover',
'mouseout',
'mousemove',
'click'
);
me.mixins.observable.constructor.apply(this, arguments);
},
initDraggable: function() {
var me = this;
me.draggable = true;
if (!me.el) {
me.surface.createSpriteElement(me);
}
me.dd = Ext.create('Ext.draw.SpriteDD', me, Ext.isBoolean(me.draggable) ? null : me.draggable);
me.on('beforedestroy', me.dd.destroy, me.dd);
},
setAttributes: function(attrs, redraw) {
var me = this,
fontProps = me.fontProperties,
fontPropsLength = fontProps.length,
pathProps = me.pathProperties,
pathPropsLength = pathProps.length,
hasSurface = !!me.surface,
custom = hasSurface && me.surface.customAttributes || {},
spriteAttrs = me.attr,
attr, i, translate, translation, rotate, rotation, scale, scaling;
attrs = Ext.apply({}, attrs);
for (attr in custom) {
if (attrs.hasOwnProperty(attr) && typeof custom[attr] == "function") {
Ext.apply(attrs, custom[attr].apply(me, [].concat(attrs[attr])));
}
}
if (!!attrs.hidden !== !!spriteAttrs.hidden) {
me.dirtyHidden = true;
}
for (i = 0; i < pathPropsLength; i++) {
attr = pathProps[i];
if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
me.dirtyPath = true;
break;
}
}
if ('zIndex' in attrs) {
me.zIndexDirty = true;
}
for (i = 0; i < fontPropsLength; i++) {
attr = fontProps[i];
if (attr in attrs && attrs[attr] !== spriteAttrs[attr]) {
me.dirtyFont = true;
break;
}
}
translate = attrs.translate;
translation = spriteAttrs.translation;
if (translate) {
if ((translate.x && translate.x !== translation.x) ||
(translate.y && translate.y !== translation.y)) {
Ext.apply(translation, translate);
me.dirtyTransform = true;
}
delete attrs.translate;
}
rotate = attrs.rotate;
rotation = spriteAttrs.rotation;
if (rotate) {
if ((rotate.x && rotate.x !== rotation.x) ||
(rotate.y && rotate.y !== rotation.y) ||
(rotate.degrees && rotate.degrees !== rotation.degrees)) {
Ext.apply(rotation, rotate);
me.dirtyTransform = true;
}
delete attrs.rotate;
}
scale = attrs.scale;
scaling = spriteAttrs.scaling;
if (scale) {
if ((scale.x && scale.x !== scaling.x) ||
(scale.y && scale.y !== scaling.y) ||
(scale.cx && scale.cx !== scaling.cx) ||
(scale.cy && scale.cy !== scaling.cy)) {
Ext.apply(scaling, scale);
me.dirtyTransform = true;
}
delete attrs.scale;
}
Ext.apply(spriteAttrs, attrs);
me.dirty = true;
if (redraw === true && hasSurface) {
me.redraw();
}
return this;
},
getBBox: function() {
return this.surface.getBBox(this);
},
setText: function(text) {
return this.surface.setText(this, text);
},
hide: function(redraw) {
this.setAttributes({
hidden: true
}, redraw);
return this;
},
show: function(redraw) {
this.setAttributes({
hidden: false
}, redraw);
return this;
},
remove: function() {
if (this.surface) {
this.surface.remove(this);
return true;
}
return false;
},
onRemove: function() {
this.surface.onRemove(this);
},
destroy: function() {
var me = this;
if (me.fireEvent('beforedestroy', me) !== false) {
me.remove();
me.surface.onDestroy(me);
me.clearListeners();
me.fireEvent('destroy');
}
},
redraw: function() {
this.surface.renderItem(this);
return this;
},
setStyle: function() {
this.el.setStyle.apply(this.el, arguments);
return this;
},
addCls: function(obj) {
this.surface.addCls(this, obj);
return this;
},
removeCls: function(obj) {
this.surface.removeCls(this, obj);
return this;
}
});
Ext.define('Ext.draw.engine.Svg', {
extend: 'Ext.draw.Surface',
requires: ['Ext.draw.Draw', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.core.Element'],
engine: 'Svg',
trimRe: /^\s+|\s+$/g,
spacesRe: /\s+/,
xlink: "http:/" + "/www.w3.org/1999/xlink",
translateAttrs: {
radius: "r",
radiusX: "rx",
radiusY: "ry",
path: "d",
lineWidth: "stroke-width",
fillOpacity: "fill-opacity",
strokeOpacity: "stroke-opacity",
strokeLinejoin: "stroke-linejoin"
},
parsers: {},
minDefaults: {
circle: {
cx: 0,
cy: 0,
r: 0,
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
ellipse: {
cx: 0,
cy: 0,
rx: 0,
ry: 0,
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
rect: {
x: 0,
y: 0,
width: 0,
height: 0,
rx: 0,
ry: 0,
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
text: {
x: 0,
y: 0,
"text-anchor": "start",
"font-family": null,
"font-size": null,
"font-weight": null,
"font-style": null,
fill: "#000",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
path: {
d: "M0,0",
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
image: {
x: 0,
y: 0,
width: 0,
height: 0,
preserveAspectRatio: "none",
opacity: null
}
},
createSvgElement: function(type, attrs) {
var el = this.domRef.createElementNS("http:/" + "/www.w3.org/2000/svg", type),
key;
if (attrs) {
for (key in attrs) {
el.setAttribute(key, String(attrs[key]));
}
}
return el;
},
createSpriteElement: function(sprite) {
var el = this.createSvgElement(sprite.type);
el.id = sprite.id;
if (el.style) {
el.style.webkitTapHighlightColor = "rgba(0,0,0,0)";
}
sprite.el = Ext.get(el);
this.applyZIndex(sprite);
sprite.matrix = Ext.create('Ext.draw.Matrix');
sprite.bbox = {
plain: 0,
transform: 0
};
sprite.fireEvent("render", sprite);
return el;
},
getBBox: function (sprite, isWithoutTransform) {
var realPath = this["getPath" + sprite.type](sprite);
if (isWithoutTransform) {
sprite.bbox.plain = sprite.bbox.plain || Ext.draw.Draw.pathDimensions(realPath);
return sprite.bbox.plain;
}
sprite.bbox.transform = sprite.bbox.transform || Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(realPath, sprite.matrix));
return sprite.bbox.transform;
},
getBBoxText: function (sprite) {
var bbox = {},
bb, height, width, i, ln, el;
if (sprite && sprite.el) {
el = sprite.el.dom;
try {
bbox = el.getBBox();
return bbox;
} catch(e) {
}
bbox = {x: bbox.x, y: Infinity, width: 0, height: 0};
ln = el.getNumberOfChars();
for (i = 0; i < ln; i++) {
bb = el.getExtentOfChar(i);
bbox.y = Math.min(bb.y, bbox.y);
height = bb.y + bb.height - bbox.y;
bbox.height = Math.max(bbox.height, height);
width = bb.x + bb.width - bbox.x;
bbox.width = Math.max(bbox.width, width);
}
return bbox;
}
},
hide: function() {
Ext.get(this.el).hide();
},
show: function() {
Ext.get(this.el).show();
},
hidePrim: function(sprite) {
this.addCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
},
showPrim: function(sprite) {
this.removeCls(sprite, Ext.baseCSSPrefix + 'hide-visibility');
},
getDefs: function() {
return this._defs || (this._defs = this.createSvgElement("defs"));
},
transform: function(sprite) {
var me = this,
matrix = Ext.create('Ext.draw.Matrix'),
transforms = sprite.transformations,
transformsLength = transforms.length,
i = 0,
transform, type;
for (; i < transformsLength; i++) {
transform = transforms[i];
type = transform.type;
if (type == "translate") {
matrix.translate(transform.x, transform.y);
}
else if (type == "rotate") {
matrix.rotate(transform.degrees, transform.x, transform.y);
}
else if (type == "scale") {
matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
}
}
sprite.matrix = matrix;
sprite.el.set({transform: matrix.toSvg()});
},
setSize: function(w, h) {
var me = this,
el = me.el;
w = +w || me.width;
h = +h || me.height;
me.width = w;
me.height = h;
el.setSize(w, h);
el.set({
width: w,
height: h
});
me.callParent([w, h]);
},
getRegion: function() {
var svgXY = this.el.getXY(),
rectXY = this.bgRect.getXY(),
max = Math.max,
x = max(svgXY[0], rectXY[0]),
y = max(svgXY[1], rectXY[1]);
return {
left: x,
top: y,
right: x + this.width,
bottom: y + this.height
};
},
onRemove: function(sprite) {
if (sprite.el) {
sprite.el.remove();
delete sprite.el;
}
this.callParent(arguments);
},
setViewBox: function(x, y, width, height) {
if (isFinite(x) && isFinite(y) && isFinite(width) && isFinite(height)) {
this.callParent(arguments);
this.el.dom.setAttribute("viewBox", [x, y, width, height].join(" "));
}
},
render: function (container) {
var me = this;
if (!me.el) {
var width = me.width || 10,
height = me.height || 10,
el = me.createSvgElement('svg', {
xmlns: "http:/" + "/www.w3.org/2000/svg",
version: 1.1,
width: width,
height: height
}),
defs = me.getDefs(),
bgRect = me.createSvgElement("rect", {
width: "100%",
height: "100%",
fill: "#000",
stroke: "none",
opacity: 0
}),
webkitRect;
if (Ext.isSafari3) {
webkitRect = me.createSvgElement("rect", {
x: -10,
y: -10,
width: "110%",
height: "110%",
fill: "none",
stroke: "#000"
});
}
el.appendChild(defs);
if (Ext.isSafari3) {
el.appendChild(webkitRect);
}
el.appendChild(bgRect);
container.appendChild(el);
me.el = Ext.get(el);
me.bgRect = Ext.get(bgRect);
if (Ext.isSafari3) {
me.webkitRect = Ext.get(webkitRect);
me.webkitRect.hide();
}
me.el.on({
scope: me,
mouseup: me.onMouseUp,
mousedown: me.onMouseDown,
mouseover: me.onMouseOver,
mouseout: me.onMouseOut,
mousemove: me.onMouseMove,
mouseenter: me.onMouseEnter,
mouseleave: me.onMouseLeave,
click: me.onClick
});
}
me.renderAll();
},
onMouseEnter: function(e) {
if (this.el.parent().getRegion().contains(e.getPoint())) {
this.fireEvent('mouseenter', e);
}
},
onMouseLeave: function(e) {
if (!this.el.parent().getRegion().contains(e.getPoint())) {
this.fireEvent('mouseleave', e);
}
},
processEvent: function(name, e) {
var target = e.getTarget(),
surface = this.surface,
sprite;
this.fireEvent(name, e);
if (target.nodeName == "tspan" && target.parentNode) {
target = target.parentNode;
}
sprite = this.items.get(target.id);
if (sprite) {
sprite.fireEvent(name, sprite, e);
}
},
tuneText: function (sprite, attrs) {
var el = sprite.el.dom,
tspans = [],
height, tspan, text, i, ln, texts, factor;
if (attrs.hasOwnProperty("text")) {
tspans = this.setText(sprite, attrs.text);
}
if (tspans.length) {
height = this.getBBoxText(sprite).height;
for (i = 0, ln = tspans.length; i < ln; i++) {
factor = (Ext.isFF3_0 || Ext.isFF3_5) ? 2 : 4;
tspans[i].setAttribute("dy", i ? height * 1.2 : height / factor);
}
sprite.dirty = true;
}
},
setText: function(sprite, textString) {
var me = this,
el = sprite.el.dom,
x = el.getAttribute("x"),
tspans = [],
height, tspan, text, i, ln, texts;
while (el.firstChild) {
el.removeChild(el.firstChild);
}
texts = String(textString).split("\n");
for (i = 0, ln = texts.length; i < ln; i++) {
text = texts[i];
if (text) {
tspan = me.createSvgElement("tspan");
tspan.appendChild(document.createTextNode(Ext.htmlDecode(text)));
tspan.setAttribute("x", x);
el.appendChild(tspan);
tspans[i] = tspan;
}
}
return tspans;
},
renderAll: function() {
this.items.each(this.renderItem, this);
},
renderItem: function (sprite) {
if (!this.el) {
return;
}
if (!sprite.el) {
this.createSpriteElement(sprite);
}
if (sprite.zIndexDirty) {
this.applyZIndex(sprite);
}
if (sprite.dirty) {
this.applyAttrs(sprite);
this.applyTransformations(sprite);
}
},
redraw: function(sprite) {
sprite.dirty = sprite.zIndexDirty = true;
this.renderItem(sprite);
},
applyAttrs: function (sprite) {
var me = this,
el = sprite.el,
group = sprite.group,
sattr = sprite.attr,
parsers = me.parsers,
gradientsMap = me.gradientsMap || {},
safariFix = Ext.isSafari && !Ext.isStrict,
groups, i, ln, attrs, font, key, style, name, rect;
if (group) {
groups = [].concat(group);
ln = groups.length;
for (i = 0; i < ln; i++) {
group = groups[i];
me.getGroup(group).add(sprite);
}
delete sprite.group;
}
attrs = me.scrubAttrs(sprite) || {};
sprite.bbox.plain = 0;
sprite.bbox.transform = 0;
if (sprite.type == "circle" || sprite.type == "ellipse") {
attrs.cx = attrs.cx || attrs.x;
attrs.cy = attrs.cy || attrs.y;
}
else if (sprite.type == "rect") {
attrs.rx = attrs.ry = attrs.r;
}
else if (sprite.type == "path" && attrs.d) {
attrs.d = Ext.draw.Draw.pathToString(Ext.draw.Draw.pathToAbsolute(attrs.d));
}
sprite.dirtyPath = false;
if (attrs['clip-rect']) {
me.setClip(sprite, attrs);
delete attrs['clip-rect'];
}
if (sprite.type == 'text' && attrs.font && sprite.dirtyFont) {
el.set({ style: "font: " + attrs.font});
sprite.dirtyFont = false;
}
if (sprite.type == "image") {
el.dom.setAttributeNS(me.xlink, "href", attrs.src);
}
Ext.applyIf(attrs, me.minDefaults[sprite.type]);
if (sprite.dirtyHidden) {
(sattr.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
sprite.dirtyHidden = false;
}
for (key in attrs) {
if (attrs.hasOwnProperty(key) && attrs[key] != null) {
if (safariFix && ('color|stroke|fill'.indexOf(key) > -1) && (attrs[key] in gradientsMap)) {
attrs[key] = gradientsMap[attrs[key]];
}
if (key in parsers) {
el.dom.setAttribute(key, parsers[key](attrs[key], sprite, me));
} else {
el.dom.setAttribute(key, attrs[key]);
}
}
}
if (sprite.type == 'text') {
me.tuneText(sprite, attrs);
}
style = sattr.style;
if (style) {
el.setStyle(style);
}
sprite.dirty = false;
if (Ext.isSafari3) {
me.webkitRect.show();
setTimeout(function () {
me.webkitRect.hide();
});
}
},
setClip: function(sprite, params) {
var me = this,
rect = params["clip-rect"],
clipEl, clipPath;
if (rect) {
if (sprite.clip) {
sprite.clip.parentNode.parentNode.removeChild(sprite.clip.parentNode);
}
clipEl = me.createSvgElement('clipPath');
clipPath = me.createSvgElement('rect');
clipEl.id = Ext.id(null, 'ext-clip-');
clipPath.setAttribute("x", rect.x);
clipPath.setAttribute("y", rect.y);
clipPath.setAttribute("width", rect.width);
clipPath.setAttribute("height", rect.height);
clipEl.appendChild(clipPath);
me.getDefs().appendChild(clipEl);
sprite.el.dom.setAttribute("clip-path", "url(#" + clipEl.id + ")");
sprite.clip = clipPath;
}
},
applyZIndex: function(sprite) {
var idx = this.normalizeSpriteCollection(sprite),
el = sprite.el,
prevEl;
if (this.el.dom.childNodes[idx + 2] !== el.dom) {
if (idx > 0) {
do {
prevEl = this.items.getAt(--idx).el;
} while (!prevEl && idx > 0);
}
el.insertAfter(prevEl || this.bgRect);
}
sprite.zIndexDirty = false;
},
createItem: function (config) {
var sprite = Ext.create('Ext.draw.Sprite', config);
sprite.surface = this;
return sprite;
},
addGradient: function(gradient) {
gradient = Ext.draw.Draw.parseGradient(gradient);
var me = this,
ln = gradient.stops.length,
vector = gradient.vector,
usePlain = Ext.isSafari && !Ext.isStrict,
gradientEl, stop, stopEl, i, gradientsMap;
gradientsMap = me.gradientsMap || {};
if (!usePlain) {
if (gradient.type == "linear") {
gradientEl = me.createSvgElement("linearGradient");
gradientEl.setAttribute("x1", vector[0]);
gradientEl.setAttribute("y1", vector[1]);
gradientEl.setAttribute("x2", vector[2]);
gradientEl.setAttribute("y2", vector[3]);
}
else {
gradientEl = me.createSvgElement("radialGradient");
gradientEl.setAttribute("cx", gradient.centerX);
gradientEl.setAttribute("cy", gradient.centerY);
gradientEl.setAttribute("r", gradient.radius);
if (Ext.isNumber(gradient.focalX) && Ext.isNumber(gradient.focalY)) {
gradientEl.setAttribute("fx", gradient.focalX);
gradientEl.setAttribute("fy", gradient.focalY);
}
}
gradientEl.id = gradient.id;
me.getDefs().appendChild(gradientEl);
for (i = 0; i < ln; i++) {
stop = gradient.stops[i];
stopEl = me.createSvgElement("stop");
stopEl.setAttribute("offset", stop.offset + "%");
stopEl.setAttribute("stop-color", stop.color);
stopEl.setAttribute("stop-opacity",stop.opacity);
gradientEl.appendChild(stopEl);
}
} else {
gradientsMap['url(#' + gradient.id + ')'] = gradient.stops[0].color;
}
me.gradientsMap = gradientsMap;
},
hasCls: function(sprite, className) {
return className && (' ' + (sprite.el.dom.getAttribute('class') || '') + ' ').indexOf(' ' + className + ' ') != -1;
},
addCls: function(sprite, className) {
var el = sprite.el,
i,
len,
v,
cls = [],
curCls = el.getAttribute('class') || '';
if (!Ext.isArray(className)) {
if (typeof className == 'string' && !this.hasCls(sprite, className)) {
el.set({ 'class': curCls + ' ' + className });
}
}
else {
for (i = 0, len = className.length; i < len; i++) {
v = className[i];
if (typeof v == 'string' && (' ' + curCls + ' ').indexOf(' ' + v + ' ') == -1) {
cls.push(v);
}
}
if (cls.length) {
el.set({ 'class': ' ' + cls.join(' ') });
}
}
},
removeCls: function(sprite, className) {
var me = this,
el = sprite.el,
curCls = el.getAttribute('class') || '',
i, idx, len, cls, elClasses;
if (!Ext.isArray(className)){
className = [className];
}
if (curCls) {
elClasses = curCls.replace(me.trimRe, ' ').split(me.spacesRe);
for (i = 0, len = className.length; i < len; i++) {
cls = className[i];
if (typeof cls == 'string') {
cls = cls.replace(me.trimRe, '');
idx = Ext.Array.indexOf(elClasses, cls);
if (idx != -1) {
Ext.Array.erase(elClasses, idx, 1);
}
}
}
el.set({ 'class': elClasses.join(' ') });
}
},
destroy: function() {
var me = this;
me.callParent();
if (me.el) {
me.el.remove();
}
delete me.el;
}
});
Ext.define('Ext.draw.engine.Vml', {
extend: 'Ext.draw.Surface',
requires: ['Ext.draw.Draw', 'Ext.draw.Color', 'Ext.draw.Sprite', 'Ext.draw.Matrix', 'Ext.core.Element'],
engine: 'Vml',
map: {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"},
bitesRe: /([clmz]),?([^clmz]*)/gi,
valRe: /-?[^,\s-]+/g,
fillUrlRe: /^url\(\s*['"]?([^\)]+?)['"]?\s*\)$/i,
pathlike: /^(path|rect)$/,
NonVmlPathRe: /[ahqstv]/ig, // Non-VML Pathing ops
partialPathRe: /[clmz]/g,
fontFamilyRe: /^['"]+|['"]+$/g,
baseVmlCls: Ext.baseCSSPrefix + 'vml-base',
vmlGroupCls: Ext.baseCSSPrefix + 'vml-group',
spriteCls: Ext.baseCSSPrefix + 'vml-sprite',
measureSpanCls: Ext.baseCSSPrefix + 'vml-measure-span',
zoom: 21600,
coordsize: 1000,
coordorigin: '0 0',
// @private
// Convert an SVG standard path into a VML path
path2vml: function (path) {
var me = this,
nonVML = me.NonVmlPathRe,
map = me.map,
val = me.valRe,
zoom = me.zoom,
bites = me.bitesRe,
command = Ext.Function.bind(Ext.draw.Draw.pathToAbsolute, Ext.draw.Draw),
res, pa, p, r, i, ii, j, jj;
if (String(path).match(nonVML)) {
command = Ext.Function.bind(Ext.draw.Draw.path2curve, Ext.draw.Draw);
} else if (!String(path).match(me.partialPathRe)) {
res = String(path).replace(bites, function (all, command, args) {
var vals = [],
isMove = command.toLowerCase() == "m",
res = map[command];
args.replace(val, function (value) {
if (isMove && vals[length] == 2) {
res += vals + map[command == "m" ? "l" : "L"];
vals = [];
}
vals.push(Math.round(value * zoom));
});
return res + vals;
});
return res;
}
pa = command(path);
res = [];
for (i = 0, ii = pa.length; i < ii; i++) {
p = pa[i];
r = pa[i][0].toLowerCase();
if (r == "z") {
r = "x";
}
for (j = 1, jj = p.length; j < jj; j++) {
r += Math.round(p[j] * me.zoom) + (j != jj - 1 ? "," : "");
}
res.push(r);
}
return res.join(" ");
},
// @private - set of attributes which need to be translated from the sprite API to the native browser API
translateAttrs: {
radius: "r",
radiusX: "rx",
radiusY: "ry",
lineWidth: "stroke-width",
fillOpacity: "fill-opacity",
strokeOpacity: "stroke-opacity",
strokeLinejoin: "stroke-linejoin"
},
// @private - Minimun set of defaults for different types of sprites.
minDefaults: {
circle: {
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
ellipse: {
cx: 0,
cy: 0,
rx: 0,
ry: 0,
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
rect: {
x: 0,
y: 0,
width: 0,
height: 0,
rx: 0,
ry: 0,
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
text: {
x: 0,
y: 0,
"text-anchor": "start",
font: '10px "Arial"',
fill: "#000",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
path: {
d: "M0,0",
fill: "none",
stroke: null,
"stroke-width": null,
opacity: null,
"fill-opacity": null,
"stroke-opacity": null
},
image: {
x: 0,
y: 0,
width: 0,
height: 0,
preserveAspectRatio: "none",
opacity: null
}
},
// private
onMouseEnter: function(e) {
this.fireEvent("mouseenter", e);
},
// private
onMouseLeave: function(e) {
this.fireEvent("mouseleave", e);
},
// @private - Normalize a delegated single event from the main container to each sprite and sprite group
processEvent: function(name, e) {
var target = e.getTarget(),
surface = this.surface,
sprite;
this.fireEvent(name, e);
sprite = this.items.get(target.id);
if (sprite) {
sprite.fireEvent(name, sprite, e);
}
},
// Create the VML element/elements and append them to the DOM
createSpriteElement: function(sprite) {
var me = this,
attr = sprite.attr,
type = sprite.type,
zoom = me.zoom,
vml = sprite.vml || (sprite.vml = {}),
round = Math.round,
el = (type === 'image') ? me.createNode('image') : me.createNode('shape'),
path, skew, textPath;
el.coordsize = zoom + ' ' + zoom;
el.coordorigin = attr.coordorigin || "0 0";
Ext.get(el).addCls(me.spriteCls);
if (type == "text") {
vml.path = path = me.createNode("path");
path.textpathok = true;
vml.textpath = textPath = me.createNode("textpath");
textPath.on = true;
el.appendChild(textPath);
el.appendChild(path);
}
el.id = sprite.id;
sprite.el = Ext.get(el);
me.el.appendChild(el);
if (type !== 'image') {
skew = me.createNode("skew");
skew.on = true;
el.appendChild(skew);
sprite.skew = skew;
}
sprite.matrix = Ext.create('Ext.draw.Matrix');
sprite.bbox = {
plain: null,
transform: null
};
sprite.fireEvent("render", sprite);
return sprite.el;
},
// @private - Get bounding box for the sprite. The Sprite itself has the public method.
getBBox: function (sprite, isWithoutTransform) {
var realPath = this["getPath" + sprite.type](sprite);
if (isWithoutTransform) {
sprite.bbox.plain = sprite.bbox.plain || Ext.draw.Draw.pathDimensions(realPath);
return sprite.bbox.plain;
}
sprite.bbox.transform = sprite.bbox.transform || Ext.draw.Draw.pathDimensions(Ext.draw.Draw.mapPath(realPath, sprite.matrix));
return sprite.bbox.transform;
},
getBBoxText: function (sprite) {
var vml = sprite.vml;
return {
x: vml.X + (vml.bbx || 0) - vml.W / 2,
y: vml.Y - vml.H / 2,
width: vml.W,
height: vml.H
};
},
applyAttrs: function (sprite) {
var me = this,
vml = sprite.vml,
group = sprite.group,
spriteAttr = sprite.attr,
el = sprite.el,
dom = el.dom,
style, name, groups, i, ln, scrubbedAttrs, font, key, bbox;
if (group) {
groups = [].concat(group);
ln = groups.length;
for (i = 0; i < ln; i++) {
group = groups[i];
me.getGroup(group).add(sprite);
}
delete sprite.group;
}
scrubbedAttrs = me.scrubAttrs(sprite) || {};
if (sprite.zIndexDirty) {
me.setZIndex(sprite);
}
// Apply minimum default attributes
Ext.applyIf(scrubbedAttrs, me.minDefaults[sprite.type]);
if (sprite.type == 'image') {
Ext.apply(sprite.attr, {
x: scrubbedAttrs.x,
y: scrubbedAttrs.y,
width: scrubbedAttrs.width,
height: scrubbedAttrs.height
});
bbox = sprite.getBBox();
el.setStyle({
width: bbox.width + 'px',
height: bbox.height + 'px'
});
dom.src = scrubbedAttrs.src;
}
if (dom.href) {
dom.href = scrubbedAttrs.href;
}
if (dom.title) {
dom.title = scrubbedAttrs.title;
}
if (dom.target) {
dom.target = scrubbedAttrs.target;
}
if (dom.cursor) {
dom.cursor = scrubbedAttrs.cursor;
}
// Change visibility
if (sprite.dirtyHidden) {
(scrubbedAttrs.hidden) ? me.hidePrim(sprite) : me.showPrim(sprite);
sprite.dirtyHidden = false;
}
// Update path
if (sprite.dirtyPath) {
if (sprite.type == "circle" || sprite.type == "ellipse") {
var cx = scrubbedAttrs.x,
cy = scrubbedAttrs.y,
rx = scrubbedAttrs.rx || scrubbedAttrs.r || 0,
ry = scrubbedAttrs.ry || scrubbedAttrs.r || 0;
dom.path = Ext.String.format("ar{0},{1},{2},{3},{4},{1},{4},{1}",
Math.round((cx - rx) * me.zoom),
Math.round((cy - ry) * me.zoom),
Math.round((cx + rx) * me.zoom),
Math.round((cy + ry) * me.zoom),
Math.round(cx * me.zoom));
sprite.dirtyPath = false;
}
else if (sprite.type !== "text" && sprite.type !== 'image') {
sprite.attr.path = scrubbedAttrs.path = me.setPaths(sprite, scrubbedAttrs) || scrubbedAttrs.path;
dom.path = me.path2vml(scrubbedAttrs.path);
sprite.dirtyPath = false;
}
}
// Apply clipping
if ("clip-rect" in scrubbedAttrs) {
me.setClip(sprite, scrubbedAttrs);
}
// Handle text (special handling required)
if (sprite.type == "text") {
me.setTextAttributes(sprite, scrubbedAttrs);
}
// Handle fill and opacity
if (scrubbedAttrs.opacity || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
me.setFill(sprite, scrubbedAttrs);
}
// Handle stroke (all fills require a stroke element)
if (scrubbedAttrs.stroke || scrubbedAttrs['stroke-opacity'] || scrubbedAttrs.fill) {
me.setStroke(sprite, scrubbedAttrs);
}
//set styles
style = spriteAttr.style;
if (style) {
el.setStyle(style);
}
sprite.dirty = false;
},
setZIndex: function(sprite) {
if (sprite.el) {
if (sprite.attr.zIndex != undefined) {
sprite.el.setStyle('zIndex', sprite.attr.zIndex);
}
sprite.zIndexDirty = false;
}
},
// Normalize all virtualized types into paths.
setPaths: function(sprite, params) {
var spriteAttr = sprite.attr;
// Clear bbox cache
sprite.bbox.plain = null;
sprite.bbox.transform = null;
if (sprite.type == 'circle') {
spriteAttr.rx = spriteAttr.ry = params.r;
return Ext.draw.Draw.ellipsePath(sprite);
}
else if (sprite.type == 'ellipse') {
spriteAttr.rx = params.rx;
spriteAttr.ry = params.ry;
return Ext.draw.Draw.ellipsePath(sprite);
}
else if (sprite.type == 'rect') {
spriteAttr.rx = spriteAttr.ry = params.r;
return Ext.draw.Draw.rectPath(sprite);
}
else if (sprite.type == 'path' && spriteAttr.path) {
return Ext.draw.Draw.pathToAbsolute(spriteAttr.path);
}
return false;
},
setFill: function(sprite, params) {
var me = this,
el = sprite.el.dom,
fillEl = el.fill,
newfill = false,
opacity, gradient, fillUrl, rotation, angle;
if (!fillEl) {
// NOT an expando (but it sure looks like one)...
fillEl = el.fill = me.createNode("fill");
newfill = true;
}
if (Ext.isArray(params.fill)) {
params.fill = params.fill[0];
}
if (params.fill == "none") {
fillEl.on = false;
}
else {
if (typeof params.opacity == "number") {
fillEl.opacity = params.opacity;
}
if (typeof params["fill-opacity"] == "number") {
fillEl.opacity = params["fill-opacity"];
}
fillEl.on = true;
if (typeof params.fill == "string") {
fillUrl = params.fill.match(me.fillUrlRe);
if (fillUrl) {
fillUrl = fillUrl[1];
// If the URL matches one of the registered gradients, render that gradient
if (fillUrl.charAt(0) == "#") {
gradient = me.gradientsColl.getByKey(fillUrl.substring(1));
}
if (gradient) {
// VML angle is offset and inverted from standard, and must be adjusted to match rotation transform
rotation = params.rotation;
angle = -(gradient.angle + 270 + (rotation ? rotation.degrees : 0)) % 360;
// IE will flip the angle at 0 degrees...
if (angle === 0) {
angle = 180;
}
fillEl.angle = angle;
fillEl.type = "gradient";
fillEl.method = "sigma";
fillEl.colors.value = gradient.colors;
}
// Otherwise treat it as an image
else {
fillEl.src = fillUrl;
fillEl.type = "tile";
}
}
else {
fillEl.color = Ext.draw.Color.toHex(params.fill);
fillEl.src = "";
fillEl.type = "solid";
}
}
}
if (newfill) {
el.appendChild(fillEl);
}
},
setStroke: function(sprite, params) {
var me = this,
el = sprite.el.dom,
strokeEl = sprite.strokeEl,
newStroke = false,
width, opacity;
if (!strokeEl) {
strokeEl = sprite.strokeEl = me.createNode("stroke");
newStroke = true;
}
if (Ext.isArray(params.stroke)) {
params.stroke = params.stroke[0];
}
if (!params.stroke || params.stroke == "none" || params.stroke == 0 || params["stroke-width"] == 0) {
strokeEl.on = false;
}
else {
strokeEl.on = true;
if (params.stroke && !params.stroke.match(me.fillUrlRe)) {
// VML does NOT support a gradient stroke :(
strokeEl.color = Ext.draw.Color.toHex(params.stroke);
}
strokeEl.joinstyle = params["stroke-linejoin"];
strokeEl.endcap = params["stroke-linecap"] || "round";
strokeEl.miterlimit = params["stroke-miterlimit"] || 8;
width = parseFloat(params["stroke-width"] || 1) * 0.75;
opacity = params["stroke-opacity"] || 1;
// VML Does not support stroke widths under 1, so we're going to fiddle with stroke-opacity instead.
if (Ext.isNumber(width) && width < 1) {
strokeEl.weight = 1;
strokeEl.opacity = opacity * width;
}
else {
strokeEl.weight = width;
strokeEl.opacity = opacity;
}
}
if (newStroke) {
el.appendChild(strokeEl);
}
},
setClip: function(sprite, params) {
var me = this,
el = sprite.el,
clipEl = sprite.clipEl,
rect = String(params["clip-rect"]).split(me.separatorRe);
if (!clipEl) {
clipEl = sprite.clipEl = me.el.insertFirst(Ext.getDoc().dom.createElement("div"));
clipEl.addCls(Ext.baseCSSPrefix + 'vml-sprite');
}
if (rect.length == 4) {
rect[2] = +rect[2] + (+rect[0]);
rect[3] = +rect[3] + (+rect[1]);
clipEl.setStyle("clip", Ext.String.format("rect({1}px {2}px {3}px {0}px)", rect[0], rect[1], rect[2], rect[3]));
clipEl.setSize(me.el.width, me.el.height);
}
else {
clipEl.setStyle("clip", "");
}
},
setTextAttributes: function(sprite, params) {
var me = this,
vml = sprite.vml,
textStyle = vml.textpath.style,
spanCacheStyle = me.span.style,
zoom = me.zoom,
round = Math.round,
fontObj = {
fontSize: "font-size",
fontWeight: "font-weight",
fontStyle: "font-style"
},
fontProp,
paramProp;
if (sprite.dirtyFont) {
if (params.font) {
textStyle.font = spanCacheStyle.font = params.font;
}
if (params["font-family"]) {
textStyle.fontFamily = '"' + params["font-family"].split(",")[0].replace(me.fontFamilyRe, "") + '"';
spanCacheStyle.fontFamily = params["font-family"];
}
for (fontProp in fontObj) {
paramProp = params[fontObj[fontProp]];
if (paramProp) {
textStyle[fontProp] = spanCacheStyle[fontProp] = paramProp;
}
}
me.setText(sprite, params.text);
if (vml.textpath.string) {
me.span.innerHTML = String(vml.textpath.string).replace(/");
}
vml.W = me.span.offsetWidth;
vml.H = me.span.offsetHeight + 2;
if (params["text-anchor"] == "middle") {
textStyle["v-text-align"] = "center";
}
else if (params["text-anchor"] == "end") {
textStyle["v-text-align"] = "right";
vml.bbx = -Math.round(vml.W / 2);
}
else {
textStyle["v-text-align"] = "left";
vml.bbx = Math.round(vml.W / 2);
}
}
vml.X = params.x;
vml.Y = params.y;
vml.path.v = Ext.String.format("m{0},{1}l{2},{1}", Math.round(vml.X * zoom), Math.round(vml.Y * zoom), Math.round(vml.X * zoom) + 1);
sprite.bbox.plain = null;
sprite.bbox.transform = null;
sprite.dirtyFont = false;
},
setText: function(sprite, text) {
sprite.vml.textpath.string = Ext.htmlDecode(text);
},
hide: function() {
this.el.hide();
},
show: function() {
this.el.show();
},
hidePrim: function(sprite) {
sprite.el.addCls(Ext.baseCSSPrefix + 'hide-visibility');
},
showPrim: function(sprite) {
sprite.el.removeCls(Ext.baseCSSPrefix + 'hide-visibility');
},
setSize: function(width, height) {
var me = this;
width = width || me.width;
height = height || me.height;
me.width = width;
me.height = height;
if (me.el) {
if (width != undefined) {
me.el.setWidth(width);
}
if (height != undefined) {
me.el.setHeight(height);
}
me.applyViewBox();
me.callParent(arguments);
}
},
setViewBox: function(x, y, width, height) {
this.callParent(arguments);
this.viewBox = {
x: x,
y: y,
width: width,
height: height
};
this.applyViewBox();
},
applyViewBox: function() {
var me = this,
viewBox = me.viewBox,
width = me.width,
height = me.height,
viewBoxX, viewBoxY, viewBoxWidth, viewBoxHeight,
relativeHeight, relativeWidth, size;
if (viewBox && (width || height)) {
viewBoxX = viewBox.x;
viewBoxY = viewBox.y;
viewBoxWidth = viewBox.width;
viewBoxHeight = viewBox.height;
relativeHeight = height / viewBoxHeight;
relativeWidth = width / viewBoxWidth;
if (viewBoxWidth * relativeHeight < width) {
viewBoxX -= (width - viewBoxWidth * relativeHeight) / 2 / relativeHeight;
}
if (viewBoxHeight * relativeWidth < height) {
viewBoxY -= (height - viewBoxHeight * relativeWidth) / 2 / relativeWidth;
}
size = 1 / Math.max(viewBoxWidth / width, viewBoxHeight / height);
me.viewBoxShift = {
dx: -viewBoxX,
dy: -viewBoxY,
scale: size
};
me.items.each(function(item) {
me.transform(item);
});
}
},
onAdd: function(item) {
this.callParent(arguments);
if (this.el) {
this.renderItem(item);
}
},
onRemove: function(sprite) {
if (sprite.el) {
sprite.el.remove();
delete sprite.el;
}
this.callParent(arguments);
},
render: function (container) {
var me = this,
doc = Ext.getDoc().dom;
if (!me.createNode) {
try {
if (!doc.namespaces.rvml) {
doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
}
me.createNode = function (tagName) {
return doc.createElement("');
};
} catch (e) {
me.createNode = function (tagName) {
return doc.createElement("<" + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
};
}
}
if (!me.el) {
var el = doc.createElement("div");
me.el = Ext.get(el);
me.el.addCls(me.baseVmlCls);
me.span = doc.createElement("span");
Ext.get(me.span).addCls(me.measureSpanCls);
el.appendChild(me.span);
me.el.setSize(me.width || 10, me.height || 10);
container.appendChild(el);
me.el.on({
scope: me,
mouseup: me.onMouseUp,
mousedown: me.onMouseDown,
mouseover: me.onMouseOver,
mouseout: me.onMouseOut,
mousemove: me.onMouseMove,
mouseenter: me.onMouseEnter,
mouseleave: me.onMouseLeave,
click: me.onClick
});
}
me.renderAll();
},
renderAll: function() {
this.items.each(this.renderItem, this);
},
redraw: function(sprite) {
sprite.dirty = true;
this.renderItem(sprite);
},
renderItem: function (sprite) {
if (!this.el) {
return;
}
if (!sprite.el) {
this.createSpriteElement(sprite);
}
if (sprite.dirty) {
this.applyAttrs(sprite);
if (sprite.dirtyTransform) {
this.applyTransformations(sprite);
}
}
},
rotationCompensation: function (deg, dx, dy) {
var matrix = Ext.create('Ext.draw.Matrix');
matrix.rotate(-deg, 0.5, 0.5);
return {
x: matrix.x(dx, dy),
y: matrix.y(dx, dy)
};
},
transform: function(sprite) {
var me = this,
matrix = Ext.create('Ext.draw.Matrix'),
transforms = sprite.transformations,
transformsLength = transforms.length,
i = 0,
deltaDegrees = 0,
deltaScaleX = 1,
deltaScaleY = 1,
flip = "",
el = sprite.el,
dom = el.dom,
domStyle = dom.style,
zoom = me.zoom,
skew = sprite.skew,
deltaX, deltaY, transform, type, compensate, y, fill, newAngle,zoomScaleX, zoomScaleY, newOrigin;
for (; i < transformsLength; i++) {
transform = transforms[i];
type = transform.type;
if (type == "translate") {
matrix.translate(transform.x, transform.y);
}
else if (type == "rotate") {
matrix.rotate(transform.degrees, transform.x, transform.y);
deltaDegrees += transform.degrees;
}
else if (type == "scale") {
matrix.scale(transform.x, transform.y, transform.centerX, transform.centerY);
deltaScaleX *= transform.x;
deltaScaleY *= transform.y;
}
}
if (me.viewBoxShift) {
matrix.scale(me.viewBoxShift.scale, me.viewBoxShift.scale, -1, -1);
matrix.add(1, 0, 0, 1, me.viewBoxShift.dx, me.viewBoxShift.dy);
}
sprite.matrix = matrix;
if (sprite.type != "image" && skew) {
skew.matrix = matrix.toString();
skew.offset = matrix.offset();
}
else {
deltaX = matrix.matrix[0][2];
deltaY = matrix.matrix[1][2];
zoomScaleX = zoom / deltaScaleX;
zoomScaleY = zoom / deltaScaleY;
dom.coordsize = Math.abs(zoomScaleX) + " " + Math.abs(zoomScaleY);
newAngle = deltaDegrees * (deltaScaleX * ((deltaScaleY < 0) ? -1 : 1));
if (newAngle != domStyle.rotation && !(newAngle === 0 && !domStyle.rotation)) {
domStyle.rotation = newAngle;
}
if (deltaDegrees) {
compensate = me.rotationCompensation(deltaDegrees, deltaX, deltaY);
deltaX = compensate.x;
deltaY = compensate.y;
}
if (deltaScaleX < 0) {
flip += "x";
}
if (deltaScaleY < 0) {
flip += " y";
y = -1;
}
if (flip != "" && !dom.style.flip) {
domStyle.flip = flip;
}
newOrigin = (deltaX * -zoomScaleX) + " " + (deltaY * -zoomScaleY);
if (newOrigin != dom.coordorigin) {
dom.coordorigin = (deltaX * -zoomScaleX) + " " + (deltaY * -zoomScaleY);
}
}
},
createItem: function (config) {
return Ext.create('Ext.draw.Sprite', config);
},
getRegion: function() {
return this.el.getRegion();
},
addCls: function(sprite, className) {
if (sprite && sprite.el) {
sprite.el.addCls(className);
}
},
removeCls: function(sprite, className) {
if (sprite && sprite.el) {
sprite.el.removeCls(className);
}
},
addGradient: function(gradient) {
var gradients = this.gradientsColl || (this.gradientsColl = Ext.create('Ext.util.MixedCollection')),
colors = [],
stops = Ext.create('Ext.util.MixedCollection');
stops.addAll(gradient.stops);
stops.sortByKey("ASC", function(a, b) {
a = parseInt(a, 10);
b = parseInt(b, 10);
return a > b ? 1 : (a < b ? -1 : 0);
});
stops.eachKey(function(k, v) {
colors.push(k + "% " + v.color);
});
gradients.add(gradient.id, {
colors: colors.join(","),
angle: gradient.angle
});
},
destroy: function() {
var me = this;
me.callParent(arguments);
if (me.el) {
me.el.remove();
}
delete me.el;
}
});
Ext.define('Ext.fx.target.ElementCSS', {
extend: 'Ext.fx.target.Element',
setAttr: function(targetData, isFirstFrame) {
var cssArr = {
attrs: [],
duration: [],
easing: []
},
ln = targetData.length,
attributes,
attrs,
attr,
easing,
duration,
o,
i,
j,
ln2;
for (i = 0; i < ln; i++) {
attrs = targetData[i];
duration = attrs.duration;
easing = attrs.easing;
attrs = attrs.attrs;
for (attr in attrs) {
if (Ext.Array.indexOf(cssArr.attrs, attr) == -1) {
cssArr.attrs.push(attr.replace(/[A-Z]/g, function(v) {
return '-' + v.toLowerCase();
}));
cssArr.duration.push(duration + 'ms');
cssArr.easing.push(easing);
}
}
}
attributes = cssArr.attrs.join(',');
duration = cssArr.duration.join(',');
easing = cssArr.easing.join(', ');
for (i = 0; i < ln; i++) {
attrs = targetData[i].attrs;
for (attr in attrs) {
ln2 = attrs[attr].length;
for (j = 0; j < ln2; j++) {
o = attrs[attr][j];
o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', isFirstFrame ? '' : attributes);
o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', isFirstFrame ? '' : duration);
o[0].setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', isFirstFrame ? '' : easing);
o[0].setStyle(attr, o[1]);
if (isFirstFrame) {
o = o[0].dom.offsetWidth;
}
else {
o[0].on(Ext.supports.CSS3TransitionEnd, function() {
this.setStyle(Ext.supports.CSS3Prefix + 'TransitionProperty', null);
this.setStyle(Ext.supports.CSS3Prefix + 'TransitionDuration', null);
this.setStyle(Ext.supports.CSS3Prefix + 'TransitionTimingFunction', null);
}, o[0], { single: true });
}
}
}
}
}
});
Ext.define('Ext.fx.target.CompositeElementCSS', {
extend: 'Ext.fx.target.CompositeElement',
requires: ['Ext.fx.target.ElementCSS'],
setAttr: function() {
return Ext.fx.target.ElementCSS.prototype.setAttr.apply(this, arguments);
}
});
Ext.define('Ext.layout.container.AbstractFit', {
extend: 'Ext.layout.container.Container',
itemCls: Ext.baseCSSPrefix + 'fit-item',
targetCls: Ext.baseCSSPrefix + 'layout-fit',
type: 'fit'
});
Ext.define('Ext.layout.container.Fit', {
extend: 'Ext.layout.container.AbstractFit',
alias: 'layout.fit',
alternateClassName: 'Ext.layout.FitLayout',
onLayout : function() {
var me = this;
me.callParent();
if (me.owner.items.length) {
me.setItemBox(me.owner.items.get(0), me.getLayoutTargetSize());
}
},
getTargetBox : function() {
return this.getLayoutTargetSize();
},
setItemBox : function(item, box) {
var me = this;
if (item && box.height > 0) {
if (!me.owner.isFixedWidth()) {
box.width = undefined;
}
if (!me.owner.isFixedHeight()) {
box.height = undefined;
}
me.setItemSize(item, box.width, box.height);
}
},
configureItem: function(item) {
item.layoutManagedHeight = 0;
item.layoutManagedWidth = 0;
this.callParent(arguments);
}
});
Ext.define('Ext.layout.container.AbstractCard', {
extend: 'Ext.layout.container.Fit',
type: 'card',
sizeAllCards: false,
hideInactive: true,
deferredRender : false,
beforeLayout: function() {
var me = this;
me.getActiveItem();
if (me.activeItem && me.deferredRender) {
me.renderItems([me.activeItem], me.getRenderTarget());
return true;
}
else {
return this.callParent(arguments);
}
},
renderChildren: function () {
this.getActiveItem();
this.callParent();
},
onLayout: function() {
var me = this,
activeItem = me.activeItem,
items = me.getVisibleItems(),
ln = items.length,
targetBox = me.getTargetBox(),
i, item;
for (i = 0; i < ln; i++) {
item = items[i];
me.setItemBox(item, targetBox);
}
if (!me.firstActivated && activeItem) {
if (activeItem.fireEvent('beforeactivate', activeItem) !== false) {
activeItem.fireEvent('activate', activeItem);
}
me.firstActivated = true;
}
},
isValidParent : function(item, target, position) {
var itemEl = item.el ? item.el.dom : Ext.getDom(item);
return (itemEl && itemEl.parentNode === (target.dom || target)) || false;
},
getActiveItem: function() {
var me = this;
if (!me.activeItem && me.owner) {
me.activeItem = me.parseActiveItem(me.owner.activeItem);
}
if (me.activeItem && me.owner.items.indexOf(me.activeItem) != -1) {
return me.activeItem;
}
return null;
},
parseActiveItem: function(item) {
if (item && item.isComponent) {
return item;
}
else if (typeof item == 'number' || item === undefined) {
return this.getLayoutItems()[item || 0];
}
else {
return this.owner.getComponent(item);
}
},
configureItem: function(item, position) {
this.callParent([item, position]);
if (this.hideInactive && this.activeItem !== item) {
item.hide();
}
else {
item.show();
}
},
onRemove: function(component) {
if (component === this.activeItem) {
this.activeItem = null;
if (this.owner.items.getCount() === 0) {
this.firstActivated = false;
}
}
},
getAnimation: function(newCard, owner) {
var newAnim = (newCard || {}).cardSwitchAnimation;
if (newAnim === false) {
return false;
}
return newAnim || owner.cardSwitchAnimation;
},
getNext: function() {
var wrap = arguments[0];
var items = this.getLayoutItems(),
index = Ext.Array.indexOf(items, this.activeItem);
return items[index + 1] || (wrap ? items[0] : false);
},
next: function() {
var anim = arguments[0], wrap = arguments[1];
return this.setActiveItem(this.getNext(wrap), anim);
},
getPrev: function() {
var wrap = arguments[0];
var items = this.getLayoutItems(),
index = Ext.Array.indexOf(items, this.activeItem);
return items[index - 1] || (wrap ? items[items.length - 1] : false);
},
prev: function() {
var anim = arguments[0], wrap = arguments[1];
return this.setActiveItem(this.getPrev(wrap), anim);
}
});
Ext.define('Ext.selection.Model', {
extend: 'Ext.util.Observable',
alternateClassName: 'Ext.AbstractSelectionModel',
requires: ['Ext.data.StoreManager'],
allowDeselect: false,
selected: null,
pruneRemoved: true,
constructor: function(cfg) {
var me = this;
cfg = cfg || {};
Ext.apply(me, cfg);
me.addEvents(
'selectionchange'
);
me.modes = {
SINGLE: true,
SIMPLE: true,
MULTI: true
};
me.setSelectionMode(cfg.mode || me.mode);
me.selected = Ext.create('Ext.util.MixedCollection');
me.callParent(arguments);
},
bind : function(store, initial){
var me = this;
if(!initial && me.store){
if(store !== me.store && me.store.autoDestroy){
me.store.destroy();
}else{
me.store.un("add", me.onStoreAdd, me);
me.store.un("clear", me.onStoreClear, me);
me.store.un("remove", me.onStoreRemove, me);
me.store.un("update", me.onStoreUpdate, me);
}
}
if(store){
store = Ext.data.StoreManager.lookup(store);
store.on({
add: me.onStoreAdd,
clear: me.onStoreClear,
remove: me.onStoreRemove,
update: me.onStoreUpdate,
scope: me
});
}
me.store = store;
if(store && !initial) {
me.refresh();
}
},
selectAll: function(suppressEvent) {
var me = this,
selections = me.store.getRange(),
i = 0,
len = selections.length,
start = me.getSelection().length;
me.bulkChange = true;
for (; i < len; i++) {
me.doSelect(selections[i], true, suppressEvent);
}
delete me.bulkChange;
me.maybeFireSelectionChange(me.getSelection().length !== start);
},
deselectAll: function(suppressEvent) {
var me = this,
selections = me.getSelection(),
i = 0,
len = selections.length,
start = me.getSelection().length;
me.bulkChange = true;
for (; i < len; i++) {
me.doDeselect(selections[i], suppressEvent);
}
delete me.bulkChange;
me.maybeFireSelectionChange(me.getSelection().length !== start);
},
selectWithEvent: function(record, e, keepExisting) {
var me = this;
switch (me.selectionMode) {
case 'MULTI':
if (e.ctrlKey && me.isSelected(record)) {
me.doDeselect(record, false);
} else if (e.shiftKey && me.lastFocused) {
me.selectRange(me.lastFocused, record, e.ctrlKey);
} else if (e.ctrlKey) {
me.doSelect(record, true, false);
} else if (me.isSelected(record) && !e.shiftKey && !e.ctrlKey && me.selected.getCount() > 1) {
me.doSelect(record, keepExisting, false);
} else {
me.doSelect(record, false);
}
break;
case 'SIMPLE':
if (me.isSelected(record)) {
me.doDeselect(record);
} else {
me.doSelect(record, true);
}
break;
case 'SINGLE':
if (me.allowDeselect && me.isSelected(record)) {
me.doDeselect(record);
} else {
me.doSelect(record, false);
}
break;
}
},
selectRange : function(startRow, endRow, keepExisting, dir){
var me = this,
store = me.store,
selectedCount = 0,
i,
tmp,
dontDeselect,
records = [];
if (me.isLocked()){
return;
}
if (!keepExisting) {
me.deselectAll(true);
}
if (!Ext.isNumber(startRow)) {
startRow = store.indexOf(startRow);
}
if (!Ext.isNumber(endRow)) {
endRow = store.indexOf(endRow);
}
if (startRow > endRow){
tmp = endRow;
endRow = startRow;
startRow = tmp;
}
for (i = startRow; i <= endRow; i++) {
if (me.isSelected(store.getAt(i))) {
selectedCount++;
}
}
if (!dir) {
dontDeselect = -1;
} else {
dontDeselect = (dir == 'up') ? startRow : endRow;
}
for (i = startRow; i <= endRow; i++){
if (selectedCount == (endRow - startRow + 1)) {
if (i != dontDeselect) {
me.doDeselect(i, true);
}
} else {
records.push(store.getAt(i));
}
}
me.doMultiSelect(records, true);
},
select: function(records, keepExisting, suppressEvent) {
this.doSelect(records, keepExisting, suppressEvent);
},
deselect: function(records, suppressEvent) {
this.doDeselect(records, suppressEvent);
},
doSelect: function(records, keepExisting, suppressEvent) {
var me = this,
record;
if (me.locked) {
return;
}
if (typeof records === "number") {
records = [me.store.getAt(records)];
}
if (me.selectionMode == "SINGLE" && records) {
record = records.length ? records[0] : records;
me.doSingleSelect(record, suppressEvent);
} else {
me.doMultiSelect(records, keepExisting, suppressEvent);
}
},
doMultiSelect: function(records, keepExisting, suppressEvent) {
var me = this,
selected = me.selected,
change = false,
i = 0,
len, record;
if (me.locked) {
return;
}
records = !Ext.isArray(records) ? [records] : records;
len = records.length;
if (!keepExisting && selected.getCount() > 0) {
if (me.doDeselect(me.getSelection(), suppressEvent) === false) {
return;
}
}
function commit () {
selected.add(record);
change = true;
}
for (; i < len; i++) {
record = records[i];
if (keepExisting && me.isSelected(record)) {
continue;
}
me.lastSelected = record;
me.onSelectChange(record, true, suppressEvent, commit);
}
me.setLastFocused(record, suppressEvent);
me.maybeFireSelectionChange(change && !suppressEvent);
},
doDeselect: function(records, suppressEvent) {
var me = this,
selected = me.selected,
i = 0,
len, record,
attempted = 0,
accepted = 0;
if (me.locked) {
return false;
}
if (typeof records === "number") {
records = [me.store.getAt(records)];
} else if (!Ext.isArray(records)) {
records = [records];
}
function commit () {
++accepted;
selected.remove(record);
}
len = records.length;
for (; i < len; i++) {
record = records[i];
if (me.isSelected(record)) {
if (me.lastSelected == record) {
me.lastSelected = selected.last();
}
++attempted;
me.onSelectChange(record, false, suppressEvent, commit);
}
}
me.maybeFireSelectionChange(accepted > 0 && !suppressEvent);
return accepted === attempted;
},
doSingleSelect: function(record, suppressEvent) {
var me = this,
changed = false,
selected = me.selected;
if (me.locked) {
return;
}
if (me.isSelected(record)) {
return;
}
function commit () {
me.bulkChange = true;
if (selected.getCount() > 0 && me.doDeselect(me.lastSelected, suppressEvent) === false) {
delete me.bulkChange;
return false;
}
delete me.bulkChange;
selected.add(record);
me.lastSelected = record;
changed = true;
}
me.onSelectChange(record, true, suppressEvent, commit);
if (changed) {
if (!suppressEvent) {
me.setLastFocused(record);
}
me.maybeFireSelectionChange(!suppressEvent);
}
},
setLastFocused: function(record, supressFocus) {
var me = this,
recordBeforeLast = me.lastFocused;
me.lastFocused = record;
me.onLastFocusChanged(recordBeforeLast, record, supressFocus);
},
isFocused: function(record) {
return record === this.getLastFocused();
},
maybeFireSelectionChange: function(fireEvent) {
var me = this;
if (fireEvent && !me.bulkChange) {
me.fireEvent('selectionchange', me, me.getSelection());
}
},
getLastSelected: function() {
return this.lastSelected;
},
getLastFocused: function() {
return this.lastFocused;
},
getSelection: function() {
return this.selected.getRange();
},
getSelectionMode: function() {
return this.selectionMode;
},
setSelectionMode: function(selMode) {
selMode = selMode ? selMode.toUpperCase() : 'SINGLE';
this.selectionMode = this.modes[selMode] ? selMode : 'SINGLE';
},
isLocked: function() {
return this.locked;
},
setLocked: function(locked) {
this.locked = !!locked;
},
isSelected: function(record) {
record = Ext.isNumber(record) ? this.store.getAt(record) : record;
return this.selected.indexOf(record) !== -1;
},
hasSelection: function() {
return this.selected.getCount() > 0;
},
refresh: function() {
var me = this,
toBeSelected = [],
oldSelections = me.getSelection(),
len = oldSelections.length,
selection,
change,
i = 0,
lastFocused = this.getLastFocused();
for (; i < len; i++) {
selection = oldSelections[i];
if (!this.pruneRemoved || me.store.indexOf(selection) !== -1) {
toBeSelected.push(selection);
}
}
if (me.selected.getCount() != toBeSelected.length) {
change = true;
}
me.clearSelections();
if (me.store.indexOf(lastFocused) !== -1) {
this.setLastFocused(lastFocused, true);
}
if (toBeSelected.length) {
me.doSelect(toBeSelected, false, true);
}
me.maybeFireSelectionChange(change);
},
clearSelections: function() {
this.selected.clear();
this.lastSelected = null;
this.setLastFocused(null);
},
onStoreAdd: function() {
},
onStoreClear: function() {
if (this.selected.getCount > 0) {
this.clearSelections();
this.maybeFireSelectionChange(true);
}
},
onStoreRemove: function(store, record) {
var me = this,
selected = me.selected;
if (me.locked || !me.pruneRemoved) {
return;
}
if (selected.remove(record)) {
if (me.lastSelected == record) {
me.lastSelected = null;
}
if (me.getLastFocused() == record) {
me.setLastFocused(null);
}
me.maybeFireSelectionChange(true);
}
},
getCount: function() {
return this.selected.getCount();
},
destroy: function() {
},
onStoreUpdate: function() {
},
onSelectChange: function(record, isSelected, suppressEvent) {
},
onLastFocusChanged: function(oldFocused, newFocused) {
},
onEditorKey: function(field, e) {
},
bindComponent: function(cmp) {
}
});
Ext.define('Ext.selection.DataViewModel', {
extend: 'Ext.selection.Model',
requires: ['Ext.util.KeyNav'],
deselectOnContainerClick: true,
enableKeyNav: true,
constructor: function(cfg){
this.addEvents(
'beforedeselect',
'beforeselect',
'deselect',
'select'
);
this.callParent(arguments);
},
bindComponent: function(view) {
var me = this,
eventListeners = {
refresh: me.refresh,
scope: me
};
me.view = view;
me.bind(view.getStore());
view.on(view.triggerEvent, me.onItemClick, me);
view.on(view.triggerCtEvent, me.onContainerClick, me);
view.on(eventListeners);
if (me.enableKeyNav) {
me.initKeyNav(view);
}
},
onItemClick: function(view, record, item, index, e) {
this.selectWithEvent(record, e);
},
onContainerClick: function() {
if (this.deselectOnContainerClick) {
this.deselectAll();
}
},
initKeyNav: function(view) {
var me = this;
if (!view.rendered) {
view.on('render', Ext.Function.bind(me.initKeyNav, me, [view], 0), me, {single: true});
return;
}
view.el.set({
tabIndex: -1
});
me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
down: Ext.pass(me.onNavKey, [1], me),
right: Ext.pass(me.onNavKey, [1], me),
left: Ext.pass(me.onNavKey, [-1], me),
up: Ext.pass(me.onNavKey, [-1], me),
scope: me
});
},
onNavKey: function(step) {
step = step || 1;
var me = this,
view = me.view,
selected = me.getSelection()[0],
numRecords = me.view.store.getCount(),
idx;
if (selected) {
idx = view.indexOf(view.getNode(selected)) + step;
} else {
idx = 0;
}
if (idx < 0) {
idx = numRecords - 1;
} else if (idx >= numRecords) {
idx = 0;
}
me.select(idx);
},
onSelectChange: function(record, isSelected, suppressEvent, commitFn) {
var me = this,
view = me.view,
eventName = isSelected ? 'select' : 'deselect';
if ((suppressEvent || me.fireEvent('before' + eventName, me, record)) !== false &&
commitFn() !== false) {
if (isSelected) {
view.onItemSelect(record);
} else {
view.onItemDeselect(record);
}
if (!suppressEvent) {
me.fireEvent(eventName, me, record);
}
}
}
});
Ext.define('Ext.state.CookieProvider', {
extend: 'Ext.state.Provider',
constructor : function(config){
var me = this;
me.path = "/";
me.expires = new Date(new Date().getTime()+(1000*60*60*24*7));
me.domain = null;
me.secure = false;
me.callParent(arguments);
me.state = me.readCookies();
},
set : function(name, value){
var me = this;
if(typeof value == "undefined" || value === null){
me.clear(name);
return;
}
me.setCookie(name, value);
me.callParent(arguments);
},
clear : function(name){
this.clearCookie(name);
this.callParent(arguments);
},
readCookies : function(){
var cookies = {},
c = document.cookie + ";",
re = /\s?(.*?)=(.*?);/g,
prefix = this.prefix,
len = prefix.length,
matches,
name,
value;
while((matches = re.exec(c)) != null){
name = matches[1];
value = matches[2];
if (name && name.substring(0, len) == prefix){
cookies[name.substr(len)] = this.decodeValue(value);
}
}
return cookies;
},
setCookie : function(name, value){
var me = this;
document.cookie = me.prefix + name + "=" + me.encodeValue(value) +
((me.expires == null) ? "" : ("; expires=" + me.expires.toGMTString())) +
((me.path == null) ? "" : ("; path=" + me.path)) +
((me.domain == null) ? "" : ("; domain=" + me.domain)) +
((me.secure == true) ? "; secure" : "");
},
clearCookie : function(name){
var me = this;
document.cookie = me.prefix + name + "=null; expires=Thu, 01-Jan-70 00:00:01 GMT" +
((me.path == null) ? "" : ("; path=" + me.path)) +
((me.domain == null) ? "" : ("; domain=" + me.domain)) +
((me.secure == true) ? "; secure" : "");
}
});
Ext.define('Ext.state.LocalStorageProvider', {
extend: 'Ext.state.Provider',
alias: 'state.localstorage',
constructor: function(){
var me = this;
me.callParent(arguments);
me.store = me.getStorageObject();
me.state = me.readLocalStorage();
},
readLocalStorage: function(){
var store = this.store,
i = 0,
len = store.length,
prefix = this.prefix,
prefixLen = prefix.length,
data = {},
key;
for (; i < len; ++i) {
key = store.key(i);
if (key.substring(0, prefixLen) == prefix) {
data[key.substr(prefixLen)] = this.decodeValue(store.getItem(key));
}
}
return data;
},
set : function(name, value){
var me = this;
me.clear(name);
if (typeof value == "undefined" || value === null) {
return;
}
me.store.setItem(me.prefix + name, me.encodeValue(value));
me.callParent(arguments);
},
clear : function(name){
this.store.removeItem(this.prefix + name);
this.callParent(arguments);
},
getStorageObject: function(){
try {
var supports = 'localStorage' in window && window['localStorage'] !== null;
if (supports) {
return window.localStorage;
}
} catch (e) {
return false;
}
}
});
Ext.define('Ext.util.Point', {
extend: 'Ext.util.Region',
statics: {
fromEvent: function(e) {
e = (e.changedTouches && e.changedTouches.length > 0) ? e.changedTouches[0] : e;
return new this(e.pageX, e.pageY);
}
},
constructor: function(x, y) {
this.callParent([y, x, y, x]);
},
toString: function() {
return "Point[" + this.x + "," + this.y + "]";
},
equals: function(p) {
return (this.x == p.x && this.y == p.y);
},
isWithin: function(p, threshold) {
if (!Ext.isObject(threshold)) {
threshold = {
x: threshold,
y: threshold
};
}
return (this.x <= p.x + threshold.x && this.x >= p.x - threshold.x &&
this.y <= p.y + threshold.y && this.y >= p.y - threshold.y);
},
roundedEquals: function(p) {
return (Math.round(this.x) == Math.round(p.x) && Math.round(this.y) == Math.round(p.y));
}
}, function() {
this.prototype.translate = Ext.util.Region.prototype.translateBy;
});
Ext.define('Ext.view.AbstractView', {
extend: 'Ext.Component',
alternateClassName: 'Ext.view.AbstractView',
requires: [
'Ext.LoadMask',
'Ext.data.StoreManager',
'Ext.CompositeElementLite',
'Ext.DomQuery',
'Ext.selection.DataViewModel'
],
inheritableStatics: {
getRecord: function(node) {
return this.getBoundView(node).getRecord(node);
},
getBoundView: function(node) {
return Ext.getCmp(node.boundView);
}
},
itemCls: Ext.baseCSSPrefix + 'dataview-item',
loadingText: 'Loading...',
loadMask: true,
loadingUseMsg: true,
selectedItemCls: Ext.baseCSSPrefix + 'item-selected',
emptyText: "",
deferEmptyText: true,
trackOver: false,
blockRefresh: false,
last: false,
triggerEvent: 'itemclick',
triggerCtEvent: 'containerclick',
addCmpEvents: function() {
},
initComponent : function(){
var me = this,
isDef = Ext.isDefined,
itemTpl = me.itemTpl,
memberFn = {};
if (itemTpl) {
if (Ext.isArray(itemTpl)) {
itemTpl = itemTpl.join('');
} else if (Ext.isObject(itemTpl)) {
memberFn = Ext.apply(memberFn, itemTpl.initialConfig);
itemTpl = itemTpl.html;
}
if (!me.itemSelector) {
me.itemSelector = '.' + me.itemCls;
}
itemTpl = Ext.String.format('{1}
';
} else if (Ext.isIE) {
return '
';
} else {
return '';
}
}(),
shadows: [],
pull: function() {
var sh = this.shadows.shift();
if (!sh) {
sh = Ext.get(Ext.core.DomHelper.insertHtml("beforeBegin", document.body.firstChild, this.markup));
sh.autoBoxAdjust = false;
}
return sh;
},
push: function(sh) {
this.shadows.push(sh);
},
reset: function() {
Ext.Array.each(this.shadows, function(shadow) {
shadow.remove();
});
this.shadows = [];
}
});
Ext.define('Ext.Shadow', {
requires: ['Ext.ShadowPool'],
constructor: function(config) {
Ext.apply(this, config);
if (typeof this.mode != "string") {
this.mode = this.defaultMode;
}
var offset = this.offset,
adjusts = {
h: 0
},
rad = Math.floor(this.offset / 2);
switch (this.mode.toLowerCase()) {
case "drop":
if (Ext.supports.CSS3BoxShadow) {
adjusts.w = adjusts.h = -offset;
adjusts.l = adjusts.t = offset;
} else {
adjusts.w = 0;
adjusts.l = adjusts.t = offset;
adjusts.t -= 1;
if (Ext.isIE) {
adjusts.l -= offset + rad;
adjusts.t -= offset + rad;
adjusts.w -= rad;
adjusts.h -= rad;
adjusts.t += 1;
}
}
break;
case "sides":
if (Ext.supports.CSS3BoxShadow) {
adjusts.h -= offset;
adjusts.t = offset;
adjusts.l = adjusts.w = 0;
} else {
adjusts.w = (offset * 2);
adjusts.l = -offset;
adjusts.t = offset - 1;
if (Ext.isIE) {
adjusts.l -= (offset - rad);
adjusts.t -= offset + rad;
adjusts.l += 1;
adjusts.w -= (offset - rad) * 2;
adjusts.w -= rad + 1;
adjusts.h -= 1;
}
}
break;
case "frame":
if (Ext.supports.CSS3BoxShadow) {
adjusts.l = adjusts.w = adjusts.t = 0;
} else {
adjusts.w = adjusts.h = (offset * 2);
adjusts.l = adjusts.t = -offset;
adjusts.t += 1;
adjusts.h -= 2;
if (Ext.isIE) {
adjusts.l -= (offset - rad);
adjusts.t -= (offset - rad);
adjusts.l += 1;
adjusts.w -= (offset + rad + 1);
adjusts.h -= (offset + rad);
adjusts.h += 1;
}
break;
}
}
this.adjusts = adjusts;
},
offset: 4,
defaultMode: "drop",
show: function(target) {
target = Ext.get(target);
if (!this.el) {
this.el = Ext.ShadowPool.pull();
if (this.el.dom.nextSibling != target.dom) {
this.el.insertBefore(target);
}
}
this.el.setStyle("z-index", this.zIndex || parseInt(target.getStyle("z-index"), 10) - 1);
if (Ext.isIE && !Ext.supports.CSS3BoxShadow) {
this.el.dom.style.filter = "progid:DXImageTransform.Microsoft.alpha(opacity=50) progid:DXImageTransform.Microsoft.Blur(pixelradius=" + (this.offset) + ")";
}
this.realign(
target.getLeft(true),
target.getTop(true),
target.getWidth(),
target.getHeight()
);
this.el.dom.style.display = "block";
},
isVisible: function() {
return this.el ? true: false;
},
realign: function(l, t, targetWidth, targetHeight) {
if (!this.el) {
return;
}
var adjusts = this.adjusts,
d = this.el.dom,
targetStyle = d.style,
shadowWidth,
shadowHeight,
cn,
sww,
sws,
shs;
targetStyle.left = (l + adjusts.l) + "px";
targetStyle.top = (t + adjusts.t) + "px";
shadowWidth = Math.max(targetWidth + adjusts.w, 0);
shadowHeight = Math.max(targetHeight + adjusts.h, 0);
sws = shadowWidth + "px";
shs = shadowHeight + "px";
if (targetStyle.width != sws || targetStyle.height != shs) {
targetStyle.width = sws;
targetStyle.height = shs;
if (Ext.supports.CSS3BoxShadow) {
targetStyle.boxShadow = '0 0 ' + this.offset + 'px 0 #888';
} else {
if (!Ext.isIE) {
cn = d.childNodes;
sww = Math.max(0, (shadowWidth - 12)) + "px";
cn[0].childNodes[1].style.width = sww;
cn[1].childNodes[1].style.width = sww;
cn[2].childNodes[1].style.width = sww;
cn[1].style.height = Math.max(0, (shadowHeight - 12)) + "px";
}
}
}
},
hide: function() {
if (this.el) {
this.el.dom.style.display = "none";
Ext.ShadowPool.push(this.el);
delete this.el;
}
},
setZIndex: function(z) {
this.zIndex = z;
if (this.el) {
this.el.setStyle("z-index", z);
}
}
});
Ext.define('Ext.button.Split', {
alias: 'widget.splitbutton',
extend: 'Ext.button.Button',
alternateClassName: 'Ext.SplitButton',
arrowCls : 'split',
split : true,
initComponent : function(){
this.callParent();
this.addEvents("arrowclick");
},
setArrowHandler : function(handler, scope){
this.arrowHandler = handler;
this.scope = scope;
},
onClick : function(e, t) {
var me = this;
e.preventDefault();
if (!me.disabled) {
if (me.overMenuTrigger) {
if (me.menu && !me.menu.isVisible() && !me.ignoreNextClick) {
me.showMenu();
}
me.fireEvent("arrowclick", me, e);
if (me.arrowHandler) {
me.arrowHandler.call(me.scope || me, me, e);
}
} else {
if (me.enableToggle) {
me.toggle();
}
me.fireEvent("click", me, e);
if (me.handler) {
me.handler.call(me.scope || me, me, e);
}
me.onBlur();
}
}
}
});
Ext.define('Ext.button.Cycle', {
alias: 'widget.cycle',
extend: 'Ext.button.Split',
alternateClassName: 'Ext.CycleButton',
getButtonText: function(item) {
var me = this,
text = '';
if (item && me.showText === true) {
if (me.prependText) {
text += me.prependText;
}
text += item.text;
return text;
}
return me.text;
},
setActiveItem: function(item, suppressEvent) {
var me = this;
if (!Ext.isObject(item)) {
item = me.menu.getComponent(item);
}
if (item) {
if (!me.rendered) {
me.text = me.getButtonText(item);
me.iconCls = item.iconCls;
} else {
me.setText(me.getButtonText(item));
me.setIconCls(item.iconCls);
}
me.activeItem = item;
if (!item.checked) {
item.setChecked(true, false);
}
if (me.forceIcon) {
me.setIconCls(me.forceIcon);
}
if (!suppressEvent) {
me.fireEvent('change', me, item);
}
}
},
getActiveItem: function() {
return this.activeItem;
},
initComponent: function() {
var me = this,
checked = 0,
items;
me.addEvents(
"change"
);
if (me.changeHandler) {
me.on('change', me.changeHandler, me.scope || me);
delete me.changeHandler;
}
items = (me.menu.items||[]).concat(me.items||[]);
me.menu = Ext.applyIf({
cls: Ext.baseCSSPrefix + 'cycle-menu',
items: []
}, me.menu);
Ext.each(items, function(item, i) {
item = Ext.applyIf({
group: me.id,
itemIndex: i,
checkHandler: me.checkHandler,
scope: me,
checked: item.checked || false
}, item);
me.menu.items.push(item);
if (item.checked) {
checked = i;
}
});
me.itemCount = me.menu.items.length;
me.callParent(arguments);
me.on('click', me.toggleSelected, me);
me.setActiveItem(checked, me);
if (me.width && me.showText) {
me.addCls(Ext.baseCSSPrefix + 'cycle-fixed-width');
}
},
checkHandler: function(item, pressed) {
if (pressed) {
this.setActiveItem(item);
}
},
toggleSelected: function() {
var me = this,
m = me.menu,
checkItem;
checkItem = me.activeItem.next(':not([disabled])') || m.items.getAt(0);
checkItem.setChecked(true);
}
});
Ext.define('Ext.container.ButtonGroup', {
extend: 'Ext.panel.Panel',
alias: 'widget.buttongroup',
alternateClassName: 'Ext.ButtonGroup',
baseCls: Ext.baseCSSPrefix + 'btn-group',
layout: {
type: 'table'
},
defaultType: 'button',
frame: true,
frameHeader: false,
internalDefaults: {removeMode: 'container', hideParent: true},
initComponent : function(){
var me = this,
cols = me.columns;
me.noTitleCls = me.baseCls + '-notitle';
if (cols) {
me.layout = Ext.apply({}, {columns: cols}, me.layout);
}
if (!me.title) {
me.addCls(me.noTitleCls);
}
me.callParent(arguments);
},
afterLayout: function() {
var me = this;
me.callParent(arguments);
if (me.layout.table && (Ext.isIEQuirks || Ext.isIE6) && !me.width) {
var t = me.getTargetEl();
t.setWidth(me.layout.table.offsetWidth + t.getPadding('lr'));
}
},
afterRender: function() {
var me = this;
if (me.header) {
delete me.header.items.items[0].flex;
me.suspendLayout = true;
me.header.insert(1, {
xtype: 'component',
ui : me.ui,
flex : 1
});
me.header.insert(0, {
xtype: 'component',
ui : me.ui,
flex : 1
});
me.suspendLayout = false;
}
me.callParent(arguments);
},
onBeforeAdd: function(component) {
if (component.is('button')) {
component.ui = component.ui + '-toolbar';
}
this.callParent(arguments);
},
applyDefaults: function(c) {
if (!Ext.isString(c)) {
c = this.callParent(arguments);
var d = this.internalDefaults;
if (c.events) {
Ext.applyIf(c.initialConfig, d);
Ext.apply(c, d);
} else {
Ext.applyIf(c, d);
}
}
return c;
}
});
Ext.define('Ext.container.Viewport', {
extend: 'Ext.container.Container',
alias: 'widget.viewport',
requires: ['Ext.EventManager'],
alternateClassName: 'Ext.Viewport',
isViewport: true,
ariaRole: 'application',
initComponent : function() {
var me = this,
html = Ext.fly(document.body.parentNode),
el;
me.callParent(arguments);
html.addCls(Ext.baseCSSPrefix + 'viewport');
if (me.autoScroll) {
html.setStyle('overflow', 'auto');
}
me.el = el = Ext.getBody();
el.setHeight = Ext.emptyFn;
el.setWidth = Ext.emptyFn;
el.setSize = Ext.emptyFn;
el.dom.scroll = 'no';
me.allowDomMove = false;
Ext.EventManager.onWindowResize(me.fireResize, me);
me.renderTo = me.el;
me.width = Ext.core.Element.getViewportWidth();
me.height = Ext.core.Element.getViewportHeight();
},
fireResize : function(w, h){
this.setSize(w, h);
}
});
Ext.define('Ext.dd.DDTarget', {
extend: 'Ext.dd.DragDrop',
constructor: function(id, sGroup, config) {
if (id) {
this.initTarget(id, sGroup, config);
}
},
getDragEl: Ext.emptyFn,
isValidHandleChild: Ext.emptyFn,
startDrag: Ext.emptyFn,
endDrag: Ext.emptyFn,
onDrag: Ext.emptyFn,
onDragDrop: Ext.emptyFn,
onDragEnter: Ext.emptyFn,
onDragOut: Ext.emptyFn,
onDragOver: Ext.emptyFn,
onInvalidDrop: Ext.emptyFn,
onMouseDown: Ext.emptyFn,
onMouseUp: Ext.emptyFn,
setXConstraint: Ext.emptyFn,
setYConstraint: Ext.emptyFn,
resetConstraints: Ext.emptyFn,
clearConstraints: Ext.emptyFn,
clearTicks: Ext.emptyFn,
setInitPosition: Ext.emptyFn,
setDragElId: Ext.emptyFn,
setHandleElId: Ext.emptyFn,
setOuterHandleElId: Ext.emptyFn,
addInvalidHandleClass: Ext.emptyFn,
addInvalidHandleId: Ext.emptyFn,
addInvalidHandleType: Ext.emptyFn,
removeInvalidHandleClass: Ext.emptyFn,
removeInvalidHandleId: Ext.emptyFn,
removeInvalidHandleType: Ext.emptyFn,
toString: function() {
return ("DDTarget " + this.id);
}
});
Ext.define('Ext.dd.DragTracker', {
uses: ['Ext.util.Region'],
mixins: {
observable: 'Ext.util.Observable'
},
active: false,
trackOver: false,
tolerance: 5,
autoStart: false,
constructor : function(config){
Ext.apply(this, config);
this.addEvents(
'mouseover',
'mouseout',
'mousedown',
'mouseup',
'mousemove',
'beforedragstart',
'dragstart',
'dragend',
'drag'
);
this.dragRegion = Ext.create('Ext.util.Region', 0,0,0,0);
if (this.el) {
this.initEl(this.el);
}
this.mixins.observable.constructor.call(this);
if (this.disabled) {
this.disable();
}
},
initEl: function(el) {
this.el = Ext.get(el);
this.handle = Ext.get(this.delegate);
this.delegate = this.handle ? undefined : this.delegate;
if (!this.handle) {
this.handle = this.el;
}
this.mon(this.handle, {
mousedown: this.onMouseDown,
delegate: this.delegate,
scope: this
});
if (this.trackOver || this.overCls) {
this.mon(this.handle, {
mouseover: this.onMouseOver,
mouseout: this.onMouseOut,
delegate: this.delegate,
scope: this
});
}
},
disable: function() {
this.disabled = true;
},
enable: function() {
this.disabled = false;
},
destroy : function() {
this.clearListeners();
delete this.el;
},
onMouseOver: function(e, target) {
var me = this;
if (!me.disabled) {
if (Ext.EventManager.contains(e) || me.delegate) {
me.mouseIsOut = false;
if (me.overCls) {
me.el.addCls(me.overCls);
}
me.fireEvent('mouseover', me, e, me.delegate ? e.getTarget(me.delegate, target) : me.handle);
}
}
},
onMouseOut: function(e) {
if (this.mouseIsDown) {
this.mouseIsOut = true;
} else {
if (this.overCls) {
this.el.removeCls(this.overCls);
}
this.fireEvent('mouseout', this, e);
}
},
onMouseDown: function(e, target){
if (this.disabled ||e.dragTracked) {
return;
}
this.dragTarget = this.delegate ? target : this.handle.dom;
this.startXY = this.lastXY = e.getXY();
this.startRegion = Ext.fly(this.dragTarget).getRegion();
if (this.fireEvent('mousedown', this, e) === false ||
this.fireEvent('beforedragstart', this, e) === false ||
this.onBeforeStart(e) === false) {
return;
}
this.mouseIsDown = true;
e.dragTracked = true;
if (this.preventDefault !== false) {
e.preventDefault();
}
Ext.getDoc().on({
scope: this,
mouseup: this.onMouseUp,
mousemove: this.onMouseMove,
selectstart: this.stopSelect
});
if (this.autoStart) {
this.timer = Ext.defer(this.triggerStart, this.autoStart === true ? 1000 : this.autoStart, this, [e]);
}
},
onMouseMove: function(e, target){
if (this.active && Ext.isIE && !e.browserEvent.button) {
e.preventDefault();
this.onMouseUp(e);
return;
}
e.preventDefault();
var xy = e.getXY(),
s = this.startXY;
this.lastXY = xy;
if (!this.active) {
if (Math.max(Math.abs(s[0]-xy[0]), Math.abs(s[1]-xy[1])) > this.tolerance) {
this.triggerStart(e);
} else {
return;
}
}
if (this.fireEvent('mousemove', this, e) === false) {
this.onMouseUp(e);
} else {
this.onDrag(e);
this.fireEvent('drag', this, e);
}
},
onMouseUp: function(e) {
this.mouseIsDown = false;
if (this.mouseIsOut) {
this.mouseIsOut = false;
this.onMouseOut(e);
}
e.preventDefault();
this.fireEvent('mouseup', this, e);
this.endDrag(e);
},
endDrag: function(e) {
var doc = Ext.getDoc(),
wasActive = this.active;
doc.un('mousemove', this.onMouseMove, this);
doc.un('mouseup', this.onMouseUp, this);
doc.un('selectstart', this.stopSelect, this);
this.clearStart();
this.active = false;
if (wasActive) {
this.onEnd(e);
this.fireEvent('dragend', this, e);
}
delete this._constrainRegion;
delete Ext.EventObject.dragTracked;
},
triggerStart: function(e) {
this.clearStart();
this.active = true;
this.onStart(e);
this.fireEvent('dragstart', this, e);
},
clearStart : function() {
if (this.timer) {
clearTimeout(this.timer);
delete this.timer;
}
},
stopSelect : function(e) {
e.stopEvent();
return false;
},
onBeforeStart : function(e) {
},
onStart : function(xy) {
},
onDrag : function(e) {
},
onEnd : function(e) {
},
getDragTarget : function(){
return this.dragTarget;
},
getDragCt : function(){
return this.el;
},
getConstrainRegion: function() {
if (this.constrainTo) {
if (this.constrainTo instanceof Ext.util.Region) {
return this.constrainTo;
}
if (!this._constrainRegion) {
this._constrainRegion = Ext.fly(this.constrainTo).getViewRegion();
}
} else {
if (!this._constrainRegion) {
this._constrainRegion = this.getDragCt().getViewRegion();
}
}
return this._constrainRegion;
},
getXY : function(constrain){
return constrain ? this.constrainModes[constrain](this, this.lastXY) : this.lastXY;
},
getOffset : function(constrain){
var xy = this.getXY(constrain),
s = this.startXY;
return [xy[0]-s[0], xy[1]-s[1]];
},
constrainModes: {
point: function(me, xy) {
var dr = me.dragRegion,
constrainTo = me.getConstrainRegion();
if (!constrainTo) {
return xy;
}
dr.x = dr.left = dr[0] = dr.right = xy[0];
dr.y = dr.top = dr[1] = dr.bottom = xy[1];
dr.constrainTo(constrainTo);
return [dr.left, dr.top];
},
dragTarget: function(me, xy) {
var s = me.startXY,
dr = me.startRegion.copy(),
constrainTo = me.getConstrainRegion(),
adjust;
if (!constrainTo) {
return xy;
}
dr.translateBy(xy[0]-s[0], xy[1]-s[1]);
if (dr.right > constrainTo.right) {
xy[0] += adjust = (constrainTo.right - dr.right);
dr.left += adjust;
}
if (dr.left < constrainTo.left) {
xy[0] += (constrainTo.left - dr.left);
}
if (dr.bottom > constrainTo.bottom) {
xy[1] += adjust = (constrainTo.bottom - dr.bottom);
dr.top += adjust;
}
if (dr.top < constrainTo.top) {
xy[1] += (constrainTo.top - dr.top);
}
return xy;
}
}
});
Ext.define('Ext.dd.DragZone', {
extend: 'Ext.dd.DragSource',
constructor : function(el, config){
this.callParent([el, config]);
if (this.containerScroll) {
Ext.dd.ScrollManager.register(this.el);
}
},
getDragData : function(e){
return Ext.dd.Registry.getHandleFromEvent(e);
},
onInitDrag : function(x, y){
this.proxy.update(this.dragData.ddel.cloneNode(true));
this.onStartDrag(x, y);
return true;
},
afterRepair : function(){
var me = this;
if (Ext.enableFx) {
Ext.fly(me.dragData.ddel).highlight(me.repairHighlightColor);
}
me.dragging = false;
},
getRepairXY : function(e){
return Ext.core.Element.fly(this.dragData.ddel).getXY();
},
destroy : function(){
this.callParent();
if (this.containerScroll) {
Ext.dd.ScrollManager.unregister(this.el);
}
}
});
Ext.define('Ext.dd.ScrollManager', {
singleton: true,
requires: [
'Ext.dd.DragDropManager'
],
constructor: function() {
var ddm = Ext.dd.DragDropManager;
ddm.fireEvents = Ext.Function.createSequence(ddm.fireEvents, this.onFire, this);
ddm.stopDrag = Ext.Function.createSequence(ddm.stopDrag, this.onStop, this);
this.doScroll = Ext.Function.bind(this.doScroll, this);
this.ddmInstance = ddm;
this.els = {};
this.dragEl = null;
this.proc = {};
},
onStop: function(e){
var sm = Ext.dd.ScrollManager;
sm.dragEl = null;
sm.clearProc();
},
triggerRefresh: function() {
if (this.ddmInstance.dragCurrent) {
this.ddmInstance.refreshCache(this.ddmInstance.dragCurrent.groups);
}
},
doScroll: function() {
if (this.ddmInstance.dragCurrent) {
var proc = this.proc,
procEl = proc.el,
ddScrollConfig = proc.el.ddScrollConfig,
inc = ddScrollConfig ? ddScrollConfig.increment : this.increment;
if (!this.animate) {
if (procEl.scroll(proc.dir, inc)) {
this.triggerRefresh();
}
} else {
procEl.scroll(proc.dir, inc, true, this.animDuration, this.triggerRefresh);
}
}
},
clearProc: function() {
var proc = this.proc;
if (proc.id) {
clearInterval(proc.id);
}
proc.id = 0;
proc.el = null;
proc.dir = "";
},
startProc: function(el, dir) {
this.clearProc();
this.proc.el = el;
this.proc.dir = dir;
var group = el.ddScrollConfig ? el.ddScrollConfig.ddGroup : undefined,
freq = (el.ddScrollConfig && el.ddScrollConfig.frequency)
? el.ddScrollConfig.frequency
: this.frequency;
if (group === undefined || this.ddmInstance.dragCurrent.ddGroup == group) {
this.proc.id = setInterval(this.doScroll, freq);
}
},
onFire: function(e, isDrop) {
if (isDrop || !this.ddmInstance.dragCurrent) {
return;
}
if (!this.dragEl || this.dragEl != this.ddmInstance.dragCurrent) {
this.dragEl = this.ddmInstance.dragCurrent;
this.refreshCache();
}
var xy = e.getXY(),
pt = e.getPoint(),
proc = this.proc,
els = this.els;
for (var id in els) {
var el = els[id], r = el._region;
var c = el.ddScrollConfig ? el.ddScrollConfig : this;
if (r && r.contains(pt) && el.isScrollable()) {
if (r.bottom - pt.y <= c.vthresh) {
if(proc.el != el){
this.startProc(el, "down");
}
return;
}else if (r.right - pt.x <= c.hthresh) {
if (proc.el != el) {
this.startProc(el, "left");
}
return;
} else if(pt.y - r.top <= c.vthresh) {
if (proc.el != el) {
this.startProc(el, "up");
}
return;
} else if(pt.x - r.left <= c.hthresh) {
if (proc.el != el) {
this.startProc(el, "right");
}
return;
}
}
}
this.clearProc();
},
register : function(el){
if (Ext.isArray(el)) {
for(var i = 0, len = el.length; i < len; i++) {
this.register(el[i]);
}
} else {
el = Ext.get(el);
this.els[el.id] = el;
}
},
unregister : function(el){
if(Ext.isArray(el)){
for (var i = 0, len = el.length; i < len; i++) {
this.unregister(el[i]);
}
}else{
el = Ext.get(el);
delete this.els[el.id];
}
},
vthresh : 25,
hthresh : 25,
increment : 100,
frequency : 500,
animate: true,
animDuration: 0.4,
ddGroup: undefined,
refreshCache : function(){
var els = this.els,
id;
for (id in els) {
if(typeof els[id] == 'object'){
els[id]._region = els[id].getRegion();
}
}
}
});
Ext.define('Ext.dd.DropTarget', {
extend: 'Ext.dd.DDTarget',
requires: ['Ext.dd.ScrollManager'],
constructor : function(el, config){
this.el = Ext.get(el);
Ext.apply(this, config);
if(this.containerScroll){
Ext.dd.ScrollManager.register(this.el);
}
this.callParent([this.el.dom, this.ddGroup || this.group,
{isTarget: true}]);
},
dropAllowed : Ext.baseCSSPrefix + 'dd-drop-ok',
dropNotAllowed : Ext.baseCSSPrefix + 'dd-drop-nodrop',
isTarget : true,
isNotifyTarget : true,
notifyEnter : function(dd, e, data){
if(this.overClass){
this.el.addCls(this.overClass);
}
return this.dropAllowed;
},
notifyOver : function(dd, e, data){
return this.dropAllowed;
},
notifyOut : function(dd, e, data){
if(this.overClass){
this.el.removeCls(this.overClass);
}
},
notifyDrop : function(dd, e, data){
return false;
},
destroy : function(){
this.callParent();
if(this.containerScroll){
Ext.dd.ScrollManager.unregister(this.el);
}
}
});
Ext.define('Ext.dd.Registry', {
singleton: true,
constructor: function() {
this.elements = {};
this.handles = {};
this.autoIdSeed = 0;
},
getId: function(el, autogen){
if(typeof el == "string"){
return el;
}
var id = el.id;
if(!id && autogen !== false){
id = "extdd-" + (++this.autoIdSeed);
el.id = id;
}
return id;
},
register : function(el, data){
data = data || {};
if (typeof el == "string") {
el = document.getElementById(el);
}
data.ddel = el;
this.elements[this.getId(el)] = data;
if (data.isHandle !== false) {
this.handles[data.ddel.id] = data;
}
if (data.handles) {
var hs = data.handles;
for (var i = 0, len = hs.length; i < len; i++) {
this.handles[this.getId(hs[i])] = data;
}
}
},
unregister : function(el){
var id = this.getId(el, false);
var data = this.elements[id];
if(data){
delete this.elements[id];
if(data.handles){
var hs = data.handles;
for (var i = 0, len = hs.length; i < len; i++) {
delete this.handles[this.getId(hs[i], false)];
}
}
}
},
getHandle : function(id){
if(typeof id != "string"){
id = id.id;
}
return this.handles[id];
},
getHandleFromEvent : function(e){
var t = e.getTarget();
return t ? this.handles[t.id] : null;
},
getTarget : function(id){
if(typeof id != "string"){
id = id.id;
}
return this.elements[id];
},
getTargetFromEvent : function(e){
var t = e.getTarget();
return t ? this.elements[t.id] || this.handles[t.id] : null;
}
});
Ext.define('Ext.dd.DropZone', {
extend: 'Ext.dd.DropTarget',
requires: ['Ext.dd.Registry'],
getTargetFromEvent : function(e){
return Ext.dd.Registry.getTargetFromEvent(e);
},
onNodeEnter : function(n, dd, e, data){
},
onNodeOver : function(n, dd, e, data){
return this.dropAllowed;
},
onNodeOut : function(n, dd, e, data){
},
onNodeDrop : function(n, dd, e, data){
return false;
},
onContainerOver : function(dd, e, data){
return this.dropNotAllowed;
},
onContainerDrop : function(dd, e, data){
return false;
},
notifyEnter : function(dd, e, data){
return this.dropNotAllowed;
},
notifyOver : function(dd, e, data){
var n = this.getTargetFromEvent(e);
if(!n) {
if(this.lastOverNode){
this.onNodeOut(this.lastOverNode, dd, e, data);
this.lastOverNode = null;
}
return this.onContainerOver(dd, e, data);
}
if(this.lastOverNode != n){
if(this.lastOverNode){
this.onNodeOut(this.lastOverNode, dd, e, data);
}
this.onNodeEnter(n, dd, e, data);
this.lastOverNode = n;
}
return this.onNodeOver(n, dd, e, data);
},
notifyOut : function(dd, e, data){
if(this.lastOverNode){
this.onNodeOut(this.lastOverNode, dd, e, data);
this.lastOverNode = null;
}
},
notifyDrop : function(dd, e, data){
if(this.lastOverNode){
this.onNodeOut(this.lastOverNode, dd, e, data);
this.lastOverNode = null;
}
var n = this.getTargetFromEvent(e);
return n ?
this.onNodeDrop(n, dd, e, data) :
this.onContainerDrop(dd, e, data);
},
triggerCacheRefresh : function() {
Ext.dd.DDM.refreshCache(this.groups);
}
});
Ext.define('Ext.flash.Component', {
extend: 'Ext.Component',
alternateClassName: 'Ext.FlashComponent',
alias: 'widget.flash',
flashVersion : '9.0.115',
backgroundColor: '#ffffff',
wmode: 'opaque',
swfWidth: '100%',
swfHeight: '100%',
expressInstall: false,
renderTpl: ['
'],
initComponent: function() {
this.callParent();
this.addEvents(
'success',
'failure'
);
},
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)
);
},
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);
}
},
getSwfId: function() {
return this.swfId || (this.swfId = "extswf" + this.getAutoId());
},
onSuccess: function() {
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: {
EXPRESS_INSTALL_URL: 'http:/' + '/swfobject.googlecode.com/svn/trunk/swfobject/expressInstall.swf'
}
});
Ext.define('Ext.form.action.Action', {
alternateClassName: 'Ext.form.Action',
constructor: function(config) {
if (config) {
Ext.apply(this, config);
}
var params = config.params;
if (Ext.isString(params)) {
this.params = Ext.Object.fromQueryString(params);
}
},
run: Ext.emptyFn,
onFailure : function(response){
this.response = response;
this.failureType = Ext.form.action.Action.CONNECT_FAILURE;
this.form.afterAction(this, false);
},
processResponse : function(response){
this.response = response;
if (!response.responseText && !response.responseXML) {
return true;
}
return (this.result = this.handleResponse(response));
},
getUrl: function() {
return this.url || this.form.url;
},
getMethod: function() {
return (this.method || this.form.method || 'POST').toUpperCase();
},
getParams: function() {
return Ext.apply({}, this.params, this.form.baseParams);
},
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
};
},
statics: {
CLIENT_INVALID: 'client',
SERVER_INVALID: 'server',
CONNECT_FAILURE: 'connect',
LOAD_FAILURE: 'load'
}
});
Ext.define('Ext.form.action.Submit', {
extend:'Ext.form.action.Action',
alternateClassName: 'Ext.form.Action.Submit',
alias: 'formaction.submit',
type: 'submit',
run : function(){
var form = this.form;
if (this.clientValidation === false || form.isValid()) {
this.doSubmit();
} else {
this.failureType = Ext.form.action.Action.CLIENT_INVALID;
form.afterAction(this, false);
}
},
doSubmit: function() {
var formEl,
ajaxOptions = Ext.apply(this.createCallback(), {
url: this.getUrl(),
method: this.getMethod(),
headers: this.headers
});
if (this.form.hasUpload()) {
formEl = ajaxOptions.form = this.buildForm();
ajaxOptions.isUpload = true;
} else {
ajaxOptions.params = this.getParams();
}
Ext.Ajax.request(ajaxOptions);
if (formEl) {
Ext.removeNode(formEl);
}
},
getParams: function() {
var nope = false,
configParams = this.callParent(),
fieldParams = this.form.getValues(nope, nope, this.submitEmptyText !== nope);
return Ext.apply({}, fieldParams, configParams);
},
buildForm: function() {
var fieldsSpec = [],
formSpec,
formEl,
basicForm = this.form,
params = this.getParams(),
uploadFields = [];
basicForm.getFields().each(function(field) {
if (field.isFileUpload()) {
uploadFields.push(field);
}
});
function addField(name, val) {
fieldsSpec.push({
tag: 'input',
type: 'hidden',
name: name,
value: Ext.String.htmlEncode(val)
});
}
Ext.iterate(params, function(key, val) {
if (Ext.isArray(val)) {
Ext.each(val, function(v) {
addField(key, v);
});
} else {
addField(key, val);
}
});
formSpec = {
tag: 'form',
action: this.getUrl(),
method: this.getMethod(),
target: this.target || '_self',
style: 'display:none',
cn: fieldsSpec
};
if (uploadFields.length) {
formSpec.encoding = formSpec.enctype = 'multipart/form-data';
}
formEl = Ext.core.DomHelper.append(Ext.getBody(), formSpec);
Ext.Array.each(uploadFields, function(field) {
if (field.rendered) {
formEl.appendChild(field.extractFileInput());
}
});
return formEl;
},
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);
},
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);
}
});
Ext.define('Ext.util.ComponentDragger', {
extend: 'Ext.dd.DragTracker',
autoStart: 500,
constructor: function(comp, config) {
this.comp = comp;
this.initialConstrainTo = config.constrainTo;
this.callParent([ config ]);
},
onStart: function(e) {
var me = this,
comp = me.comp;
this.startPosition = comp.getPosition();
if (comp.ghost && !comp.liveDrag) {
me.proxy = comp.ghost();
me.dragTarget = me.proxy.header.el;
}
if (me.constrain || me.constrainDelegate) {
me.constrainTo = me.calculateConstrainRegion();
}
},
calculateConstrainRegion: function() {
var me = this,
comp = me.comp,
c = me.initialConstrainTo,
delegateRegion,
elRegion,
shadowSize = comp.el.shadow ? comp.el.shadow.offset : 0;
if (!(c instanceof Ext.util.Region)) {
c = Ext.fly(c).getViewRegion();
}
if (shadowSize) {
c.adjust(0, -shadowSize, -shadowSize, shadowSize);
}
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;
},
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]);
},
onEnd: function(e) {
if (this.proxy && !this.comp.liveDrag) {
this.comp.unghost();
}
}
});
Ext.define("Ext.form.Labelable", {
requires: ['Ext.XTemplate'],
labelableRenderTpl: [
'',
' for="{inputId}" class="{labelCls}" style="{labelStyle}" >',
'{fieldLabel}{labelSeparator} ',
'',
'',
' id="{baseBodyCls}-{inputId}" role="presentation">{subTplMarkup}
',
'
',
'
',
{
compiled: true,
disableFormats: true
}
],
activeErrorsTpl: [
'',
' ',
''
],
isFieldLabelable: true,
formItemCls: Ext.baseCSSPrefix + 'form-item',
labelCls: Ext.baseCSSPrefix + 'form-item-label',
errorMsgCls: Ext.baseCSSPrefix + 'form-error-msg',
baseBodyCls: Ext.baseCSSPrefix + 'form-item-body',
fieldBodyCls: '',
clearCls: Ext.baseCSSPrefix + 'clear',
invalidCls : Ext.baseCSSPrefix + 'form-invalid',
fieldLabel: undefined,
labelAlign : 'left',
labelWidth: 100,
labelPad : 5,
labelSeparator : ':',
hideLabel: false,
hideEmptyLabel: true,
preventMark: false,
autoFitErrors: true,
msgTarget: 'qtip',
initLabelable: function() {
this.addCls(this.formItemCls);
this.addEvents(
'errorchange'
);
},
getFieldLabel: function() {
return this.fieldLabel || '';
},
getLabelableRenderData: function() {
var me = this,
labelAlign = me.labelAlign,
labelPad = me.labelPad,
labelStyle;
if (labelAlign === 'top') {
labelStyle = 'margin-bottom:' + labelPad + 'px;';
} else {
labelStyle = 'margin-right:' + labelPad + 'px;';
if (Ext.isBorderBox) {
labelStyle += 'width:' + me.labelWidth + 'px;';
}
}
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
);
},
getLabelableSelectors: function() {
return {
labelEl: 'label.' + this.labelCls,
bodyEl: '.' + this.baseBodyCls,
errorEl: '.' + this.errorMsgCls
};
},
getSubTplMarkup: function() {
return '';
},
getInputId: function() {
return '';
},
getActiveError : function() {
return this.activeError || '';
},
hasActiveError: function() {
return !!this.getActiveError();
},
setActiveError: function(msg) {
this.activeError = msg;
this.activeErrors = [msg];
this.renderActiveError();
},
getActiveErrors: function() {
return this.activeErrors || [];
},
setActiveErrors: function(errors) {
this.activeErrors = errors;
this.activeError = this.getTpl('activeErrorsTpl').apply({errors: errors});
this.renderActiveError();
},
unsetActiveError: function() {
delete this.activeError;
delete this.activeErrors;
this.renderActiveError();
},
renderActiveError: function() {
var me = this,
activeError = me.getActiveError(),
hasError = !!activeError;
if (activeError !== me.lastActiveError) {
me.fireEvent('errorchange', me, activeError);
me.lastActiveError = activeError;
}
if (me.rendered && !me.isDestroyed && !me.preventMark) {
me.el[hasError ? 'addCls' : 'removeCls'](me.invalidCls);
me.getActionEl().dom.setAttribute('aria-invalid', hasError);
me.errorEl.dom.innerHTML = activeError;
}
},
setFieldDefaults: function(defaults) {
var me = this;
Ext.iterate(defaults, function(key, val) {
if (!me.hasOwnProperty(key)) {
me[key] = val;
}
});
},
getBodyNaturalWidth: function() {
return this.bodyEl.getWidth();
}
});
Ext.define('Ext.form.field.Field', {
isFormField : true,
disabled : false,
submitValue: true,
validateOnChange: true,
suspendCheckChange: 0,
initField: function() {
this.addEvents(
'change',
'validitychange',
'dirtychange'
);
this.initValue();
},
initValue: function() {
var me = this;
me.originalValue = me.lastValue = me.value;
me.suspendCheckChange++;
me.setValue(me.value);
me.suspendCheckChange--;
},
getName: function() {
return this.name;
},
getValue: function() {
return this.value;
},
setValue: function(value) {
var me = this;
me.value = value;
me.checkChange();
return me;
},
isEqual: function(value1, value2) {
return String(value1) === String(value2);
},
getSubmitData: function() {
var me = this,
data = null;
if (!me.disabled && me.submitValue && !me.isFileUpload()) {
data = {};
data[me.getName()] = '' + me.getValue();
}
return data;
},
getModelData: function() {
var me = this,
data = null;
if (!me.disabled && !me.isFileUpload()) {
data = {};
data[me.getName()] = me.getValue();
}
return data;
},
reset : function(){
var me = this;
me.setValue(me.originalValue);
me.clearInvalid();
delete me.wasValid;
},
resetOriginalValue: function() {
this.originalValue = this.getValue();
this.checkDirty();
},
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);
}
}
},
onChange: function(newVal, oldVal) {
if (this.validateOnChange) {
this.validate();
}
this.checkDirty();
},
isDirty : function() {
var me = this;
return !me.disabled && !me.isEqual(me.getValue(), me.originalValue);
},
checkDirty: function() {
var me = this,
isDirty = me.isDirty();
if (isDirty !== me.wasDirty) {
me.fireEvent('dirtychange', me, isDirty);
me.onDirtyChange(isDirty);
me.wasDirty = isDirty;
}
},
onDirtyChange: Ext.emptyFn,
getErrors: function(value) {
return [];
},
isValid : function() {
var me = this;
return me.disabled || Ext.isEmpty(me.getErrors());
},
validate : function() {
var me = this,
isValid = me.isValid();
if (isValid !== me.wasValid) {
me.wasValid = isValid;
me.fireEvent('validitychange', me, isValid);
}
return isValid;
},
batchChanges: function(fn) {
this.suspendCheckChange++;
fn();
this.suspendCheckChange--;
this.checkChange();
},
isFileUpload: function() {
return false;
},
extractFileInput: function() {
return null;
},
markInvalid: Ext.emptyFn,
clearInvalid: Ext.emptyFn
});
Ext.define('Ext.layout.component.field.Field', {
alias: ['layout.field'],
extend: 'Ext.layout.component.Component',
uses: ['Ext.tip.QuickTip', 'Ext.util.TextMetrics'],
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) {
width = undef;
}
}
if (!isDefined(height)) {
height = lastSize.height;
if (height < 0) {
height = undef;
}
}
autoWidth = !isNumber(width);
autoHeight = !isNumber(height);
info = {
autoWidth: autoWidth,
autoHeight: autoHeight,
width: autoWidth ? owner.getBodyNaturalWidth() : width,
height: height,
setOuterWidth: false,
insets: {
top: 0,
right: 0,
bottom: 0,
left: 0
}
};
labelStrategy.prepare(owner, info);
errorStrategy.prepare(owner, info);
labelStrategy.adjustHorizInsets(owner, info);
errorStrategy.adjustHorizInsets(owner, info);
labelStrategy.layoutHoriz(owner, info);
errorStrategy.layoutHoriz(owner, info);
labelStrategy.adjustVertInsets(owner, info);
errorStrategy.adjustVertInsets(owner, info);
labelStrategy.layoutVert(owner, info);
errorStrategy.layoutVert(owner, info);
if (autoWidth && autoHeight) {
me.setElementSize(owner.el, (info.setOuterWidth ? info.width : undef), info.height);
} else {
me.setTargetSize((!autoWidth || info.setOuterWidth ? info.width : undef), info.height);
}
me.sizeBody(info);
me.activeError = owner.getActiveError();
},
sizeBody: function(info) {
var me = this,
owner = me.owner,
insets = info.insets,
totalWidth = info.width,
totalHeight = info.height,
width = Ext.isNumber(totalWidth) ? totalWidth - insets.left - insets.right : totalWidth,
height = Ext.isNumber(totalHeight) ? totalHeight - insets.top - insets.bottom : totalHeight;
me.setElementSize(owner.bodyEl, width, height);
me.sizeBodyContents(width, height);
},
sizeBodyContents: Ext.emptyFn,
getLabelStrategy: function() {
var me = this,
strategies = me.labelStrategies,
labelAlign = me.owner.labelAlign;
return strategies[labelAlign] || strategies.base;
},
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;
},
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 (info.autoWidth) {
info.width += (!owner.labelEl ? 0 : owner.labelWidth + owner.labelPad);
}
info.setOuterWidth = true;
},
adjustHorizInsets: function(owner, info) {
if (owner.labelEl) {
info.insets.left += owner.labelWidth + owner.labelPad;
}
},
layoutHoriz: function(owner, info) {
var labelEl = owner.labelEl;
if (labelEl && !owner.isLabelSized && !Ext.isBorderBox) {
labelEl.setWidth(owner.labelWidth);
owner.isLabelSized = true;
}
}
}, base);
return {
base: base,
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),
left: left,
right: left
};
})(),
errorStrategies: (function() {
function setDisplayed(el, displayed) {
var wasDisplayed = el.getStyle('display') !== 'none';
if (displayed !== wasDisplayed) {
el.setDisplayed(displayed);
}
}
function setStyle(el, name, value) {
if (el.getStyle(name) !== value) {
el.setStyle(name, value);
}
}
var applyIf = Ext.applyIf,
emptyFn = Ext.emptyFn,
base = {
prepare: function(owner) {
setDisplayed(owner.errorEl, false);
},
adjustHorizInsets: emptyFn,
adjustVertInsets: emptyFn,
layoutHoriz: emptyFn,
layoutVert: emptyFn
};
return {
none: base,
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),
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;
setStyle(errorEl, 'width', info.width - insets.right - insets.left + 'px');
setStyle(errorEl, 'marginLeft', insets.left + 'px');
}
}, base),
qtip: applyIf({
prepare: function(owner) {
setDisplayed(owner.errorEl, false);
Ext.layout.component.field.Field.initTip();
owner.getActionEl().dom.setAttribute('data-errorqtip', owner.getActiveError() || '');
}
}, base),
title: applyIf({
prepare: function(owner) {
setDisplayed(owner.errorEl, false);
owner.el.dom.title = owner.getActiveError() || '';
}
}, base),
elementId: applyIf({
prepare: function(owner) {
setDisplayed(owner.errorEl, false);
var targetEl = Ext.fly(owner.msgTarget);
if (targetEl) {
targetEl.dom.innerHTML = owner.getActiveError() || '';
targetEl.setDisplayed(owner.hasActiveError());
}
}
}, base)
};
})(),
statics: {
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);
}
},
destroyTip: function() {
var tip = this.tip;
if (tip) {
tip.destroy();
delete this.tip;
}
}
}
});
Ext.define('Ext.form.field.VTypes', (function(){
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;
return {
singleton: true,
alternateClassName: 'Ext.form.VTypes',
'email' : function(v){
return email.test(v);
},
'emailText' : 'This field should be an e-mail address in the format "user@example.com"',
'emailMask' : /[a-z0-9_\.\-@\+]/i,
'url' : function(v){
return url.test(v);
},
'urlText' : 'This field should be a URL in the format "http:/'+'/www.example.com"',
'alpha' : function(v){
return alpha.test(v);
},
'alphaText' : 'This field should only contain letters and _',
'alphaMask' : /[a-z_]/i,
'alphanum' : function(v){
return alphanum.test(v);
},
'alphanumText' : 'This field should only contain letters, numbers and _',
'alphanumMask' : /[a-z0-9_]/i
};
})());
Ext.define('Ext.layout.component.field.Text', {
extend: 'Ext.layout.component.field.Field',
alias: 'layout.textfield',
requires: ['Ext.util.TextMetrics'],
type: 'textfield',
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);
},
sizeBodyContents: function(width, height) {
var size = this.adjustForGrow(width, height);
this.setElementSize(this.owner.inputEl, size[0], size[1]);
},
adjustForGrow: function(width, height) {
var me = this,
owner = me.owner,
inputEl, value, calcWidth,
result = [width, height];
if (owner.grow) {
inputEl = owner.inputEl;
value = (inputEl.dom.value || (owner.hasFocus ? '' : owner.emptyText) || '') + owner.growAppend;
calcWidth = inputEl.getTextWidth(value) + inputEl.getBorderWidth("lr") + inputEl.getPadding("lr");
result[0] = Ext.Number.constrain(calcWidth, owner.growMin,
Math.max(owner.growMin, Math.min(owner.growMax, Ext.isNumber(width) ? width : Infinity)));
}
return result;
}
});
Ext.define('Ext.layout.component.field.TextArea', {
extend: 'Ext.layout.component.field.Text',
alias: 'layout.textareafield',
type: 'textareafield',
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);
curHeight = inputEl.getHeight();
value = inputEl.dom.value || ' ';
value += owner.growAppend;
value = value.replace(/\n/g, 'size="{size}" ',
'tabIndex="{tabIdx}" ',
'class="{fieldCls} {typeCls}" autocomplete="off" />',
{
compiled: true,
disableFormats: true
}
],
inputType: 'text',
invalidText : 'The value in this field is invalid',
fieldCls : Ext.baseCSSPrefix + 'form-field',
focusCls : Ext.baseCSSPrefix + 'form-focus',
dirtyCls : Ext.baseCSSPrefix + 'form-dirty',
checkChangeEvents: Ext.isIE && (!document.documentMode || document.documentMode < 9) ?
['change', 'propertychange'] :
['change', 'input', 'textInput', 'keyup', 'dragdrop'],
checkChangeBuffer: 50,
componentLayout: 'field',
readOnly : false,
readOnlyCls: Ext.baseCSSPrefix + 'form-readonly',
validateOnBlur: true,
hasFocus : false,
baseCls: Ext.baseCSSPrefix + 'field',
maskOnDisable: false,
initComponent : function() {
var me = this;
me.callParent();
me.subTplData = me.subTplData || {};
me.addEvents(
'focus',
'blur',
'specialkey'
);
me.initLabelable();
me.initField();
if (!me.name) {
me.name = me.getInputId();
}
},
getInputId: function() {
return this.inputId || (this.inputId = Ext.id());
},
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)
});
},
getSubTplMarkup: function() {
return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
},
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());
},
setFieldStyle: function(style) {
var me = this,
inputEl = me.inputEl;
if (inputEl) {
inputEl.applyStyles(style);
}
me.fieldStyle = style;
},
onRender : function() {
var me = this,
fieldStyle = me.fieldStyle,
renderSelectors = me.renderSelectors;
Ext.applyIf(renderSelectors, me.getLabelableSelectors());
Ext.applyIf(renderSelectors, {
inputEl: '.' + me.fieldCls
});
me.callParent(arguments);
me.setRawValue(me.rawValue);
if (me.readOnly) {
me.setReadOnly(true);
}
if (me.disabled) {
me.disable();
}
if (fieldStyle) {
me.setFieldStyle(fieldStyle);
}
me.renderActiveError();
},
initAria: function() {
var me = this;
me.callParent();
me.getActionEl().dom.setAttribute('aria-describedby', Ext.id(me.errorEl));
},
getFocusEl: function() {
return this.inputEl;
},
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;
},
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;
},
getSubmitValue: function() {
return this.processRawValue(this.getRawValue());
},
getRawValue: function() {
var me = this,
v = (me.inputEl ? me.inputEl.getValue() : Ext.value(me.rawValue, ''));
me.rawValue = v;
return v;
},
setRawValue: function(value) {
var me = this;
value = Ext.value(value, '');
me.rawValue = value;
if (me.inputEl) {
me.inputEl.dom.value = value;
}
return value;
},
valueToRaw: function(value) {
return '' + Ext.value(value, '');
},
rawToValue: function(rawValue) {
return rawValue;
},
processRawValue: function(value) {
return value;
},
getValue: function() {
var me = this,
val = me.rawToValue(me.processRawValue(me.getRawValue()));
me.value = val;
return val;
},
setValue: function(value) {
var me = this;
me.setRawValue(me.valueToRaw(value));
return me.mixins.field.setValue.call(me, value);
},
onDisable: function() {
var me = this,
inputEl = me.inputEl;
me.callParent();
if (inputEl) {
inputEl.dom.disabled = true;
}
},
onEnable: function() {
var me = this,
inputEl = me.inputEl;
me.callParent();
if (inputEl) {
inputEl.dom.disabled = false;
}
},
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;
},
fireKey: function(e){
if(e.isSpecialKey()){
this.fireEvent('specialkey', this, Ext.create('Ext.EventObjectImpl', e));
}
},
initEvents : function(){
var me = this,
inputEl = me.inputEl,
onChangeTask,
onChangeEvent;
if (inputEl) {
me.mon(inputEl, Ext.EventManager.getKeyEvent(), me.fireKey, me);
me.mon(inputEl, 'focus', me.onFocus, me);
me.mon(inputEl, 'blur', me.onBlur, me, me.inEditor ? {buffer:10} : null);
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();
},
doComponentLayout: function() {
var me = this,
inputEl = me.inputEl,
usesPropertychange = me.usesPropertychange,
ename = 'propertychange',
onChangeEvent = me.onChangeEvent;
if (usesPropertychange) {
me.mun(inputEl, ename, onChangeEvent);
}
me.callParent(arguments);
if (usesPropertychange) {
me.mon(inputEl, ename, onChangeEvent);
}
},
preFocus: Ext.emptyFn,
onFocus: function() {
var me = this,
focusCls = me.focusCls,
inputEl = me.inputEl;
me.preFocus();
if (focusCls && inputEl) {
inputEl.addCls(focusCls);
}
if (!me.hasFocus) {
me.hasFocus = true;
me.fireEvent('focus', me);
}
},
beforeBlur : Ext.emptyFn,
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();
},
postBlur : Ext.emptyFn,
onDirtyChange: function(isDirty) {
this[isDirty ? 'addCls' : 'removeCls'](this.dirtyCls);
},
isValid : function() {
var me = this;
return me.disabled || me.validateValue(me.processRawValue(me.getRawValue()));
},
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);
}
}
return isValid;
},
markInvalid : function(errors) {
var me = this,
oldMsg = me.getActiveError();
me.setActiveErrors(Ext.Array.from(errors));
if (oldMsg !== me.getActiveError()) {
me.doComponentLayout();
}
},
clearInvalid : function() {
var me = this,
hadError = me.hasActiveError();
me.unsetActiveError();
if (hadError) {
me.doComponentLayout();
}
},
renderActiveError: function() {
var me = this,
hasError = me.hasActiveError();
if (me.inputEl) {
me.inputEl[hasError ? 'addCls' : 'removeCls'](me.invalidCls + '-field');
}
me.mixins.labelable.renderActiveError.call(me);
},
getActionEl: function() {
return this.inputEl || this.el;
}
});
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'],
size: 20,
growMin : 30,
growMax : 800,
growAppend: 'W',
allowBlank : true,
minLength : 0,
maxLength : Number.MAX_VALUE,
minLengthText : 'The minimum length for this field is {0}',
maxLengthText : 'The maximum length for this field is {0}',
blankText : 'This field is required',
regexText : '',
emptyCls : Ext.baseCSSPrefix + 'form-empty-field',
ariaRole: 'textbox',
componentLayout: 'textfield',
initComponent : function(){
this.callParent();
this.addEvents(
'autosize',
'keydown',
'keyup',
'keypress'
);
},
initEvents : function(){
var me = this,
el = me.inputEl;
me.callParent();
if(me.selectOnFocus || me.emptyText){
me.mon(el, 'mousedown', me.onMouseDown, me);
}
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
});
}
},
isEqual: function(value1, value2) {
return String(Ext.value(value1, '')) === String(Ext.value(value2, ''));
},
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();
},
onMouseDown: function(e){
var me = this;
if(!me.hasFocus){
me.mon(me.inputEl, 'mouseup', Ext.emptyFn, me, { single: true, preventDefault: true });
}
},
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;
},
onDisable: function(){
this.callParent();
if (Ext.isIE) {
this.inputEl.dom.unselectable = 'on';
}
},
onEnable: function(){
this.callParent();
if (Ext.isIE) {
this.inputEl.dom.unselectable = '';
}
},
onKeyDown: function(e) {
this.fireEvent('keydown', this, e);
},
onKeyUp: function(e) {
this.fireEvent('keyup', this, e);
},
onKeyPress: function(e) {
this.fireEvent('keypress', this, e);
},
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);
}
if (isEmpty) {
me.inputEl.addCls(me.emptyCls);
}
me.autoSize();
}
},
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 (me.selectOnFocus || isEmpty) {
inputEl.dom.select();
}
},
onFocus: function() {
var me = this;
me.callParent(arguments);
if (me.emptyText) {
me.autoSize();
}
},
postBlur : function(){
this.applyEmptyText();
},
filterKeys : function(e){
if(e.ctrlKey){
return;
}
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(!this.maskRe.test(charCode)){
e.stopEvent();
}
},
getRawValue: function() {
var me = this,
v = me.callParent();
if (v === me.emptyText) {
v = '';
}
return v;
},
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;
},
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 (value.length < 1 || value === emptyText) {
if (!allowBlank) {
errors.push(me.blankText);
}
return errors;
}
if (value.length < me.minLength) {
errors.push(format(me.minLengthText, me.minLength));
}
if (value.length > me.maxLength) {
errors.push(format(me.maxLengthText, me.maxLength));
}
if (vtype) {
if(!vtypes[vtype](value, me)){
errors.push(me.vtypeText || vtypes[vtype +'Text']);
}
}
if (regex && !regex.test(value)) {
errors.push(me.regexText || me.invalidText);
}
return errors;
},
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();
}
},
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;
}
}
},
initAria: function() {
this.callParent();
this.getActionEl().dom.setAttribute('aria-required', this.allowBlank === false);
},
getBodyNaturalWidth: function() {
return Math.round(this.size * 6.5) + 20;
}
});
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
}
],
growMin: 60,
growMax: 1000,
growAppend: '\n-',
cols: 20,
rows: 4,
enterIsSpecial: false,
preventScrollbars: false,
componentLayout: 'textareafield',
onRender: function(ct, position) {
var me = this;
Ext.applyIf(me.subTplData, {
cols: me.cols,
rows: me.rows
});
me.callParent(arguments);
},
afterRender: function(){
var me = this;
me.callParent(arguments);
if (me.grow) {
if (me.preventScrollbars) {
me.inputEl.setStyle('overflow', 'hidden');
}
me.inputEl.setHeight(me.growMin);
}
},
fireKey: function(e) {
if (e.isSpecialKey() && (this.enterIsSpecial || (e.getKey() !== e.ENTER || e.hasModifier()))) {
this.fireEvent('specialkey', this, e);
}
},
autoSize: function() {
var me = this,
height;
if (me.grow && me.rendered) {
me.doComponentLayout();
height = me.inputEl.getHeight();
if (height !== me.lastInputHeight) {
me.fireEvent('autosize', height);
me.lastInputHeight = height;
}
}
},
initAria: function() {
this.callParent(arguments);
this.getActionEl().dom.setAttribute('aria-multiline', true);
},
getBodyNaturalWidth: function() {
return Math.round(this.cols * 6.5) + 20;
}
});
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',
OK : 1,
YES : 2,
NO : 4,
CANCEL : 8,
OKCANCEL : 9,
YESNO : 6,
YESNOCANCEL : 14,
INFO : 'ext-mb-info',
WARNING : 'ext-mb-warning',
QUESTION : 'ext-mb-question',
ERROR : 'ext-mb-error',
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'
},
defaultTextHeight : 75,
minProgressWidth : 250,
minPromptWidth: 250,
buttonText: {
ok: 'OK',
yes: 'Yes',
no: 'No',
cancel: 'Cancel'
},
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();
}
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];
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;
}
delete me.defaultFocus;
me.animateTarget = cfg.animateTarget || undefined;
me.modal = cfg.modal !== false;
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);
me.closable = cfg.closable && !cfg.wait;
if (cfg.closable === false) {
me.tools.close.hide();
} else {
me.tools.close.show();
}
if (!cfg.title && !me.closable) {
me.header.hide();
} else {
me.header.show();
}
me.liveDrag = !cfg.proxyDrag;
me.userCallback = Ext.Function.bind(cfg.callback ||cfg.fn || Ext.emptyFn, cfg.scope || Ext.global);
me.setIcon(cfg.icon);
if (cfg.msg) {
me.msg.update(cfg.msg);
me.msg.show();
} else {
me.msg.hide();
}
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();
}
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();
}
for (i = 0; i < 4; i++) {
if (buttons & Math.pow(2, i)) {
if (!me.defaultFocus) {
me.defaultFocus = me.msgButtons[i];
}
me.msgButtons[i].show();
hideToolbar = false;
} else {
me.msgButtons[i].hide();
}
}
if (hideToolbar) {
me.bottomTb.hide();
} else {
me.bottomTb.show();
}
me.hidden = true;
},
show: function(cfg) {
var me = this;
me.reconfigure(cfg);
me.addCls(cfg.cls);
if (cfg.animateTarget) {
me.doAutoSize(false);
me.callParent();
} else {
me.callParent();
me.doAutoSize(true);
}
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();
}
icon.setHeight(iconHeight);
me.minWidth = me.cfg.minWidth || Ext.getClass(this).prototype.minWidth;
me.topContainer.doLayout();
if (Ext.isIE6 || Ext.isIEQuirks) {
me.textField.setCalculatedSize(9);
me.textArea.setCalculatedSize(9);
}
var width = me.cfg.width || me.msg.getWidth() + icon.getWidth() + 25,
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 ;
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);
},
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;
},
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);
}
},
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);
},
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);
},
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);
},
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);
},
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();
});
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'],
constructor: function(owner, config) {
var me = this,
onItemAddOrRemove = me.onItemAddOrRemove;
me.owner = owner;
me.mon(owner, {
add: onItemAddOrRemove,
remove: onItemAddOrRemove,
scope: me
});
Ext.apply(me, config);
if (Ext.isString(me.paramOrder)) {
me.paramOrder = me.paramOrder.split(/[\s,|]/);
}
me.checkValidityTask = Ext.create('Ext.util.DelayedTask', me.checkValidity, me);
me.addEvents(
'beforeaction',
'actionfailed',
'actioncomplete',
'validitychange',
'dirtychange'
);
me.callParent();
},
initialize: function(){
this.initialized = true;
this.onValidityChange(!this.hasInvalidField());
},
timeout: 30,
paramsAsHash: false,
waitTitle: 'Please Wait...',
trackResetOnLoad: false,
wasDirty: false,
destroy: function() {
this.clearListeners();
this.checkValidityTask.cancel();
},
onItemAddOrRemove: function(parent, child) {
var me = this,
isAdding = !!child.ownerCt,
isContainer = child.isContainer;
function handleField(field) {
me[isAdding ? 'mon' : 'mun'](field, {
validitychange: me.checkValidity,
dirtychange: me.checkDirty,
scope: me,
buffer: 100
});
delete me._fields;
}
if (child.isFormField) {
handleField(child);
}
else if (isContainer) {
Ext.Array.forEach(child.query('[isFormField]'), handleField);
}
delete this._boundItems;
if (me.initialized) {
me.checkValidityTask.delay(10);
}
},
getFields: function() {
var fields = this._fields;
if (!fields) {
fields = this._fields = Ext.create('Ext.util.MixedCollection');
fields.addAll(this.owner.query('[isFormField]'));
}
return fields;
},
getBoundItems: function() {
var boundItems = this._boundItems;
if (!boundItems) {
boundItems = this._boundItems = Ext.create('Ext.util.MixedCollection');
boundItems.addAll(this.owner.query('[formBind]'));
}
return boundItems;
},
hasInvalidField: function() {
return !!this.getFields().findBy(function(field) {
var preventMark = field.preventMark,
isValid;
field.preventMark = true;
isValid = field.isValid();
field.preventMark = preventMark;
return !isValid;
});
},
isValid: function() {
var me = this,
invalid;
me.batchLayouts(function() {
invalid = me.getFields().filterBy(function(field) {
return !field.validate();
});
});
return invalid.length < 1;
},
checkValidity: function() {
var me = this,
valid = !me.hasInvalidField();
if (valid !== me.wasValid) {
me.onValidityChange(valid);
me.fireEvent('validitychange', me, valid);
me.wasValid = valid;
}
},
onValidityChange: function(valid) {
var boundItems = this.getBoundItems();
if (boundItems) {
boundItems.each(function(cmp) {
if (cmp.disabled === valid) {
cmp.setDisabled(!valid);
}
});
}
},
isDirty: function() {
return !!this.getFields().findBy(function(f) {
return f.isDirty();
});
},
checkDirty: function() {
var dirty = this.isDirty();
if (dirty !== this.wasDirty) {
this.fireEvent('dirtychange', this, dirty);
this.wasDirty = dirty;
}
},
hasUpload: function() {
return !!this.getFields().findBy(function(f) {
return f.isFileUpload();
});
},
doAction: function(action, options) {
if (Ext.isString(action)) {
action = Ext.ClassManager.instantiateByAlias('formaction.' + action, Ext.apply({}, options, {form: this}));
}
if (this.fireEvent('beforeaction', this, action) !== false) {
this.beforeAction(action);
Ext.defer(action.run, 100, action);
}
return this;
},
submit: function(options) {
return this.doAction(this.standardSubmit ? 'standardsubmit' : this.api ? 'directsubmit' : 'submit', options);
},
load: function(options) {
return this.doAction(this.api ? 'directload' : 'load', options);
},
updateRecord: function(record) {
var fields = record.fields,
values = this.getFieldValues(),
name,
obj = {};
fields.each(function(f) {
name = f.name;
if (name in values) {
obj[name] = values[name];
}
});
record.beginEdit();
record.set(obj);
record.endEdit();
return this;
},
loadRecord: function(record) {
this._record = record;
return this.setValues(record.data);
},
getRecord: function() {
return this._record;
},
beforeAction: function(action) {
var waitMsg = action.waitMsg,
maskCls = Ext.baseCSSPrefix + 'mask-loading',
waitMsgTarget;
this.getFields().each(function(f) {
if (f.isFormField && f.syncValue) {
f.syncValue();
}
});
if (waitMsg) {
waitMsgTarget = this.waitMsgTarget;
if (waitMsgTarget === true) {
this.owner.el.mask(waitMsg, maskCls);
} else if (waitMsgTarget) {
waitMsgTarget = this.waitMsgTarget = Ext.get(waitMsgTarget);
waitMsgTarget.mask(waitMsg, maskCls);
} else {
Ext.MessageBox.wait(waitMsg, action.waitTitle || this.waitTitle);
}
}
},
afterAction: function(action, success) {
if (action.waitMsg) {
var MessageBox = Ext.MessageBox,
waitMsgTarget = this.waitMsgTarget;
if (waitMsgTarget === true) {
this.owner.el.unmask();
} else if (waitMsgTarget) {
waitMsgTarget.unmask();
} else {
MessageBox.updateProgress(1);
MessageBox.hide();
}
}
if (success) {
if (action.reset) {
this.reset();
}
Ext.callback(action.success, action.scope || action, [this, action]);
this.fireEvent('actioncomplete', this, action);
} else {
Ext.callback(action.failure, action.scope || action, [this, action]);
this.fireEvent('actionfailed', this, action);
}
},
findField: function(id) {
return this.getFields().findBy(function(f) {
return f.id === id || f.getName() === id;
});
},
markInvalid: function(errors) {
var me = this;
function mark(fieldId, msg) {
var field = me.findField(fieldId);
if (field) {
field.markInvalid(msg);
}
}
if (Ext.isArray(errors)) {
Ext.each(errors, function(err) {
mark(err.id, err.msg);
});
}
else if (errors instanceof Ext.data.Errors) {
errors.each(function(err) {
mark(err.field, err.message);
});
}
else {
Ext.iterate(errors, mark);
}
return this;
},
setValues: function(values) {
var me = this;
function setVal(fieldId, val) {
var field = me.findField(fieldId);
if (field) {
field.setValue(val);
if (me.trackResetOnLoad) {
field.resetOriginalValue();
}
}
}
if (Ext.isArray(values)) {
Ext.each(values, function(val) {
setVal(val.id, val.value);
});
} else {
Ext.iterate(values, setVal);
}
return this;
},
getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
var values = {};
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;
}
});
}
}
});
if (asString) {
values = Ext.Object.toQueryString(values);
}
return values;
},
getFieldValues: function(dirtyOnly) {
return this.getValues(false, dirtyOnly, false, true);
},
clearInvalid: function() {
var me = this;
me.batchLayouts(function() {
me.getFields().each(function(f) {
f.clearInvalid();
});
});
return me;
},
reset: function() {
var me = this;
me.batchLayouts(function() {
me.getFields().each(function(f) {
f.reset();
});
});
return me;
},
applyToFields: function(obj) {
this.getFields().each(function(f) {
Ext.apply(f, obj);
});
return this;
},
applyIfToFields: function(obj) {
this.getFields().each(function(f) {
Ext.applyIf(f, obj);
});
return this;
},
batchLayouts: function(fn) {
var me = this,
suspended = new Ext.util.HashMap();
me.getFields().each(function(field) {
var ownerCt = field.ownerCt;
if (!suspended.contains(ownerCt)) {
suspended.add(ownerCt);
ownerCt.oldSuspendLayout = ownerCt.suspendLayout;
ownerCt.suspendLayout = true;
}
});
fn();
suspended.each(function(id, ct) {
ct.suspendLayout = ct.oldSuspendLayout;
delete ct.oldSuspendLayout;
});
me.owner.doComponentLayout();
}
});
Ext.define('Ext.form.FieldAncestor', {
initFieldAncestor: function() {
var me = this,
onSubtreeChange = me.onFieldAncestorSubtreeChange;
me.addEvents(
'fieldvaliditychange',
'fielderrorchange'
);
me.on('add', onSubtreeChange, me);
me.on('remove', onSubtreeChange, me);
me.initFieldDefaults();
},
initFieldDefaults: function() {
if (!this.fieldDefaults) {
this.fieldDefaults = {};
}
},
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);
}
if (isField) {
me['onField' + (isAdding ? 'Added' : 'Removed')](cmp);
}
}
else if (cmp.isContainer) {
Ext.Array.forEach(cmp.getRefItems(), handleCmp);
}
}
handleCmp(child);
},
onLabelableAdded: function(labelable) {
var me = this;
me.mon(labelable, 'errorchange', me.handleFieldErrorChange, me, {buffer: 10});
labelable.setFieldDefaults(me.fieldDefaults);
},
onFieldAdded: function(field) {
var me = this;
me.mon(field, 'validitychange', me.handleFieldValidityChange, me);
},
onLabelableRemoved: function(labelable) {
var me = this;
me.mun(labelable, 'errorchange', me.handleFieldErrorChange, me);
},
onFieldRemoved: function(field) {
var me = this;
me.mun(field, 'validitychange', me.handleFieldValidityChange, me);
},
handleFieldValidityChange: function(field, isValid) {
var me = this;
me.fireEvent('fieldvaliditychange', me, field, isValid);
me.onFieldValidityChange();
},
handleFieldErrorChange: function(labelable, activeError) {
var me = this;
me.fireEvent('fielderrorchange', me, labelable, activeError);
me.onFieldErrorChange();
},
onFieldValidityChange: Ext.emptyFn,
onFieldErrorChange: Ext.emptyFn
});
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;
shadowItems.each(function(col) {
col.items.clear();
});
while (shadowItems.length > numCols) {
shadowCt.remove(shadowItems.last());
}
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++;
}
shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
} else {
for (i = 0; i < numItems; i++) {
colIndex = i % numCols;
shadowItems.getAt(colIndex).items.add(items.getAt(i));
}
}
if (!shadowCt.rendered) {
shadowCt.render(this.getRenderTarget());
} else {
shadowItems.each(function(col) {
var layout = col.getLayout();
layout.renderItems(layout.getLayoutItems(), layout.getRenderTarget());
});
}
shadowCt.doComponentLayout();
},
renderItems: Ext.emptyFn,
getShadowCt: function() {
var me = this,
shadowCt = me.shadowCt,
owner, items, item, columns, columnsIsArray, numCols, i;
if (!shadowCt) {
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) {
if (columns[i] < 1) {
item.flex = columns[i];
} else {
item.width = columns[i];
}
}
else {
item.flex = 1;
}
items.push(item);
}
shadowCt = me.shadowCt = Ext.createWidget('container', {
layout: 'hbox',
items: items,
ownerCt: owner
});
}
return shadowCt;
},
getColCount: function() {
var owner = this.owner,
colsCfg = owner.columns;
return Ext.isArray(colsCfg) ? colsCfg.length : (Ext.isNumber(colsCfg) ? colsCfg : owner.items.length);
}
});
Ext.define('Ext.form.FieldContainer', {
extend: 'Ext.container.Container',
mixins: {
labelable: 'Ext.form.Labelable',
fieldAncestor: 'Ext.form.FieldAncestor'
},
alias: 'widget.fieldcontainer',
componentLayout: 'field',
combineLabels: false,
labelConnector: ', ',
combineErrors: false,
maskOnDisable: false,
initComponent: function() {
var me = this,
onSubCmpAddOrRemove = me.onSubCmpAddOrRemove;
me.initLabelable();
me.initFieldAncestor();
me.callParent();
},
onLabelableAdded: function(labelable) {
var me = this;
me.mixins.fieldAncestor.onLabelableAdded.call(this, labelable);
me.updateLabel();
},
onLabelableRemoved: function(labelable) {
var me = this;
me.mixins.fieldAncestor.onLabelableRemoved.call(this, labelable);
me.updateLabel();
},
onRender: function() {
var me = this,
renderSelectors = me.renderSelectors,
applyIf = Ext.applyIf;
applyIf(renderSelectors, me.getLabelableSelectors());
me.callParent(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());
},
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;
},
updateLabel: function() {
var me = this,
label = me.labelEl;
if (label) {
label.update(me.getFieldLabel());
}
},
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();
}
}
},
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();
}
});
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'],
columns : 'auto',
vertical : false,
allowBlank : true,
blankText : "You must select at least one item in this group",
defaultType : 'checkboxfield',
groupCls : Ext.baseCSSPrefix + 'form-check-group',
fieldBodyCls: Ext.baseCSSPrefix + 'form-checkboxgroup-body',
layout: 'checkboxgroup',
initComponent: function() {
var me = this;
me.callParent();
me.initField();
},
initValue: function() {
var me = this,
valueCfg = me.value;
me.originalValue = me.lastValue = valueCfg || me.getValue();
if (valueCfg) {
me.setValue(valueCfg);
}
},
onFieldAdded: function(field) {
var me = this;
if (field.isCheckbox) {
me.mon(field, 'change', me.checkChange, me);
}
me.callParent(arguments);
},
onFieldRemoved: function(field) {
var me = this;
if (field.isCheckbox) {
me.mun(field, 'change', me.checkChange, me);
}
me.callParent(arguments);
},
isEqual: function(value1, value2) {
var toQueryString = Ext.Object.toQueryString;
return toQueryString(value1) === toQueryString(value2);
},
getErrors: function() {
var errors = [];
if (!this.allowBlank && Ext.isEmpty(this.getChecked())) {
errors.push(this.blankText);
}
return errors;
},
getBoxes: function() {
return this.query('[isCheckbox]');
},
eachBox: function(fn, scope) {
Ext.Array.forEach(this.getBoxes(), fn, scope || this);
},
getChecked: function() {
return Ext.Array.filter(this.getBoxes(), function(cb) {
return cb.getValue();
});
},
isDirty: function(){
return Ext.Array.some(this.getBoxes(), function(cb) {
return cb.isDirty();
});
},
setReadOnly: function(readOnly) {
this.eachBox(function(cb) {
cb.setReadOnly(readOnly);
});
this.readOnly = readOnly;
},
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();
}
},
resetOriginalValue: function() {
Ext.defer(function() {
this.callParent();
}, 1, 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 {
cbValue = value[name];
}
}
cb.setValue(cbValue);
});
});
return me;
},
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;
},
getSubmitData: function() {
return null;
},
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.define('Ext.form.CheckboxManager', {
extend: 'Ext.util.MixedCollection',
singleton: true,
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.filterBy(function(item) {
return item.name == name && item.checked;
});
}
});
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'],
collapsed: false,
baseCls: Ext.baseCSSPrefix + 'fieldset',
layout: 'anchor',
componentLayout: 'fieldset',
ariaRole: '',
renderTpl: ['
'],
maskOnDisable: false,
getElConfig: function(){
return {tag: 'fieldset', id: this.id};
},
initComponent: function() {
var me = this,
baseCls = me.baseCls;
me.callParent();
me.initLegend();
Ext.applyIf(me.renderSelectors, {
body: '.' + baseCls + '-body'
});
if (me.collapsed) {
me.addCls(baseCls + '-collapsed');
me.collapse();
}
},
onRender: function(container, position) {
this.callParent(arguments);
this.initLegend();
},
initLegend: function() {
var me = this,
legendItems,
legend = me.legend;
if (!legend && (me.title || me.checkboxToggle || me.collapsible)) {
legendItems = [];
if (me.checkboxToggle) {
legendItems.push(me.createCheckboxCmp());
}
else if (me.collapsible) {
legendItems.push(me.createToggleCmp());
}
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
});
}
if (legend && !legend.rendered && me.rendered) {
me.legend.render(me.el, me.body);
}
},
createTitleCmp: function() {
var me = this;
me.titleCmp = Ext.create('Ext.Component', {
html: me.title,
cls: me.baseCls + '-header-text'
});
return me.titleCmp;
},
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;
},
createToggleCmp: function() {
var me = this;
me.toggleCmp = Ext.create('Ext.panel.Tool', {
type: 'toggle',
handler: me.toggle,
scope: me
});
return me.toggleCmp;
},
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;
},
getRefItems: function(deep) {
var refItems = this.callParent(arguments),
legend = this.legend;
if (legend) {
refItems.unshift(legend);
if (deep) {
refItems.unshift.apply(refItems, legend.getRefItems(true));
}
}
return refItems;
},
expand : function(){
return this.setExpanded(true);
},
collapse : function() {
return this.setExpanded(false);
},
setExpanded: function(expanded) {
var me = this,
checkboxCmp = me.checkboxCmp;
expanded = !!expanded;
if (checkboxCmp) {
checkboxCmp.setValue(expanded);
}
if (expanded) {
me.removeCls(me.baseCls + '-collapsed');
} else {
me.addCls(me.baseCls + '-collapsed');
}
me.collapsed = !expanded;
if (expanded) {
me.getComponentLayout().childrenChanged = true;
}
me.doComponentLayout();
return me;
},
toggle: function() {
this.setExpanded(!!this.collapsed);
},
onCheckChange: function(cmp, checked) {
this.setExpanded(checked);
},
beforeDestroy : function() {
var legend = this.legend;
if (legend) {
legend.destroy();
}
this.callParent();
}
});
Ext.define('Ext.form.Label', {
extend:'Ext.Component',
alias: 'widget.label',
requires: ['Ext.util.Format'],
maskOnDisable: false,
getElConfig: function(){
var me = this;
return {
tag: 'label',
id: me.id,
htmlFor: me.forId || '',
html: me.text ? Ext.util.Format.htmlEncode(me.text) : (me.html || '')
};
},
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;
}
if(me.rendered){
me.el.dom.innerHTML = encode !== false ? Ext.util.Format.htmlEncode(text) : text;
}
return this;
}
});
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'],
layout: 'anchor',
ariaRole: 'form',
initComponent: function() {
var me = this;
if (me.frame) {
me.border = false;
}
me.initFieldAncestor();
me.callParent();
me.relayEvents(me.form, [
'beforeaction',
'actionfailed',
'actioncomplete',
'validitychange',
'dirtychange'
]);
if (me.pollForChanges) {
me.startPolling(me.pollInterval || 500);
}
},
initItems: function() {
var me = this;
me.form = me.createForm();
me.callParent();
me.form.initialize();
},
createForm: function() {
return Ext.create('Ext.form.Basic', this, Ext.applyIf({listeners: {}}, this.initialConfig));
},
getForm: function() {
return this.form;
},
loadRecord: function(record) {
return this.getForm().loadRecord(record);
},
getRecord: function() {
return this.getForm().getRecord();
},
getValues: function() {
return this.getForm().getValues();
},
beforeDestroy: function() {
this.stopPolling();
this.form.destroy();
this.callParent();
},
load: function(options) {
this.form.load(options);
},
submit: function(options) {
this.form.submit(options);
},
disable: function(silent) {
this.callParent(arguments);
this.form.getFields().each(function(field) {
field.disable();
});
},
enable: function(silent) {
this.callParent(arguments);
this.form.getFields().each(function(field) {
field.enable();
});
},
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;
},
stopPolling: function() {
var task = this.pollTask;
if (task) {
task.stopAll();
delete this.pollTask;
}
},
checkChange: function() {
this.form.getFields().each(function(field) {
field.checkChange();
});
}
});
Ext.define('Ext.form.RadioGroup', {
extend: 'Ext.form.CheckboxGroup',
alias: 'widget.radiogroup',
allowBlank : true,
blankText : 'You must select one item in this group',
defaultType : 'radiofield',
groupCls : Ext.baseCSSPrefix + 'form-radio-group',
getBoxes: function() {
return this.query('[isRadio]');
}
});
Ext.define('Ext.form.RadioManager', {
extend: 'Ext.util.MixedCollection',
singleton: true,
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;
});
}
});
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());
},
getArgs: function() {
var me = this,
args = [],
form = me.form,
paramOrder = form.paramOrder,
params = me.getParams(),
i, len;
if (paramOrder) {
for (i = 0, len = paramOrder.length; i < len; i++) {
args.push(params[paramOrder[i]]);
}
}
else if (form.paramsAsHash) {
args.push(params);
}
args.push(me.onSuccess, me);
return args;
},
processResponse: function(result) {
return (this.result = result);
},
onSuccess: function(result, trans) {
if (trans.type == Ext.direct.Manager.self.exceptions.SERVER) {
result = {};
}
this.callParent([result]);
}
});
Ext.define('Ext.form.action.DirectSubmit', {
extend:'Ext.form.action.Submit',
requires: ['Ext.direct.Manager'],
alternateClassName: 'Ext.form.Action.DirectSubmit',
alias: 'formaction.directsubmit',
type: 'directsubmit',
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);
},
processResponse: function(result) {
return (this.result = result);
},
onSuccess: function(response, trans) {
if (trans.type === Ext.direct.Manager.self.exceptions.SERVER) {
response = {};
}
this.callParent([response]);
}
});
Ext.define('Ext.form.action.StandardSubmit', {
extend:'Ext.form.action.Submit',
alias: 'formaction.standardsubmit',
doSubmit: function() {
var form = this.buildForm();
form.submit();
Ext.removeNode(form);
}
});
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: [
'',
'{boxLabel} ',
' ',
'',
'{boxLabel} ',
' ',
{
disableFormats: true,
compiled: true
}
],
isCheckbox: true,
focusCls: Ext.baseCSSPrefix + 'form-cb-focus',
fieldBodyCls: Ext.baseCSSPrefix + 'form-cb-wrap',
checked: false,
checkedCls: Ext.baseCSSPrefix + 'form-cb-checked',
boxLabelCls: Ext.baseCSSPrefix + 'form-cb-label',
boxLabelAlign: 'after',
inputValue: 'on',
checkChangeEvents: [],
inputType: 'checkbox',
ariaRole: 'checkbox',
onRe: /^on$/i,
initComponent: function(){
this.callParent(arguments);
this.getManager().add(this);
},
initValue: function() {
var me = this,
checked = !!me.checked;
me.originalValue = me.lastValue = checked;
me.setValue(checked);
},
onRender : function(ct, position) {
var me = this;
Ext.applyIf(me.renderSelectors, {
boxLabelEl: 'label.' + me.boxLabelCls
});
Ext.applyIf(me.subTplData, {
boxLabel: me.boxLabel,
boxLabelCls: me.boxLabelCls,
boxLabelAlign: me.boxLabelAlign
});
me.callParent(arguments);
},
initEvents: function() {
var me = this;
me.callParent();
me.mon(me.inputEl, 'click', me.onBoxClick, me);
},
onBoxClick: function(e) {
var me = this;
if (!me.disabled && !me.readOnly) {
this.setValue(!this.checked);
}
},
getRawValue: function() {
return this.checked;
},
getValue: function() {
return this.checked;
},
getSubmitValue: function() {
var unchecked = this.uncheckedValue,
uncheckedVal = Ext.isDefined(unchecked) ? unchecked : null;
return this.checked ? this.inputValue : uncheckedVal;
},
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);
}
me.checked = me.rawValue = checked;
return checked;
},
setValue: function(checked) {
var me = this;
if (Ext.isArray(checked)) {
me.getManager().getByName(me.name).each(function(cb) {
cb.setValue(Ext.Array.contains(checked, cb.inputValue));
});
} else {
me.callParent(arguments);
}
return me;
},
valueToRaw: function(value) {
return value;
},
onChange: function(newVal, oldVal) {
var me = this,
handler = me.handler;
if (handler) {
handler.call(me.scope || me, me, newVal);
}
me.callParent(arguments);
},
getManager: function() {
return Ext.form.CheckboxManager;
},
onEnable: function() {
var me = this,
inputEl = me.inputEl;
me.callParent();
if (inputEl) {
inputEl.dom.disabled = me.readOnly;
}
},
setReadOnly: function(readOnly) {
var me = this,
inputEl = me.inputEl;
if (inputEl) {
inputEl.dom.disabled = readOnly || me.disabled;
}
me.readOnly = readOnly;
},
getBodyNaturalWidth: function() {
var me = this,
bodyEl = me.bodyEl,
ws = 'white-space',
width;
bodyEl.setStyle(ws, 'nowrap');
width = bodyEl.getWidth();
bodyEl.setStyle(ws, '');
return width;
}
});
Ext.define('Ext.layout.component.field.Trigger', {
alias: ['layout.triggerfield'],
extend: 'Ext.layout.component.field.Field',
type: 'triggerfield',
sizeBodyContents: function(width, height) {
var me = this,
owner = me.owner,
inputEl = owner.inputEl,
triggerWrap = owner.triggerWrap,
triggerWidth = owner.getTriggerWidth();
if (owner.hideTrigger || owner.readOnly || triggerWidth > 0) {
me.setElementSize(inputEl, Ext.isNumber(width) ? width - triggerWidth : width);
triggerWrap.setWidth(triggerWidth);
}
}
});
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(
'beforeitemmousedown',
'beforeitemmouseup',
'beforeitemmouseenter',
'beforeitemmouseleave',
'beforeitemclick',
'beforeitemdblclick',
'beforeitemcontextmenu',
'beforeitemkeydown',
'itemmousedown',
'itemmouseup',
'itemmouseenter',
'itemmouseleave',
'itemclick',
'itemdblclick',
'itemcontextmenu',
'itemkeydown',
'beforecontainermousedown',
'beforecontainermouseup',
'beforecontainermouseover',
'beforecontainermouseout',
'beforecontainerclick',
'beforecontainerdblclick',
'beforecontainercontextmenu',
'beforecontainerkeydown',
'containermouseup',
'containermouseover',
'containermouseout',
'containerclick',
'containerdblclick',
'containercontextmenu',
'containerkeydown',
'selectionchange',
'beforeselect'
);
},
afterRender: function(){
var me = this,
listeners;
me.callParent();
listeners = {
scope: me,
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
};
me.mon(me.getTargetEl(), listeners);
if (me.store) {
me.bindStore(me.store, true);
}
},
handleEvent: function(e) {
if (this.processUIEvent(e) !== false) {
this.processSpecialEvent(e);
}
},
processItemEvent: Ext.emptyFn,
processContainerEvent: Ext.emptyFn,
processSpecialEvent: Ext.emptyFn,
stillOverItem: function (event, overItem) {
var nowOver;
if (overItem && typeof(overItem.offsetParent) === "object") {
nowOver = (event.type == 'mouseout') ? event.getRelatedTarget() : event.getTarget();
return Ext.fly(overItem).contains(nowOver);
}
return false;
},
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;
if (!item) {
if (type == 'mouseover' && me.stillOverItem(e, overItem)) {
item = overItem;
}
if (type == 'keydown') {
record = me.getSelectionModel().getLastSelected();
if (record) {
item = me.getNode(record);
}
}
}
if (item) {
index = me.indexOf(item);
if (!record) {
record = me.getRecord(item);
}
if (me.processItemEvent(record, item, index, e) === false) {
return false;
}
newType = me.isNewItemEvent(item, e);
if (newType === false) {
return false;
}
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;
}
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 true;
},
isNewItemEvent: function (item, e) {
var me = this,
overItem = me.mouseOverItem,
type = e.type;
switch (type) {
case 'mouseover':
if (item === overItem) {
return false;
}
me.mouseOverItem = item;
return 'mouseenter';
case 'mouseout':
if (me.stillOverItem(e, overItem)) {
return false;
}
me.mouseOverItem = null;
return 'mouseleave';
}
return type;
},
onItemMouseEnter: function(record, item, index, e) {
if (this.trackOver) {
this.highlightItem(item);
}
},
onItemMouseLeave : function(record, item, index, e) {
if (this.trackOver) {
this.clearHighlight();
}
},
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,
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,
highlightItem: function(item) {
var me = this;
me.clearHighlight();
me.highlightedItem = item;
Ext.fly(item).addCls(me.overItemCls);
},
clearHighlight: function() {
var me = this,
highlighted = me.highlightedItem;
if (highlighted) {
Ext.fly(highlighted).removeCls(me.overItemCls);
delete me.highlightedItem;
}
},
refresh: function() {
var me = this;
me.clearHighlight();
me.callParent(arguments);
if (!me.isFixedHeight()) {
me.doComponentLayout();
}
}
});
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;
},
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) {
el.setXY([-9999,-9999]);
}
me.setTargetSize(width, height);
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);
}
}
}
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);
}
}
}
if (floating) {
el.setXY(xy);
}
},
afterLayout: function() {
var me = this,
toolbar = me.owner.pagingToolbar;
me.callParent();
if (toolbar) {
toolbar.doComponentLayout();
}
},
setTargetSize : function(width, height) {
var me = this,
owner = me.owner,
listHeight = null,
toolbar;
if (Ext.isNumber(height)) {
listHeight = height - owner.el.getFrameWidth('tb');
toolbar = owner.pagingToolbar;
if (toolbar) {
listHeight -= toolbar.getHeight();
}
}
me.setElementSize(owner.listEl, null, listHeight);
me.callParent(arguments);
}
});
Ext.define('Ext.toolbar.TextItem', {
extend: 'Ext.toolbar.Item',
requires: ['Ext.XTemplate'],
alias: 'widget.tbtext',
alternateClassName: 'Ext.Toolbar.TextItem',
text: '',
renderTpl: '{text}',
baseCls: Ext.baseCSSPrefix + 'toolbar-text',
onRender : function() {
Ext.apply(this.renderData, {
text: this.text
});
this.callParent(arguments);
},
setText : function(t) {
if (this.rendered) {
this.el.update(t);
this.ownerCt.doLayout();
} else {
this.text = t;
}
}
});
Ext.define('Ext.form.field.Trigger', {
extend:'Ext.form.field.Text',
alias: ['widget.triggerfield', 'widget.trigger'],
requires: ['Ext.core.DomHelper', 'Ext.util.ClickRepeater', 'Ext.layout.component.field.Trigger'],
alternateClassName: ['Ext.form.TriggerField', 'Ext.form.TwinTriggerField', 'Ext.form.Trigger'],
fieldSubTpl: [
'size="{size}" ',
'tabIndex="{tabIdx}" ',
'class="{fieldCls} {typeCls}" autocomplete="off" />',
'',
{
compiled: true,
disableFormats: true
}
],
triggerBaseCls: Ext.baseCSSPrefix + 'form-trigger',
triggerWrapCls: Ext.baseCSSPrefix + 'form-trigger-wrap',
hideTrigger: false,
editable: true,
readOnly: false,
repeatTriggerClick: false,
autoSize: Ext.emptyFn,
monitorTab: true,
mimicing: false,
triggerIndexRe: /trigger-index-(\d+)/,
componentLayout: 'triggerfield',
initComponent: function() {
this.wrapFocusCls = this.triggerWrapCls + '-focus';
this.callParent(arguments);
},
onRender: function(ct, position) {
var me = this,
triggerCls,
triggerBaseCls = me.triggerBaseCls,
triggerWrapCls = me.triggerWrapCls,
triggerConfigs = [],
i;
if (!me.trigger1Cls) {
me.trigger1Cls = me.triggerCls;
}
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, {
triggerWrap: '.' + triggerWrapCls
});
Ext.applyIf(me.subTplData, {
triggerWrapCls: triggerWrapCls,
triggerEl: Ext.core.DomHelper.markup(triggerConfigs),
clearCls: me.clearCls
});
me.callParent(arguments);
me.triggerEl = Ext.select('.' + triggerBaseCls, true, me.triggerWrap.dom);
me.doc = Ext.isIE ? Ext.getBody() : Ext.getDoc();
me.initTrigger();
},
onEnable: function() {
this.callParent();
this.triggerWrap.unmask();
},
onDisable: function() {
this.callParent();
this.triggerWrap.mask();
},
afterRender: function() {
this.callParent();
this.updateEditState();
},
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;
}
triggerWrap.setDisplayed(displayed);
inputEl.dom.readOnly = readOnly;
me.doComponentLayout();
}
},
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;
},
setHideTrigger: function(hideTrigger) {
if (hideTrigger != this.hideTrigger) {
this.hideTrigger = hideTrigger;
this.updateEditState();
}
},
setEditable: function(editable) {
if (editable != this.editable) {
this.editable = editable;
this.updateEditState();
}
},
setReadOnly: function(readOnly) {
if (readOnly != this.readOnly) {
this.readOnly = readOnly;
this.updateEditState();
}
},
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);
}
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');
});
},
onDestroy: function() {
var me = this;
Ext.destroyMembers(me, 'triggerRepeater', 'triggerWrap', 'triggerEl');
delete me.doc;
me.callParent();
},
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);
}
}
},
checkTab: function(me, e) {
if (!this.ignoreMonitorTab && e.getKey() == e.TAB) {
this.triggerBlur();
}
},
onBlur: Ext.emptyFn,
mimicBlur: function(e) {
if (!this.isDestroyed && !this.bodyEl.contains(e.target) && this.validateBlur(e)) {
this.triggerBlur();
}
},
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,
validateBlur: function(e) {
return true;
},
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);
}
}
},
onTriggerClick: Ext.emptyFn
});
Ext.define('Ext.form.field.Picker', {
extend: 'Ext.form.field.Trigger',
alias: 'widget.pickerfield',
alternateClassName: 'Ext.form.Picker',
requires: ['Ext.util.KeyNav'],
matchFieldWidth: true,
pickerAlign: 'tl-bl?',
openCls: Ext.baseCSSPrefix + 'pickerfield-open',
editable: true,
initComponent: function() {
this.callParent();
this.addEvents(
'expand',
'collapse',
'select'
);
},
initEvents: function() {
var me = this;
me.callParent();
me.keyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
down: function() {
if (!me.isExpanded) {
me.onTriggerClick();
}
},
esc: me.collapse,
scope: me,
forceKeyDown: true
});
if (!me.editable) {
me.mon(me.inputEl, 'click', me.onTriggerClick, me);
}
if (Ext.isGecko) {
me.inputEl.dom.setAttribute('autocomplete', 'off');
}
},
expand: function() {
var me = this,
bodyEl, picker, collapseIf;
if (me.rendered && !me.isExpanded && !me.isDestroyed) {
bodyEl = me.bodyEl;
picker = me.getPicker();
collapseIf = me.collapseIf;
picker.show();
me.isExpanded = true;
me.alignPicker();
bodyEl.addCls(me.openCls);
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,
alignPicker: function() {
var me = this,
picker, isAbove,
aboveSfx = '-above';
if (this.isExpanded) {
picker = me.getPicker();
if (me.matchFieldWidth) {
picker.setSize(me.bodyEl.getWidth(), picker.store && picker.store.getCount() ? null : 0);
}
if (picker.isFloating()) {
picker.alignTo(me.inputEl, me.pickerAlign, me.pickerOffset);
isAbove = picker.el.getY() < me.inputEl.getY();
me.bodyEl[isAbove ? 'addCls' : 'removeCls'](me.openCls + aboveSfx);
picker.el[isAbove ? 'addCls' : 'removeCls'](picker.baseCls + aboveSfx);
}
}
},
collapse: function() {
if (this.isExpanded && !this.isDestroyed) {
var me = this,
openCls = me.openCls,
picker = me.picker,
doc = Ext.getDoc(),
collapseIf = me.collapseIf,
aboveSfx = '-above';
picker.hide();
me.isExpanded = false;
me.bodyEl.removeCls([openCls, openCls + aboveSfx]);
picker.el.removeCls(picker.baseCls + aboveSfx);
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,
collapseIf: function(e) {
var me = this;
if (!me.isDestroyed && !e.within(me.bodyEl, false, true) && !e.within(me.picker.el, false, true)) {
me.collapse();
}
},
getPicker: function() {
var me = this;
return me.picker || (me.picker = me.createPicker());
},
createPicker: Ext.emptyFn,
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;
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();
}
});
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',
spinUpEnabled: true,
spinDownEnabled: true,
keyNavEnabled: true,
mouseWheelEnabled: true,
repeatTriggerClick: true,
onSpinUp: Ext.emptyFn,
onSpinDown: Ext.emptyFn,
initComponent: function() {
this.callParent();
this.addEvents(
'spin',
'spinup',
'spindown'
);
},
onRender: function() {
var me = this,
triggers;
me.callParent(arguments);
triggers = me.triggerEl;
me.spinUpEl = triggers.item(0);
me.spinDownEl = triggers.item(1);
me.setSpinUpEnabled(me.spinUpEnabled);
me.setSpinDownEnabled(me.spinDownEnabled);
if (me.keyNavEnabled) {
me.spinnerKeyNav = Ext.create('Ext.util.KeyNav', me.inputEl, {
scope: me,
up: me.spinUp,
down: me.spinDown
});
}
if (me.mouseWheelEnabled) {
me.mon(me.bodyEl, 'mousewheel', me.onMouseWheel, me);
}
},
getTriggerWidth: function() {
return this.hideTrigger || this.readOnly ? 0 : this.spinUpEl.getWidth() + this.triggerWrap.getFrameWidth('lr');
},
onTrigger1Click: function() {
this.spinUp();
},
onTrigger2Click: function() {
this.spinDown();
},
spinUp: function() {
var me = this;
if (me.spinUpEnabled && !me.disabled) {
me.fireEvent('spin', me, 'up');
me.fireEvent('spinup', me);
me.onSpinUp();
}
},
spinDown: function() {
var me = this;
if (me.spinDownEnabled && !me.disabled) {
me.fireEvent('spin', me, 'down');
me.fireEvent('spindown', me);
me.onSpinDown();
}
},
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');
}
},
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');
}
},
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();
}
});
Ext.define('Ext.form.field.Number', {
extend:'Ext.form.field.Spinner',
alias: 'widget.numberfield',
alternateClassName: ['Ext.form.NumberField', 'Ext.form.Number'],
allowDecimals : true,
decimalSeparator : '.',
decimalPrecision : 2,
minValue: Number.NEGATIVE_INFINITY,
maxValue: Number.MAX_VALUE,
step: 1,
minText : 'The minimum value for this field is {0}',
maxText : 'The maximum value for this field is {0}',
nanText : '{0} is not a valid number',
negativeText : 'The value cannot be negative',
baseChars : '0123456789',
autoStripChars: false,
initComponent: function() {
var me = this,
allowed;
me.callParent();
me.setMinValue(me.minValue);
me.setMaxValue(me.maxValue);
if (me.disableKeyFilter !== true) {
allowed = me.baseChars + '';
if (me.allowDecimals) {
allowed += me.decimalSeparator;
}
if (me.minValue < 0) {
allowed += '-';
}
allowed = Ext.String.escapeRegex(allowed);
me.maskRe = new RegExp('[' + allowed + ']');
if (me.autoStripChars) {
me.stripCharsRe = new RegExp('[^' + allowed + ']', 'gi');
}
}
},
getErrors: function(value) {
var me = this,
errors = me.callParent(arguments),
format = Ext.String.format,
num;
value = Ext.isDefined(value) ? value : this.processRawValue(this.getRawValue());
if (value.length < 1) {
return errors;
}
value = String(value).replace(me.decimalSeparator, '.');
if(isNaN(value)){
errors.push(format(me.nanText, value));
}
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));
}
if (num > me.maxValue) {
errors.push(format(me.maxText, me.maxValue));
}
return errors;
},
rawToValue: function(rawValue) {
var value = this.fixPrecision(this.parseValue(rawValue));
if (value === null) {
value = rawValue || null;
}
return value;
},
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;
},
onChange: function() {
var me = this,
value = me.getValue(),
valueIsNull = value === null;
me.callParent(arguments);
me.setSpinUpEnabled(valueIsNull || value < me.maxValue);
me.setSpinDownEnabled(valueIsNull || value > me.minValue);
},
setMinValue : function(value) {
this.minValue = Ext.Number.from(value, Number.NEGATIVE_INFINITY);
},
setMaxValue: function(value) {
this.maxValue = Ext.Number.from(value, Number.MAX_VALUE);
},
parseValue : function(value) {
value = parseFloat(String(value).replace(this.decimalSeparator, '.'));
return isNaN(value) ? null : value;
},
fixPrecision : function(value) {
var me = this,
nan = isNaN(value),
precision = me.decimalPrecision;
if (nan || !value) {
return nan ? '' : value;
} else if (!me.allowDecimals || precision <= 0) {
precision = 0;
}
return parseFloat(Ext.Number.toFixed(parseFloat(value), precision));
},
beforeBlur : function() {
var me = this,
v = me.parseValue(me.getRawValue());
if (!Ext.isEmpty(v)) {
me.setValue(v);
}
},
onSpinUp: function() {
var me = this;
if (!me.readOnly) {
me.setValue(Ext.Number.constrain(me.getValue() + me.step, me.minValue, me.maxValue));
}
},
onSpinDown: function() {
var me = this;
if (!me.readOnly) {
me.setValue(Ext.Number.constrain(me.getValue() - me.step, me.minValue, me.maxValue));
}
}
});
Ext.define('Ext.toolbar.Paging', {
extend: 'Ext.toolbar.Toolbar',
alias: 'widget.pagingtoolbar',
alternateClassName: 'Ext.PagingToolbar',
requires: ['Ext.toolbar.TextItem', 'Ext.form.field.Number'],
displayInfo: false,
prependButtons: false,
displayMsg : 'Displaying {0} - {1} of {2}',
emptyMsg : 'No data to display',
beforePageText : 'Page',
afterPageText : 'of {0}',
firstText : 'First Page',
prevText : 'Previous Page',
nextText : 'Next Page',
lastText : 'Last Page',
refreshText : 'Refresh',
inputItemWidth : 30,
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
}];
},
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);
}
delete me.buttons;
if (me.displayInfo) {
me.items.push('->');
me.items.push({xtype: 'tbtext', itemId: 'displayItem'});
}
me.callParent();
me.addEvents(
'change',
'beforechange'
);
me.on('afterlayout', me.onLoad, me, {single: true});
me.bindStore(me.store, true);
},
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();
}
},
onLoad : function(){
var me = this,
pageData,
currPage,
pageCount,
afterText;
if (!me.rendered) {
return;
}
pageData = me.getPageData();
currPage = pageData.currentPage;
pageCount = pageData.pageCount;
afterText = Ext.String.format(me.afterPageText, isNaN(pageCount) ? 1 : pageCount);
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);
},
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)
};
},
onLoadError : function(){
if (!this.rendered) {
return;
}
this.child('#refresh').enable();
},
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;
}
return pageNum;
},
onPagingFocus : function(){
this.child('#inputItem').select();
},
onPagingBlur : function(e){
var curPage = this.getPageData().currentPage;
this.child('#inputItem').setValue(curPage);
},
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);
}
}
}
},
beforeLoad : function(){
if(this.rendered && this.refresh){
this.refresh.disable();
}
},
doLoad : function(start){
if(this.fireEvent('beforechange', this, o) !== false){
this.store.load();
}
},
moveFirst : function(){
if (this.fireEvent('beforechange', this, 1) !== false){
this.store.loadPage(1);
}
},
movePrevious : function(){
var me = this,
prev = me.store.currentPage - 1;
if (prev > 0) {
if (me.fireEvent('beforechange', me, prev) !== false) {
me.store.previousPage();
}
}
},
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();
}
}
},
moveLast : function(){
var me = this,
last = me.getPageData().pageCount;
if (me.fireEvent('beforechange', me, last) !== false) {
me.store.loadPage(last);
}
},
doRefresh : function(){
var me = this,
current = me.store.currentPage;
if (me.fireEvent('beforechange', me, current) !== false) {
me.store.loadPage(current);
}
},
bindStore : function(store, initial){
var me = this;
if (!initial && me.store) {
if(store !== me.store && me.store.autoDestroy){
me.store.destroy();
}else{
me.store.un('beforeload', me.beforeLoad, me);
me.store.un('load', me.onLoad, me);
me.store.un('exception', me.onLoadError, me);
}
if(!store){
me.store = null;
}
}
if (store) {
store = Ext.data.StoreManager.lookup(store);
store.on({
scope: me,
beforeload: me.beforeLoad,
load: me.onLoad,
exception: me.onLoadError
});
}
me.store = store;
},
unbind : function(store){
this.bindStore(null);
},
bind : function(store){
this.bindStore(store);
},
onDestroy : function(){
this.bindStore(null);
this.callParent();
}
});
Ext.define('Ext.view.BoundList', {
extend: 'Ext.view.View',
alias: 'widget.boundlist',
alternateClassName: 'Ext.BoundList',
requires: ['Ext.layout.component.BoundList', 'Ext.toolbar.Paging'],
pageSize: 0,
autoScroll: true,
baseCls: Ext.baseCSSPrefix + 'boundlist',
listItemCls: '',
shadow: false,
trackOver: true,
refreshed: 0,
ariaRole: 'listbox',
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) {
me.tpl = Ext.create('Ext.XTemplate',
'',
'' + me.getInnerTpl(me.displayField) + ' ',
' ' +
'{[typeof values === "string" ? values : values.' + me.displayField + ']}' +
'' + me.delimiter + ' ' +
' '
);
} else if (Ext.isString(me.displayTpl)) {
me.displayTpl = Ext.create('Ext.XTemplate', me.displayTpl);
}
me.callParent();
me.doQueryTask = Ext.create('Ext.util.DelayedTask', me.doRawQuery, me);
if (me.store.getCount() > 0) {
me.setValue(me.value);
}
if (transformSelect) {
me.render(transformSelect.parentNode, transformSelect);
Ext.removeNode(transformSelect);
delete me.renderTo;
}
},
beforeBlur: function() {
var me = this;
me.doQueryTask.cancel();
if (me.forceSelection) {
me.assertValue();
} else {
me.collapse();
}
},
assertValue: function() {
var me = this,
value = me.getRawValue(),
rec;
if (me.multiSelect) {
if (value !== me.getDisplayValue()) {
me.setValue(me.lastSelection);
}
} else {
rec = me.findRecordByDisplay(value);
if (rec) {
me.select(rec);
} else {
me.setValue(me.lastSelection);
}
}
me.collapse();
},
onTypeAhead: function() {
var me = this,
displayField = me.displayField,
record = me.store.findRecord(displayField, me.getRawValue()),
boundList = me.getPicker(),
newValue, len, selStart;
if (record) {
newValue = record.get(displayField);
len = newValue.length;
selStart = me.getRawValue().length;
boundList.highlightItem(boundList.getNode(record));
if (selStart !== 0 && selStart !== len) {
me.setRawValue(newValue);
me.selectText(selStart, newValue.length);
}
}
},
resetToDefault: function() {
},
bindStore: function(store, initial) {
var me = this,
oldStore = me.store;
if (oldStore && !initial) {
if (oldStore !== store && oldStore.autoDestroy) {
oldStore.destroy();
} else {
oldStore.un({
scope: me,
load: me.onLoad,
exception: me.collapse
});
}
if (!store) {
me.store = null;
if (me.picker) {
me.picker.bindStore(null);
}
}
}
if (store) {
if (!initial) {
me.resetToDefault();
}
me.store = Ext.data.StoreManager.lookup(store);
me.store.on({
scope: me,
load: me.onLoad,
exception: me.collapse
});
if (me.picker) {
me.picker.bindStore(store);
}
}
},
onLoad: function() {
var me = this,
value = me.value;
me.syncSelection();
if (me.picker && !me.picker.getSelectionModel().hasSelection()) {
me.doAutoSelect();
}
},
doRawQuery: function() {
this.doQuery(this.getRawValue());
},
doQuery: function(queryString, forceAll) {
queryString = queryString || '';
var me = this,
qe = {
query: queryString,
forceAll: forceAll,
combo: me,
cancel: false
},
store = me.store,
isLocalMode = me.queryMode === 'local';
if (me.fireEvent('beforequery', qe) === false || qe.cancel) {
return false;
}
queryString = qe.query;
forceAll = qe.forceAll;
if (forceAll || (queryString.length >= me.minChars)) {
me.expand();
if (!me.queryCaching || me.lastQuery !== queryString) {
me.lastQuery = queryString;
if (isLocalMode) {
if (forceAll) {
store.clearFilter();
} else {
store.clearFilter(true);
store.filter(me.displayField, queryString);
}
} else {
store.load({
params: me.getParams(queryString)
});
}
}
if (me.getRawValue() !== me.getDisplayValue()) {
me.ignoreSelection++;
me.picker.getSelectionModel().deselectAll();
me.ignoreSelection--;
}
if (isLocalMode) {
me.doAutoSelect();
}
if (me.typeAhead) {
me.doTypeAhead();
}
}
return true;
},
getParams: function(queryString) {
var p = {},
pageSize = this.pageSize,
param = this.queryParam;
if (param) {
p[param] = queryString;
}
if (pageSize) {
p.start = 0;
p.limit = pageSize;
}
return p;
},
doAutoSelect: function() {
var me = this,
picker = me.picker,
lastSelected, itemNode;
if (picker && me.autoSelect && me.store.getCount() > 0) {
lastSelected = picker.getSelectionModel().lastSelected;
itemNode = picker.getNode(lastSelected || 0);
if (itemNode) {
picker.highlightItem(itemNode);
picker.listEl.scrollChildIntoView(itemNode, false);
}
}
},
doTypeAhead: function() {
if (!this.typeAheadTask) {
this.typeAheadTask = Ext.create('Ext.util.DelayedTask', this.onTypeAhead, this);
}
if (this.lastKey != Ext.EventObject.BACKSPACE && this.lastKey != Ext.EventObject.DELETE) {
this.typeAheadTask.delay(this.typeAheadDelay);
}
},
onTriggerClick: function() {
var me = this;
if (!me.readOnly && !me.disabled) {
if (me.isExpanded) {
me.collapse();
} else {
me.onFocus({});
if (me.triggerAction === 'all') {
me.doQuery(me.allQuery, true);
} else {
me.doQuery(me.getRawValue());
}
}
me.inputEl.focus();
}
},
onKeyUp: function(e, t) {
var me = this,
key = e.getKey();
if (!me.readOnly && !me.disabled && me.editable) {
me.lastKey = key;
if (!e.isSpecialKey() || key == e.BACKSPACE || key == e.DELETE) {
me.doQueryTask.delay(me.queryDelay);
}
}
if (me.enableKeyEvents) {
me.callParent(arguments);
}
},
initEvents: function() {
var me = this;
me.callParent();
if (!me.enableKeyEvents) {
me.mon(me.inputEl, 'keyup', me.onKeyUp, me);
}
},
createPicker: function() {
var me = this,
picker,
menuCls = Ext.baseCSSPrefix + 'menu',
opts = Ext.apply({
selModel: {
mode: me.multiSelect ? 'SIMPLE' : 'SINGLE'
},
floating: true,
hidden: true,
ownerCt: me.ownerCt,
cls: me.el.up('.' + menuCls) ? menuCls : '',
store: me.store,
displayField: me.displayField,
focusOnToFront: false,
pageSize: me.pageSize,
tpl: me.tpl
}, me.listConfig, me.defaultListConfig);
picker = me.picker = Ext.create('Ext.view.BoundList', opts);
me.mon(picker, {
itemclick: me.onItemClick,
refresh: me.onListRefresh,
scope: me
});
me.mon(picker.getSelectionModel(), 'selectionchange', me.onListSelectionChange, me);
return picker;
},
onListRefresh: function() {
this.alignPicker();
this.syncSelection();
},
onItemClick: function(picker, record){
var me = this,
lastSelection = me.lastSelection,
valueField = me.valueField,
selected;
if (!me.multiSelect && lastSelection) {
selected = lastSelection[0];
if (selected && (record.get(valueField) === selected.get(valueField))) {
me.collapse();
}
}
},
onListSelectionChange: function(list, selectedRecords) {
var me = this,
isMulti = me.multiSelect,
hasRecords = selectedRecords.length > 0;
if (!me.ignoreSelection && me.isExpanded) {
if (!isMulti) {
Ext.defer(me.collapse, 1, me);
}
if (isMulti || hasRecords) {
me.setValue(selectedRecords, false);
}
if (hasRecords) {
me.fireEvent('select', me, selectedRecords);
}
me.inputEl.focus();
}
},
onExpand: function() {
var me = this,
keyNav = me.listKeyNav,
selectOnTab = me.selectOnTab,
picker = me.getPicker();
if (keyNav) {
keyNav.enable();
} else {
keyNav = me.listKeyNav = Ext.create('Ext.view.BoundListKeyNav', this.inputEl, {
boundList: picker,
forceKeyDown: true,
tab: function(e) {
if (selectOnTab) {
this.selectHighlighted(e);
me.triggerBlur();
}
return true;
}
});
}
if (selectOnTab) {
me.ignoreMonitorTab = true;
}
Ext.defer(keyNav.enable, 1, keyNav);
me.inputEl.focus();
},
onCollapse: function() {
var me = this,
keyNav = me.listKeyNav;
if (keyNav) {
keyNav.disable();
me.ignoreMonitorTab = false;
}
},
select: function(r) {
this.setValue(r, true);
},
findRecord: function(field, value) {
var ds = this.store,
idx = ds.findExact(field, value);
return idx !== -1 ? ds.getAt(idx) : false;
},
findRecordByValue: function(value) {
return this.findRecord(this.valueField, value);
},
findRecordByDisplay: function(value) {
return this.findRecord(this.displayField, value);
},
setValue: function(value, doSelect) {
var me = this,
valueNotFoundText = me.valueNotFoundText,
inputEl = me.inputEl,
i, len, record,
models = [],
displayTplData = [],
processedValue = [];
if (me.store.loading) {
me.value = value;
return me;
}
value = Ext.Array.from(value);
for (i = 0, len = value.length; i < len; i++) {
record = value[i];
if (!record || !record.isModel) {
record = me.findRecordByValue(record);
}
if (record) {
models.push(record);
displayTplData.push(record.data);
processedValue.push(record.get(me.valueField));
}
else {
if (Ext.isDefined(valueNotFoundText)) {
displayTplData.push(valueNotFoundText);
}
processedValue.push(value[i]);
}
}
me.value = me.multiSelect ? processedValue : processedValue[0];
if (!Ext.isDefined(me.value)) {
me.value = null;
}
me.displayTplData = displayTplData;
me.lastSelection = me.valueModels = models;
if (inputEl && me.emptyText && !Ext.isEmpty(value)) {
inputEl.removeCls(me.emptyCls);
}
me.setRawValue(me.getDisplayValue());
me.checkChange();
if (doSelect !== false) {
me.syncSelection();
}
me.applyEmptyText();
return me;
},
getDisplayValue: function() {
return this.displayTpl.apply(this.displayTplData);
},
getValue: function() {
var me = this,
picker = me.picker,
rawValue = me.getRawValue(),
value = me.value;
if (me.getDisplayValue() !== rawValue) {
value = rawValue;
me.value = me.displayTplData = me.valueModels = null;
if (picker) {
me.ignoreSelection++;
picker.getSelectionModel().deselectAll();
me.ignoreSelection--;
}
}
return value;
},
getSubmitValue: function() {
return this.getValue();
},
isEqual: function(v1, v2) {
var fromArray = Ext.Array.from,
i, len;
v1 = fromArray(v1);
v2 = fromArray(v2);
len = v1.length;
if (len !== v2.length) {
return false;
}
for(i = 0; i < len; i++) {
if (v2[i] !== v1[i]) {
return false;
}
}
return true;
},
clearValue: function() {
this.setValue([]);
},
syncSelection: function() {
var me = this,
ExtArray = Ext.Array,
picker = me.picker,
selection, selModel;
if (picker) {
selection = [];
ExtArray.forEach(me.valueModels || [], function(value) {
if (value && value.isModel && me.store.indexOf(value) >= 0) {
selection.push(value);
}
});
me.ignoreSelection++;
selModel = picker.getSelectionModel();
selModel.deselectAll();
if (selection.length) {
selModel.select(selection);
}
me.ignoreSelection--;
}
}
});
Ext.define('Ext.picker.Month', {
extend: 'Ext.Component',
requires: ['Ext.XTemplate', 'Ext.util.ClickRepeater', 'Ext.Date', 'Ext.button.Button'],
alias: 'widget.monthpicker',
alternateClassName: 'Ext.MonthPicker',
renderTpl: [
'',
'
',
'
',
'
',
'
',
'
',
'',
' ',
'
',
'
',
'',
'
',
' '
],
okText: 'OK',
cancelText: 'Cancel',
baseCls: Ext.baseCSSPrefix + 'monthpicker',
showButtons: true,
width: 178,
smallCls: Ext.baseCSSPrefix + 'monthpicker-small',
totalYears: 10,
yearOffset: 5,
monthOffset: 6,
initComponent: function(){
var me = this;
me.selectedCls = me.baseCls + '-selected';
me.addEvents(
'cancelclick',
'monthclick',
'monthdblclick',
'okclick',
'select',
'yearclick',
'yeardblclick'
);
if (me.small) {
me.addCls(me.smallCls);
}
me.setValue(me.value);
me.activeYear = me.getYear(new Date().getFullYear() - 4, -4);
this.callParent();
},
onRender: function(ct, position){
var me = this,
i = 0,
months = [],
shortName = Ext.Date.getShortMonthName,
monthLen = me.monthOffset;
for (; i < monthLen; ++i) {
months.push(shortName(i), shortName(i + monthLen));
}
Ext.apply(me.renderData, {
months: months,
years: me.getYears(),
showButtons: me.showButtons
});
Ext.apply(me.renderSelectors, {
bodyEl: '.' + me.baseCls + '-body',
prevEl: '.' + me.baseCls + '-yearnav-prev',
nextEl: '.' + me.baseCls + '-yearnav-next',
buttonsEl: '.' + me.baseCls + '-buttons'
});
this.callParent([ct, position]);
},
afterRender: function(){
var me = this,
body = me.bodyEl,
buttonsEl = me.buttonsEl;
me.callParent();
me.mon(body, 'click', me.onBodyClick, me);
me.mon(body, 'dblclick', me.onBodyClick, me);
me.years = body.select('.' + me.baseCls + '-year a');
me.months = body.select('.' + me.baseCls + '-month a');
if (me.showButtons) {
me.okBtn = Ext.create('Ext.button.Button', {
text: me.okText,
renderTo: buttonsEl,
handler: me.onOkClick,
scope: me
});
me.cancelBtn = Ext.create('Ext.button.Button', {
text: me.cancelText,
renderTo: buttonsEl,
handler: me.onCancelClick,
scope: me
});
}
me.backRepeater = Ext.create('Ext.util.ClickRepeater', me.prevEl, {
handler: Ext.Function.bind(me.adjustYear, me, [-me.totalYears])
});
me.prevEl.addClsOnOver(me.baseCls + '-yearnav-prev-over');
me.nextRepeater = Ext.create('Ext.util.ClickRepeater', me.nextEl, {
handler: Ext.Function.bind(me.adjustYear, me, [me.totalYears])
});
me.nextEl.addClsOnOver(me.baseCls + '-yearnav-next-over');
me.updateBody();
},
setValue: function(value){
var me = this,
active = me.activeYear,
offset = me.monthOffset,
year,
index;
if (!value) {
me.value = [null, null];
} else if (Ext.isDate(value)) {
me.value = [value.getMonth(), value.getFullYear()];
} else {
me.value = [value[0], value[1]];
}
if (me.rendered) {
year = me.value[1];
if (year !== null) {
if ((year < active || year > active + me.yearOffset)) {
me.activeYear = year - me.yearOffset + 1;
}
}
me.updateBody();
}
return me;
},
getValue: function(){
return this.value;
},
hasSelection: function(){
var value = this.value;
return value[0] !== null && value[1] !== null;
},
getYears: function(){
var me = this,
offset = me.yearOffset,
start = me.activeYear,
end = start + offset,
i = start,
years = [];
for (; i < end; ++i) {
years.push(i, i + offset);
}
return years;
},
updateBody: function(){
var me = this,
years = me.years,
months = me.months,
yearNumbers = me.getYears(),
cls = me.selectedCls,
value = me.getYear(null),
month = me.value[0],
monthOffset = me.monthOffset,
year;
if (me.rendered) {
years.removeCls(cls);
months.removeCls(cls);
years.each(function(el, all, index){
year = yearNumbers[index];
el.dom.innerHTML = year;
if (year == value) {
el.dom.className = cls;
}
});
if (month !== null) {
if (month < monthOffset) {
month = month * 2;
} else {
month = (month - monthOffset) * 2 + 1;
}
months.item(month).addCls(cls);
}
}
},
getYear: function(defaultValue, offset) {
var year = this.value[1];
offset = offset || 0;
return year === null ? defaultValue : year + offset;
},
onBodyClick: function(e, t) {
var me = this,
isDouble = e.type == 'dblclick';
if (e.getTarget('.' + me.baseCls + '-month')) {
e.stopEvent();
me.onMonthClick(t, isDouble);
} else if (e.getTarget('.' + me.baseCls + '-year')) {
e.stopEvent();
me.onYearClick(t, isDouble);
}
},
adjustYear: function(offset){
if (typeof offset != 'number') {
offset = this.totalYears;
}
this.activeYear += offset;
this.updateBody();
},
onOkClick: function(){
this.fireEvent('okclick', this, this.value);
},
onCancelClick: function(){
this.fireEvent('cancelclick', this);
},
onMonthClick: function(target, isDouble){
var me = this;
me.value[0] = me.resolveOffset(me.months.indexOf(target), me.monthOffset);
me.updateBody();
me.fireEvent('month' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
me.fireEvent('select', me, me.value);
},
onYearClick: function(target, isDouble){
var me = this;
me.value[1] = me.activeYear + me.resolveOffset(me.years.indexOf(target), me.yearOffset);
me.updateBody();
me.fireEvent('year' + (isDouble ? 'dbl' : '') + 'click', me, me.value);
me.fireEvent('select', me, me.value);
},
resolveOffset: function(index, offset){
if (index % 2 === 0) {
return (index / 2);
} else {
return offset + Math.floor(index / 2);
}
},
beforeDestroy: function(){
var me = this;
me.years = me.months = null;
Ext.destroyMembers('backRepeater', 'nextRepeater', 'okBtn', 'cancelBtn');
this.callParent();
}
});
Ext.define('Ext.picker.Date', {
extend: 'Ext.Component',
requires: [
'Ext.XTemplate',
'Ext.button.Button',
'Ext.button.Split',
'Ext.util.ClickRepeater',
'Ext.util.KeyNav',
'Ext.EventObject',
'Ext.fx.Manager',
'Ext.picker.Month'
],
alias: 'widget.datepicker',
alternateClassName: 'Ext.DatePicker',
renderTpl: [
'',
'',
'
',
'',
'',
'{.:this.firstInitial} ',
' ',
'',
'{#:this.isEndOfWeek}',
'',
'',
' ',
' ',
' ',
'
',
'
',
'',
' ',
'
' : '';
},
longDay: function(value){
return Ext.Date.format(value, this.longDayFormat);
}
}
],
ariaTitle: 'Date Picker',
todayText : 'Today',
todayTip : '{0} (Spacebar)',
minText : 'This date is before the minimum date',
maxText : 'This date is after the maximum date',
disabledDaysText : 'Disabled',
disabledDatesText : 'Disabled',
nextText : 'Next Month (Control+Right)',
prevText : 'Previous Month (Control+Left)',
monthYearText : 'Choose a month (Control+Up/Down to move years)',
startDay : 0,
showToday : true,
disableAnim: true,
baseCls: Ext.baseCSSPrefix + 'datepicker',
longDayFormat: 'F d, Y',
focusOnShow: false,
focusOnSelect: true,
width: 178,
initHour: 12,
numDays: 42,
initComponent : function() {
var me = this,
clearTime = Ext.Date.clearTime;
me.selectedCls = me.baseCls + '-selected';
me.disabledCellCls = me.baseCls + '-disabled';
me.prevCls = me.baseCls + '-prevday';
me.activeCls = me.baseCls + '-active';
me.nextCls = me.baseCls + '-prevday';
me.todayCls = me.baseCls + '-today';
me.dayNames = me.dayNames.slice(me.startDay).concat(me.dayNames.slice(0, me.startDay));
this.callParent();
me.value = me.value ?
clearTime(me.value, true) : clearTime(new Date());
me.addEvents(
'select'
);
me.initDisabledDays();
},
onRender : function(container, position){
var me = this,
days = new Array(me.numDays),
today = Ext.Date.format(new Date(), me.format);
Ext.applyIf(me, {
renderData: {},
renderSelectors: {}
});
Ext.apply(me.renderData, {
dayNames: me.dayNames,
ariaTitle: me.ariaTitle,
value: me.value,
showToday: me.showToday,
prevText: me.prevText,
nextText: me.nextText,
days: days
});
me.getTpl('renderTpl').longDayFormat = me.longDayFormat;
Ext.apply(me.renderSelectors, {
eventEl: 'table.' + me.baseCls + '-inner',
prevEl: '.' + me.baseCls + '-prev a',
nextEl: '.' + me.baseCls + '-next a',
middleBtnEl: '.' + me.baseCls + '-month',
footerEl: '.' + me.baseCls + '-footer'
});
this.callParent(arguments);
me.el.unselectable();
me.cells = me.eventEl.select('tbody td');
me.textNodes = me.eventEl.query('tbody td span');
me.monthBtn = Ext.create('Ext.button.Split', {
text: '',
tooltip: me.monthYearText,
renderTo: me.middleBtnEl
});
me.todayBtn = Ext.create('Ext.button.Button', {
renderTo: me.footerEl,
text: Ext.String.format(me.todayText, today),
tooltip: Ext.String.format(me.todayTip, today),
handler: me.selectToday,
scope: me
});
},
initEvents: function(){
var me = this,
eDate = Ext.Date,
day = eDate.DAY;
this.callParent();
me.prevRepeater = Ext.create('Ext.util.ClickRepeater', me.prevEl, {
handler: me.showPrevMonth,
scope: me,
preventDefault: true,
stopDefault: true
});
me.nextRepeater = Ext.create('Ext.util.ClickRepeater', me.nextEl, {
handler: me.showNextMonth,
scope: me,
preventDefault:true,
stopDefault:true
});
me.keyNav = Ext.create('Ext.util.KeyNav', me.eventEl, Ext.apply({
scope: me,
'left' : function(e){
if(e.ctrlKey){
me.showPrevMonth();
}else{
me.update(eDate.add(me.activeDate, day, -1));
}
},
'right' : function(e){
if(e.ctrlKey){
me.showNextMonth();
}else{
me.update(eDate.add(me.activeDate, day, 1));
}
},
'up' : function(e){
if(e.ctrlKey){
me.showNextYear();
}else{
me.update(eDate.add(me.activeDate, day, -7));
}
},
'down' : function(e){
if(e.ctrlKey){
me.showPrevYear();
}else{
me.update(eDate.add(me.activeDate, day, 7));
}
},
'pageUp' : me.showNextMonth,
'pageDown' : me.showPrevMonth,
'enter' : function(e){
e.stopPropagation();
return true;
}
}, me.keyNavConfig));
if(me.showToday){
me.todayKeyListener = me.eventEl.addKeyListener(Ext.EventObject.SPACE, me.selectToday, me);
}
me.mon(me.eventEl, 'mousewheel', me.handleMouseWheel, me);
me.mon(me.eventEl, 'click', me.handleDateClick, me, {delegate: 'a.' + me.baseCls + '-date'});
me.mon(me.monthBtn, 'click', me.showMonthPicker, me);
me.mon(me.monthBtn, 'arrowclick', me.showMonthPicker, me);
me.update(me.value);
},
initDisabledDays : function(){
var me = this,
dd = me.disabledDates,
re = '(?:',
len;
if(!me.disabledDatesRE && dd){
len = dd.length - 1;
Ext.each(dd, function(d, i){
re += Ext.isDate(d) ? '^' + Ext.String.escapeRegex(Ext.Date.dateFormat(d, me.format)) + '$' : dd[i];
if(i != len){
re += '|';
}
}, me);
me.disabledDatesRE = new RegExp(re + ')');
}
},
setDisabledDates : function(dd){
var me = this;
if(Ext.isArray(dd)){
me.disabledDates = dd;
me.disabledDatesRE = null;
}else{
me.disabledDatesRE = dd;
}
me.initDisabledDays();
me.update(me.value, true);
return me;
},
setDisabledDays : function(dd){
this.disabledDays = dd;
return this.update(this.value, true);
},
setMinDate : function(dt){
this.minDate = dt;
return this.update(this.value, true);
},
setMaxDate : function(dt){
this.maxDate = dt;
return this.update(this.value, true);
},
setValue : function(value){
this.value = Ext.Date.clearTime(value, true);
return this.update(this.value);
},
getValue : function(){
return this.value;
},
focus : function(){
this.update(this.activeDate);
},
onEnable: function(){
this.callParent();
this.setDisabledStatus(false);
this.update(this.activeDate);
},
onDisable : function(){
this.callParent();
this.setDisabledStatus(true);
},
setDisabledStatus : function(disabled){
var me = this;
me.keyNav.setDisabled(disabled);
me.prevRepeater.setDisabled(disabled);
me.nextRepeater.setDisabled(disabled);
if (me.showToday) {
me.todayKeyListener.setDisabled(disabled);
me.todayBtn.setDisabled(disabled);
}
},
getActive: function(){
return this.activeDate || me.value;
},
runAnimation: function(isHide){
var options = {
target: this.monthPicker,
duration: 200
};
Ext.fx.Manager.run();
if (isHide) {
} else {
}
Ext.create('Ext.fx.Anim', options);
},
hideMonthPicker : function(){
var me = this,
picker = me.monthPicker;
if (picker) {
if (me.disableAnim) {
picker.hide();
} else {
this.runAnimation(true);
}
}
return me;
},
showMonthPicker : function(){
var me = this,
picker,
size,
top,
left;
if (me.rendered && !me.disabled) {
size = me.getSize();
picker = me.createMonthPicker();
picker.show();
picker.setSize(size);
picker.setValue(me.getActive());
if (me.disableAnim) {
picker.setPosition(-1, -1);
} else {
me.runAnimation(false);
}
}
return me;
},
createMonthPicker: function(){
var me = this,
picker = me.monthPicker;
if (!picker) {
me.monthPicker = picker = Ext.create('Ext.picker.Month', {
renderTo: me.el,
floating: true,
shadow: false,
small: me.showToday === false,
listeners: {
scope: me,
cancelclick: me.onCancelClick,
okclick: me.onOkClick,
yeardblclick: me.onOkClick,
monthdblclick: me.onOkClick
}
});
me.on('beforehide', me.hideMonthPicker, me);
}
return picker;
},
onOkClick: function(picker, value){
var me = this,
month = value[0],
year = value[1],
date = new Date(year, month, me.getActive().getDate());
if (date.getMonth() !== month) {
date = new Date(year, month, 1).getLastDateOfMonth();
}
me.update(date);
me.hideMonthPicker();
},
onCancelClick: function(){
this.hideMonthPicker();
},
showPrevMonth : function(e){
return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, -1));
},
showNextMonth : function(e){
return this.update(Ext.Date.add(this.activeDate, Ext.Date.MONTH, 1));
},
showPrevYear : function(){
this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, -1));
},
showNextYear : function(){
this.update(Ext.Date.add(this.activeDate, Ext.Date.YEAR, 1));
},
handleMouseWheel : function(e){
e.stopEvent();
if(!this.disabled){
var delta = e.getWheelDelta();
if(delta > 0){
this.showPrevMonth();
} else if(delta < 0){
this.showNextMonth();
}
}
},
handleDateClick : function(e, t){
var me = this,
handler = me.handler;
e.stopEvent();
if(!me.disabled && t.dateValue && !Ext.fly(t.parentNode).hasCls(me.disabledCellCls)){
me.cancelFocus = me.focusOnSelect === false;
me.setValue(new Date(t.dateValue));
delete me.cancelFocus;
me.fireEvent('select', me, me.value);
if (handler) {
handler.call(me.scope || me, me, me.value);
}
me.onSelect();
}
},
onSelect: function() {
if (this.hideOnSelect) {
this.hide();
}
},
selectToday : function(){
var me = this,
btn = me.todayBtn,
handler = me.handler;
if(btn && !btn.disabled){
me.setValue(Ext.Date.clearTime(new Date()));
me.fireEvent('select', me, me.value);
if (handler) {
handler.call(me.scope || me, me, me.value);
}
me.onSelect();
}
return me;
},
selectedUpdate: function(date, active){
var me = this,
t = date.getTime(),
cells = me.cells,
cls = me.selectedCls;
cells.removeCls(cls);
cells.each(function(c){
if (c.dom.firstChild.dateValue == t) {
me.el.dom.setAttribute('aria-activedescendent', c.dom.id);
c.addCls(cls);
if(me.isVisible() && !me.cancelFocus){
Ext.fly(c.dom.firstChild).focus(50);
}
return false;
}
}, this);
},
fullUpdate: function(date, active){
var me = this,
cells = me.cells.elements,
textNodes = me.textNodes,
disabledCls = me.disabledCellCls,
eDate = Ext.Date,
i = 0,
extraDays = 0,
visible = me.isVisible(),
sel = +eDate.clearTime(date, true),
today = +eDate.clearTime(new Date()),
min = me.minDate ? eDate.clearTime(me.minDate, true) : Number.NEGATIVE_INFINITY,
max = me.maxDate ? eDate.clearTime(me.maxDate, true) : Number.POSITIVE_INFINITY,
ddMatch = me.disabledDatesRE,
ddText = me.disabledDatesText,
ddays = me.disabledDays ? me.disabledDays.join('') : false,
ddaysText = me.disabledDaysText,
format = me.format,
days = eDate.getDaysInMonth(date),
firstOfMonth = eDate.getFirstDateOfMonth(date),
startingPos = firstOfMonth.getDay() - me.startDay,
previousMonth = eDate.add(date, eDate.MONTH, -1),
longDayFormat = me.longDayFormat,
prevStart,
current,
disableToday,
tempDate,
setCellClass,
html,
cls,
formatValue,
value;
if (startingPos < 0) {
startingPos += 7;
}
days += startingPos;
prevStart = eDate.getDaysInMonth(previousMonth) - startingPos;
current = new Date(previousMonth.getFullYear(), previousMonth.getMonth(), prevStart, me.initHour);
if (me.showToday) {
tempDate = eDate.clearTime(new Date());
disableToday = (tempDate < min || tempDate > max ||
(ddMatch && format && ddMatch.test(eDate.dateFormat(tempDate, format))) ||
(ddays && ddays.indexOf(tempDate.getDay()) != -1));
if (!me.disabled) {
me.todayBtn.setDisabled(disableToday);
me.todayKeyListener.setDisabled(disableToday);
}
}
setCellClass = function(cell){
value = +eDate.clearTime(current, true);
cell.title = eDate.format(current, longDayFormat);
cell.firstChild.dateValue = value;
if(value == today){
cell.className += ' ' + me.todayCls;
cell.title = me.todayText;
}
if(value == sel){
cell.className += ' ' + me.selectedCls;
me.el.dom.setAttribute('aria-activedescendant', cell.id);
if (visible && me.floating) {
Ext.fly(cell.firstChild).focus(50);
}
}
if(value < min) {
cell.className = disabledCls;
cell.title = me.minText;
return;
}
if(value > max) {
cell.className = disabledCls;
cell.title = me.maxText;
return;
}
if(ddays){
if(ddays.indexOf(current.getDay()) != -1){
cell.title = ddaysText;
cell.className = disabledCls;
}
}
if(ddMatch && format){
formatValue = eDate.dateFormat(current, format);
if(ddMatch.test(formatValue)){
cell.title = ddText.replace('%0', formatValue);
cell.className = disabledCls;
}
}
};
for(; i < me.numDays; ++i) {
if (i < startingPos) {
html = (++prevStart);
cls = me.prevCls;
} else if (i >= days) {
html = (++extraDays);
cls = me.nextCls;
} else {
html = i - startingPos + 1;
cls = me.activeCls;
}
textNodes[i].innerHTML = html;
cells[i].className = cls;
current.setDate(current.getDate() + 1);
setCellClass(cells[i]);
}
me.monthBtn.setText(me.monthNames[date.getMonth()] + ' ' + date.getFullYear());
},
update : function(date, forceRefresh){
var me = this,
active = me.activeDate;
if (me.rendered) {
me.activeDate = date;
if(!forceRefresh && active && me.el && active.getMonth() == date.getMonth() && active.getFullYear() == date.getFullYear()){
me.selectedUpdate(date, active);
} else {
me.fullUpdate(date, active);
}
}
return me;
},
beforeDestroy : function() {
var me = this;
if (me.rendered) {
Ext.destroy(
me.todayKeyListener,
me.keyNav,
me.monthPicker,
me.monthBtn,
me.nextRepeater,
me.prevRepeater,
me.todayBtn
);
delete me.textNodes;
delete me.cells.elements;
}
},
onShow: function() {
this.callParent(arguments);
if (this.focusOnShow) {
this.focus();
}
}
},
function() {
var proto = this.prototype;
proto.monthNames = Ext.Date.monthNames;
proto.dayNames = Ext.Date.dayNames;
proto.format = Ext.Date.defaultFormat;
});
Ext.define('Ext.form.field.Date', {
extend:'Ext.form.field.Picker',
alias: 'widget.datefield',
requires: ['Ext.picker.Date'],
alternateClassName: ['Ext.form.DateField', 'Ext.form.Date'],
format : "m/d/Y",
altFormats : "m/d/Y|n/j/Y|n/j/y|m/j/y|n/d/y|m/j/Y|n/d/Y|m-d-y|m-d-Y|m/d|m-d|md|mdy|mdY|d|Y-m-d|n-j|n/j",
disabledDaysText : "Disabled",
disabledDatesText : "Disabled",
minText : "The date in this field must be equal to or after {0}",
maxText : "The date in this field must be equal to or before {0}",
invalidText : "{0} is not a valid date - it must be in the format {1}",
triggerCls : Ext.baseCSSPrefix + 'form-date-trigger',
showToday : true,
initTime: '12',
initTimeFormat: 'H',
matchFieldWidth: false,
startDay: 0,
initComponent : function(){
var me = this,
isString = Ext.isString,
min, max;
min = me.minValue;
max = me.maxValue;
if(isString(min)){
me.minValue = me.parseDate(min);
}
if(isString(max)){
me.maxValue = me.parseDate(max);
}
me.disabledDatesRE = null;
me.initDisabledDays();
me.callParent();
},
initValue: function() {
var me = this,
value = me.value;
if (Ext.isString(value)) {
me.value = me.rawToValue(value);
}
me.callParent();
},
initDisabledDays : function(){
if(this.disabledDates){
var dd = this.disabledDates,
len = dd.length - 1,
re = "(?:";
Ext.each(dd, function(d, i){
re += Ext.isDate(d) ? '^' + Ext.String.escapeRegex(d.dateFormat(this.format)) + '$' : dd[i];
if (i !== len) {
re += '|';
}
}, this);
this.disabledDatesRE = new RegExp(re + ')');
}
},
setDisabledDates : function(dd){
var me = this,
picker = me.picker;
me.disabledDates = dd;
me.initDisabledDays();
if (picker) {
picker.setDisabledDates(me.disabledDatesRE);
}
},
setDisabledDays : function(dd){
var picker = this.picker;
this.disabledDays = dd;
if (picker) {
picker.setDisabledDays(dd);
}
},
setMinValue : function(dt){
var me = this,
picker = me.picker,
minValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
me.minValue = minValue;
if (picker) {
picker.minText = Ext.String.format(me.minText, me.formatDate(me.minValue));
picker.setMinDate(minValue);
}
},
setMaxValue : function(dt){
var me = this,
picker = me.picker,
maxValue = (Ext.isString(dt) ? me.parseDate(dt) : dt);
me.maxValue = maxValue;
if (picker) {
picker.maxText = Ext.String.format(me.maxText, me.formatDate(me.maxValue));
picker.setMaxDate(maxValue);
}
},
getErrors: function(value) {
var me = this,
format = Ext.String.format,
clearTime = Ext.Date.clearTime,
errors = me.callParent(arguments),
disabledDays = me.disabledDays,
disabledDatesRE = me.disabledDatesRE,
minValue = me.minValue,
maxValue = me.maxValue,
len = disabledDays ? disabledDays.length : 0,
i = 0,
svalue,
fvalue,
day,
time;
value = me.formatDate(value || me.processRawValue(me.getRawValue()));
if (value === null || value.length < 1) {
return errors;
}
svalue = value;
value = me.parseDate(value);
if (!value) {
errors.push(format(me.invalidText, svalue, me.format));
return errors;
}
time = value.getTime();
if (minValue && time < clearTime(minValue).getTime()) {
errors.push(format(me.minText, me.formatDate(minValue)));
}
if (maxValue && time > clearTime(maxValue).getTime()) {
errors.push(format(me.maxText, me.formatDate(maxValue)));
}
if (disabledDays) {
day = value.getDay();
for(; i < len; i++) {
if (day === disabledDays[i]) {
errors.push(me.disabledDaysText);
break;
}
}
}
fvalue = me.formatDate(value);
if (disabledDatesRE && disabledDatesRE.test(fvalue)) {
errors.push(format(me.disabledDatesText, fvalue));
}
return errors;
},
rawToValue: function(rawValue) {
return this.parseDate(rawValue) || rawValue || null;
},
valueToRaw: function(value) {
return this.formatDate(this.parseDate(value));
},
safeParse : function(value, format) {
var me = this,
utilDate = Ext.Date,
parsedDate,
result = null;
if (utilDate.formatContainsHourInfo(format)) {
result = utilDate.parse(value, format);
} else {
parsedDate = utilDate.parse(value + ' ' + me.initTime, format + ' ' + me.initTimeFormat);
if (parsedDate) {
result = utilDate.clearTime(parsedDate);
}
}
return result;
},
getSubmitValue: function() {
var me = this,
format = me.submitFormat || me.format,
value = me.getValue();
return value ? Ext.Date.format(value, format) : null;
},
parseDate : function(value) {
if(!value || Ext.isDate(value)){
return value;
}
var me = this,
val = me.safeParse(value, me.format),
altFormats = me.altFormats,
altFormatsArray = me.altFormatsArray,
i = 0,
len;
if (!val && altFormats) {
altFormatsArray = altFormatsArray || altFormats.split('|');
len = altFormatsArray.length;
for (; i < len && !val; ++i) {
val = me.safeParse(value, altFormatsArray[i]);
}
}
return val;
},
formatDate : function(date){
return Ext.isDate(date) ? Ext.Date.dateFormat(date, this.format) : date;
},
createPicker: function() {
var me = this,
format = Ext.String.format;
return Ext.create('Ext.picker.Date', {
ownerCt: me.ownerCt,
renderTo: document.body,
floating: true,
hidden: true,
focusOnShow: true,
minDate: me.minValue,
maxDate: me.maxValue,
disabledDatesRE: me.disabledDatesRE,
disabledDatesText: me.disabledDatesText,
disabledDays: me.disabledDays,
disabledDaysText: me.disabledDaysText,
format: me.format,
showToday: me.showToday,
startDay: me.startDay,
minText: format(me.minText, me.formatDate(me.minValue)),
maxText: format(me.maxText, me.formatDate(me.maxValue)),
listeners: {
scope: me,
select: me.onSelect
},
keyNavConfig: {
esc: function() {
me.collapse();
}
}
});
},
onSelect: function(m, d) {
var me = this;
me.setValue(d);
me.fireEvent('select', me, d);
me.collapse();
},
onExpand: function() {
var me = this,
value = me.getValue();
me.picker.setValue(Ext.isDate(value) ? value : new Date());
},
onCollapse: function() {
this.focus(false, 60);
},
beforeBlur : function(){
var me = this,
v = me.parseDate(me.getRawValue()),
focusTask = me.focusTask;
if (focusTask) {
focusTask.cancel();
}
if (v) {
me.setValue(v);
}
}
});
Ext.define('Ext.form.field.Display', {
extend:'Ext.form.field.Base',
alias: 'widget.displayfield',
requires: ['Ext.util.Format', 'Ext.XTemplate'],
alternateClassName: ['Ext.form.DisplayField', 'Ext.form.Display'],
fieldSubTpl: [
'
',
{
compiled: true,
disableFormats: true
}
],
fieldCls: Ext.baseCSSPrefix + 'form-display-field',
htmlEncode: false,
validateOnChange: false,
initEvents: Ext.emptyFn,
submitValue: false,
isValid: function() {
return true;
},
validate: function() {
return true;
},
getRawValue: function() {
return this.rawValue;
},
setRawValue: function(value) {
var me = this;
value = Ext.value(value, '');
me.rawValue = value;
if (me.rendered) {
me.inputEl.dom.innerHTML = me.htmlEncode ? Ext.util.Format.htmlEncode(value) : value;
}
return value;
},
getContentTarget: function() {
return this.inputEl;
}
});
Ext.define("Ext.form.field.File", {
extend: 'Ext.form.field.Text',
alias: ['widget.filefield', 'widget.fileuploadfield'],
alternateClassName: ['Ext.form.FileUploadField', 'Ext.ux.form.FileUploadField', 'Ext.form.File'],
uses: ['Ext.button.Button', 'Ext.layout.component.field.File'],
buttonText: 'Browse...',
buttonOnly: false,
buttonMargin: 3,
fieldBodyCls: Ext.baseCSSPrefix + 'form-file-wrap',
readOnly: true,
componentLayout: 'filefield',
onRender: function() {
var me = this,
inputEl;
me.callParent(arguments);
me.createButton();
me.createFileInput();
if (me.disabled) {
me.disableItems();
}
inputEl = me.inputEl;
inputEl.dom.removeAttribute('name');
if (me.buttonOnly) {
inputEl.setDisplayed(false);
}
},
createButton: function() {
var me = this;
me.button = Ext.widget('button', Ext.apply({
renderTo: me.bodyEl,
text: me.buttonText,
cls: Ext.baseCSSPrefix + 'form-file-btn',
preventDefault: false,
style: me.buttonOnly ? '' : 'margin-left:' + me.buttonMargin + 'px'
}, me.buttonConfig));
},
createFileInput : function() {
var me = this;
me.fileInputEl = me.button.el.createChild({
name: me.getName(),
cls: Ext.baseCSSPrefix + 'form-file-input',
tag: 'input',
type: 'file',
size: 1
}).on('change', me.onFileChange, me);
},
onFileChange: function() {
this.lastValue = null;
Ext.form.field.File.superclass.setValue.call(this, this.fileInputEl.dom.value);
},
setValue: Ext.emptyFn,
reset : function(){
this.fileInputEl.remove();
this.createFileInput();
this.callParent();
},
onDisable: function(){
this.callParent();
this.disableItems();
},
disableItems: function(){
var file = this.fileInputEl,
button = this.button;
if (file) {
file.dom.disabled = true;
}
if (button) {
button.disable();
}
},
onEnable: function(){
var me = this;
me.callParent();
me.fileInputEl.dom.disabled = false;
me.button.enable();
},
isFileUpload: function() {
return true;
},
extractFileInput: function() {
var fileInput = this.fileInputEl.dom;
this.reset();
return fileInput;
},
onDestroy: function(){
Ext.destroyMembers(this, 'fileInputEl', 'button');
this.callParent();
}
});
Ext.define('Ext.form.field.Hidden', {
extend:'Ext.form.field.Base',
alias: ['widget.hiddenfield', 'widget.hidden'],
alternateClassName: 'Ext.form.Hidden',
inputType : 'hidden',
hideLabel: true,
initComponent: function(){
this.formItemCls += '-hidden';
this.callParent();
},
initEvents: Ext.emptyFn,
setSize : Ext.emptyFn,
setWidth : Ext.emptyFn,
setHeight : Ext.emptyFn,
setPosition : Ext.emptyFn,
setPagePosition : Ext.emptyFn,
markInvalid : Ext.emptyFn,
clearInvalid : Ext.emptyFn
});
Ext.define('Ext.picker.Color', {
extend: 'Ext.Component',
requires: 'Ext.XTemplate',
alias: 'widget.colorpicker',
alternateClassName: 'Ext.ColorPalette',
componentCls : Ext.baseCSSPrefix + 'color-picker',
selectedCls: Ext.baseCSSPrefix + 'color-picker-selected',
value : null,
clickEvent :'click',
allowReselect : false,
colors : [
'000000', '993300', '333300', '003300', '003366', '000080', '333399', '333333',
'800000', 'FF6600', '808000', '008000', '008080', '0000FF', '666699', '808080',
'FF0000', 'FF9900', '99CC00', '339966', '33CCCC', '3366FF', '800080', '969696',
'FF00FF', 'FFCC00', 'FFFF00', '00FF00', '00FFFF', '00CCFF', '993366', 'C0C0C0',
'FF99CC', 'FFCC99', 'FFFF99', 'CCFFCC', 'CCFFFF', '99CCFF', 'CC99FF', 'FFFFFF'
],
colorRe: /(?:^|\s)color-(.{6})(?:\s|$)/,
constructor: function() {
this.renderTpl = Ext.create('Ext.XTemplate', '
',
'',
'',
{
compiled: true,
disableFormats: true
}
],
enableFormat : true,
enableFontSize : true,
enableColors : true,
enableAlignments : true,
enableLists : true,
enableSourceEdit : true,
enableLinks : true,
enableFont : true,
createLinkText : 'Please enter the URL for the link:',
defaultLinkValue : 'http:/'+'/',
fontFamilies : [
'Arial',
'Courier New',
'Tahoma',
'Times New Roman',
'Verdana'
],
defaultFont: 'tahoma',
defaultValue: (Ext.isOpera || Ext.isIE6) ? ' ' : '',
fieldBodyCls: Ext.baseCSSPrefix + 'html-editor-wrap',
componentLayout: 'htmleditor',
initialized : false,
activated : false,
sourceEditMode : false,
iframePad:3,
hideMode:'offsets',
maskOnDisable: true,
initComponent : function(){
var me = this;
me.addEvents(
'initialize',
'activate',
'beforesync',
'beforepush',
'sync',
'push',
'editmodechange'
);
me.callParent(arguments);
me.initLabelable();
me.initField();
},
createToolbar : function(editor){
var me = this,
items = [],
tipsEnabled = Ext.tip.QuickTipManager && Ext.tip.QuickTipManager.isEnabled(),
baseCSSPrefix = Ext.baseCSSPrefix,
fontSelectItem, toolbar, undef;
function btn(id, toggle, handler){
return {
itemId : id,
cls : baseCSSPrefix + 'btn-icon',
iconCls: baseCSSPrefix + 'edit-'+id,
enableToggle:toggle !== false,
scope: editor,
handler:handler||editor.relayBtnCmd,
clickEvent:'mousedown',
tooltip: tipsEnabled ? editor.buttonTips[id] || undef : undef,
overflowText: editor.buttonTips[id].title || undef,
tabIndex:-1
};
}
if (me.enableFont && !Ext.isSafari2) {
fontSelectItem = Ext.widget('component', {
renderTpl: [
'',
'',
' selected >{.}',
'',
' '
],
renderData: {
cls: baseCSSPrefix + 'font-select',
fonts: me.fontFamilies,
defaultFont: me.defaultFont
},
renderSelectors: {
selectEl: 'select'
},
onDisable: function() {
var selectEl = this.selectEl;
if (selectEl) {
selectEl.dom.disabled = true;
}
Ext.Component.superclass.onDisable.apply(this, arguments);
},
onEnable: function() {
var selectEl = this.selectEl;
if (selectEl) {
selectEl.dom.disabled = false;
}
Ext.Component.superclass.onEnable.apply(this, arguments);
}
});
items.push(
fontSelectItem,
'-'
);
}
if (me.enableFormat) {
items.push(
btn('bold'),
btn('italic'),
btn('underline')
);
}
if (me.enableFontSize) {
items.push(
'-',
btn('increasefontsize', false, me.adjustFont),
btn('decreasefontsize', false, me.adjustFont)
);
}
if (me.enableColors) {
items.push(
'-', {
itemId: 'forecolor',
cls: baseCSSPrefix + 'btn-icon',
iconCls: baseCSSPrefix + 'edit-forecolor',
overflowText: editor.buttonTips.forecolor.title,
tooltip: tipsEnabled ? editor.buttonTips.forecolor || undef : undef,
tabIndex:-1,
menu : Ext.widget('menu', {
plain: true,
items: [{
xtype: 'colorpicker',
allowReselect: true,
focus: Ext.emptyFn,
value: '000000',
plain: true,
clickEvent: 'mousedown',
handler: function(cp, color) {
me.execCmd('forecolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
me.deferFocus();
this.up('menu').hide();
}
}]
})
}, {
itemId: 'backcolor',
cls: baseCSSPrefix + 'btn-icon',
iconCls: baseCSSPrefix + 'edit-backcolor',
overflowText: editor.buttonTips.backcolor.title,
tooltip: tipsEnabled ? editor.buttonTips.backcolor || undef : undef,
tabIndex:-1,
menu : Ext.widget('menu', {
plain: true,
items: [{
xtype: 'colorpicker',
focus: Ext.emptyFn,
value: 'FFFFFF',
plain: true,
allowReselect: true,
clickEvent: 'mousedown',
handler: function(cp, color) {
if (Ext.isGecko) {
me.execCmd('useCSS', false);
me.execCmd('hilitecolor', color);
me.execCmd('useCSS', true);
me.deferFocus();
} else {
me.execCmd(Ext.isOpera ? 'hilitecolor' : 'backcolor', Ext.isWebKit || Ext.isIE ? '#'+color : color);
me.deferFocus();
}
this.up('menu').hide();
}
}]
})
}
);
}
if (me.enableAlignments) {
items.push(
'-',
btn('justifyleft'),
btn('justifycenter'),
btn('justifyright')
);
}
if (!Ext.isSafari2) {
if (me.enableLinks) {
items.push(
'-',
btn('createlink', false, me.createLink)
);
}
if (me.enableLists) {
items.push(
'-',
btn('insertorderedlist'),
btn('insertunorderedlist')
);
}
if (me.enableSourceEdit) {
items.push(
'-',
btn('sourceedit', true, function(btn){
me.toggleSourceEdit(!me.sourceEditMode);
})
);
}
}
toolbar = Ext.widget('toolbar', {
renderTo: me.toolbarWrap,
enableOverflow: true,
items: items
});
if (fontSelectItem) {
me.fontSelect = fontSelectItem.selectEl;
me.mon(me.fontSelect, 'change', function(){
me.relayCmd('fontname', me.fontSelect.dom.value);
me.deferFocus();
});
}
me.mon(toolbar.el, 'click', function(e){
e.preventDefault();
});
me.toolbar = toolbar;
},
onDisable: function() {
this.bodyEl.mask();
this.callParent(arguments);
},
onEnable: function() {
this.bodyEl.unmask();
this.callParent(arguments);
},
setReadOnly: function(readOnly) {
var me = this,
textareaEl = me.textareaEl,
iframeEl = me.iframeEl,
body;
me.readOnly = readOnly;
if (textareaEl) {
textareaEl.dom.readOnly = readOnly;
}
if (me.initialized) {
body = me.getEditorBody();
if (Ext.isIE) {
iframeEl.setDisplayed(false);
body.contentEditable = !readOnly;
iframeEl.setDisplayed(true);
} else {
me.setDesignMode(!readOnly);
}
if (body) {
body.style.cursor = readOnly ? 'default' : 'text';
}
me.disableItems(readOnly);
}
},
getDocMarkup: function() {
var me = this,
h = me.iframeEl.getHeight() - me.iframePad * 2;
return Ext.String.format('', me.iframePad, h);
},
getEditorBody: function() {
var doc = this.getDoc();
return doc.body || doc.documentElement;
},
getDoc: function() {
return (!Ext.isIE && this.iframeEl.dom.contentDocument) || this.getWin().document;
},
getWin: function() {
return Ext.isIE ? this.iframeEl.dom.contentWindow : window.frames[this.iframeEl.dom.name];
},
onRender: function() {
var me = this,
renderSelectors = me.renderSelectors;
Ext.applyIf(renderSelectors, me.getLabelableSelectors());
Ext.applyIf(renderSelectors, {
toolbarWrap: 'div.' + Ext.baseCSSPrefix + 'html-editor-tb',
iframeEl: 'iframe',
textareaEl: 'textarea'
});
me.callParent(arguments);
me.textareaEl.dom.value = me.value || '';
me.monitorTask = Ext.TaskManager.start({
run: me.checkDesignMode,
scope: me,
interval:100
});
me.createToolbar(me);
me.disableItems(true);
},
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());
},
getSubTplData: function() {
var cssPrefix = Ext.baseCSSPrefix;
return {
toolbarWrapCls: cssPrefix + 'html-editor-tb',
textareaCls: cssPrefix + 'hidden',
iframeName: Ext.id(),
iframeSrc: Ext.SSL_SECURE_URL,
size: 'height:100px;'
};
},
getSubTplMarkup: function() {
return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
},
getBodyNaturalWidth: function() {
return 565;
},
initFrameDoc: function() {
var me = this,
doc, task;
Ext.TaskManager.stop(me.monitorTask);
doc = me.getDoc();
me.win = me.getWin();
doc.open();
doc.write(me.getDocMarkup());
doc.close();
task = {
run: function() {
var doc = me.getDoc();
if (doc.body || doc.readyState === 'complete') {
Ext.TaskManager.stop(task);
me.setDesignMode(true);
Ext.defer(me.initEditor, 10, me);
}
},
interval : 10,
duration:10000,
scope: me
};
Ext.TaskManager.start(task);
},
checkDesignMode: function() {
var me = this,
doc = me.getDoc();
if (doc && (!doc.editorInitialized || me.getDesignMode() !== 'on')) {
me.initFrameDoc();
}
},
setDesignMode: function(mode) {
var me = this,
doc = me.getDoc();
if (doc) {
if (me.readOnly) {
mode = false;
}
doc.designMode = (/on|true/i).test(String(mode).toLowerCase()) ?'on':'off';
}
},
getDesignMode: function() {
var doc = this.getDoc();
return !doc ? '' : String(doc.designMode).toLowerCase();
},
disableItems: function(disabled) {
this.getToolbar().items.each(function(item){
if(item.getItemId() !== 'sourceedit'){
item.setDisabled(disabled);
}
});
},
toggleSourceEdit: function(sourceEditMode) {
var me = this,
iframe = me.iframeEl,
textarea = me.textareaEl,
hiddenCls = Ext.baseCSSPrefix + 'hidden',
btn = me.getToolbar().getComponent('sourceedit');
if (!Ext.isBoolean(sourceEditMode)) {
sourceEditMode = !me.sourceEditMode;
}
me.sourceEditMode = sourceEditMode;
if (btn.pressed !== sourceEditMode) {
btn.toggle(sourceEditMode);
}
if (sourceEditMode) {
me.disableItems(true);
me.syncValue();
iframe.addCls(hiddenCls);
textarea.removeCls(hiddenCls);
textarea.dom.removeAttribute('tabIndex');
textarea.focus();
}
else {
if (me.initialized) {
me.disableItems(me.readOnly);
}
me.pushValue();
iframe.removeCls(hiddenCls);
textarea.addCls(hiddenCls);
textarea.dom.setAttribute('tabIndex', -1);
me.deferFocus();
}
me.fireEvent('editmodechange', me, sourceEditMode);
me.doComponentLayout();
},
createLink : function() {
var url = prompt(this.createLinkText, this.defaultLinkValue);
if (url && url !== 'http:/'+'/') {
this.relayCmd('createlink', url);
}
},
clearInvalid: Ext.emptyFn,
setValue: function(value) {
var me = this,
textarea = me.textareaEl;
me.mixins.field.setValue.call(me, value);
if (value === null || value === undefined) {
value = '';
}
if (textarea) {
textarea.dom.value = value;
}
me.pushValue();
return this;
},
cleanHtml: function(html) {
html = String(html);
if (Ext.isWebKit) {
html = html.replace(/\sclass="(?:Apple-style-span|khtml-block-placeholder)"/gi, '');
}
if (html.charCodeAt(0) === this.defaultValue.replace(/\D/g, '')) {
html = html.substring(1);
}
return html;
},
syncValue : function(){
var me = this,
body, html, bodyStyle, match;
if (me.initialized) {
body = me.getEditorBody();
html = body.innerHTML;
if (Ext.isWebKit) {
bodyStyle = body.getAttribute('style');
match = bodyStyle.match(/text-align:(.*?);/i);
if (match && match[1]) {
html = '' + html + '
';
}
}
html = me.cleanHtml(html);
if (me.fireEvent('beforesync', me, html) !== false) {
me.textareaEl.dom.value = html;
me.fireEvent('sync', me, html);
}
}
},
getValue : function() {
var me = this,
value;
if (!me.sourceEditMode) {
me.syncValue();
}
value = me.rendered ? me.textareaEl.dom.value : me.value;
me.value = value;
return value;
},
pushValue: function() {
var me = this,
v;
if(me.initialized){
v = me.textareaEl.dom.value || '';
if (!me.activated && v.length < 1) {
v = me.defaultValue;
}
if (me.fireEvent('beforepush', me, v) !== false) {
me.getEditorBody().innerHTML = v;
if (Ext.isGecko) {
me.setDesignMode(false);
me.setDesignMode(true);
}
me.fireEvent('push', me, v);
}
}
},
deferFocus : function(){
this.focus(false, true);
},
getFocusEl: function() {
var me = this,
win = me.win;
return win && !me.sourceEditMode ? win : me.textareaEl;
},
initEditor : function(){
try {
var me = this,
dbody = me.getEditorBody(),
ss = me.textareaEl.getStyles('font-size', 'font-family', 'background-image', 'background-repeat', 'background-color', 'color'),
doc,
fn;
ss['background-attachment'] = 'fixed';
dbody.bgProperties = 'fixed';
Ext.core.DomHelper.applyStyles(dbody, ss);
doc = me.getDoc();
if (doc) {
try {
Ext.EventManager.removeAll(doc);
} catch(e) {}
}
fn = Ext.Function.bind(me.onEditorEvent, me);
Ext.EventManager.on(doc, {
mousedown: fn,
dblclick: fn,
click: fn,
keyup: fn,
buffer:100
});
fn = me.onRelayedEvent;
Ext.EventManager.on(doc, {
mousedown: fn,
mousemove: fn,
mouseup: fn,
click: fn,
dblclick: fn,
scope: me
});
if (Ext.isGecko) {
Ext.EventManager.on(doc, 'keypress', me.applyCommand, me);
}
if (me.fixKeys) {
Ext.EventManager.on(doc, 'keydown', me.fixKeys, me);
}
Ext.EventManager.on(window, 'unload', me.beforeDestroy, me);
doc.editorInitialized = true;
me.initialized = true;
me.pushValue();
me.setReadOnly(me.readOnly);
me.fireEvent('initialize', me);
} catch(ex) {
}
},
beforeDestroy : function(){
var me = this,
monitorTask = me.monitorTask,
doc, prop;
if (monitorTask) {
Ext.TaskManager.stop(monitorTask);
}
if (me.rendered) {
try {
doc = me.getDoc();
if (doc) {
Ext.EventManager.removeAll(doc);
for (prop in doc) {
if (doc.hasOwnProperty(prop)) {
delete doc[prop];
}
}
}
} catch(e) {
}
Ext.destroyMembers('tb', 'toolbarWrap', 'iframeEl', 'textareaEl');
}
me.callParent();
},
onRelayedEvent: function (event) {
var iframeEl = this.iframeEl,
iframeXY = iframeEl.getXY(),
eventXY = event.getXY();
event.xy = [iframeXY[0] + eventXY[0], iframeXY[1] + eventXY[1]];
event.injectEvent(iframeEl);
event.xy = eventXY;
},
onFirstFocus : function(){
var me = this,
selection, range;
me.activated = true;
me.disableItems(me.readOnly);
if (Ext.isGecko) {
me.win.focus();
selection = me.win.getSelection();
if (!selection.focusNode || selection.focusNode.nodeType !== 3) {
range = selection.getRangeAt(0);
range.selectNodeContents(me.getEditorBody());
range.collapse(true);
me.deferFocus();
}
try {
me.execCmd('useCSS', true);
me.execCmd('styleWithCSS', false);
} catch(e) {
}
}
me.fireEvent('activate', me);
},
adjustFont: function(btn) {
var adjust = btn.getItemId() === 'increasefontsize' ? 1 : -1,
size = this.getDoc().queryCommandValue('FontSize') || '2',
isPxSize = Ext.isString(size) && size.indexOf('px') !== -1,
isSafari;
size = parseInt(size, 10);
if (isPxSize) {
if (size <= 10) {
size = 1 + adjust;
}
else if (size <= 13) {
size = 2 + adjust;
}
else if (size <= 16) {
size = 3 + adjust;
}
else if (size <= 18) {
size = 4 + adjust;
}
else if (size <= 24) {
size = 5 + adjust;
}
else {
size = 6 + adjust;
}
size = Ext.Number.constrain(size, 1, 6);
} else {
isSafari = Ext.isSafari;
if (isSafari) {
adjust *= 2;
}
size = Math.max(1, size + adjust) + (isSafari ? 'px' : 0);
}
this.execCmd('FontSize', size);
},
onEditorEvent: function(e) {
this.updateToolbar();
},
updateToolbar: function() {
var me = this,
btns, doc, name, fontSelect;
if (me.readOnly) {
return;
}
if (!me.activated) {
me.onFirstFocus();
return;
}
btns = me.getToolbar().items.map;
doc = me.getDoc();
if (me.enableFont && !Ext.isSafari2) {
name = (doc.queryCommandValue('FontName') || me.defaultFont).toLowerCase();
fontSelect = me.fontSelect.dom;
if (name !== fontSelect.value) {
fontSelect.value = name;
}
}
function updateButtons() {
Ext.Array.forEach(Ext.Array.toArray(arguments), function(name) {
btns[name].toggle(doc.queryCommandState(name));
});
}
if(me.enableFormat){
updateButtons('bold', 'italic', 'underline');
}
if(me.enableAlignments){
updateButtons('justifyleft', 'justifycenter', 'justifyright');
}
if(!Ext.isSafari2 && me.enableLists){
updateButtons('insertorderedlist', 'insertunorderedlist');
}
Ext.menu.Manager.hideAll();
me.syncValue();
},
relayBtnCmd: function(btn) {
this.relayCmd(btn.getItemId());
},
relayCmd: function(cmd, value) {
Ext.defer(function() {
var me = this;
me.focus();
me.execCmd(cmd, value);
me.updateToolbar();
}, 10, this);
},
execCmd : function(cmd, value){
var me = this,
doc = me.getDoc(),
undef;
doc.execCommand(cmd, false, value === undef ? null : value);
me.syncValue();
},
applyCommand : function(e){
if (e.ctrlKey) {
var me = this,
c = e.getCharCode(), cmd;
if (c > 0) {
c = String.fromCharCode(c);
switch (c) {
case 'b':
cmd = 'bold';
break;
case 'i':
cmd = 'italic';
break;
case 'u':
cmd = 'underline';
break;
}
if (cmd) {
me.win.focus();
me.execCmd(cmd);
me.deferFocus();
e.preventDefault();
}
}
}
},
insertAtCursor : function(text){
var me = this,
range;
if (me.activated) {
me.win.focus();
if (Ext.isIE) {
range = me.getDoc().selection.createRange();
if (range) {
range.pasteHTML(text);
me.syncValue();
me.deferFocus();
}
}else{
me.execCmd('InsertHTML', text);
me.deferFocus();
}
}
},
fixKeys: function() {
if (Ext.isIE) {
return function(e){
var me = this,
k = e.getKey(),
doc = me.getDoc(),
range, target;
if (k === e.TAB) {
e.stopEvent();
range = doc.selection.createRange();
if(range){
range.collapse(true);
range.pasteHTML(' ');
me.deferFocus();
}
}
else if (k === e.ENTER) {
range = doc.selection.createRange();
if (range) {
target = range.parentElement();
if(!target || target.tagName.toLowerCase() !== 'li'){
e.stopEvent();
range.pasteHTML('
';
me.callParent();
me.mon(me.store, {
load: me.onStoreLoad,
scope: me
});
},
onStoreLoad: function(){
var me = this;
if (me.invalidateScrollerOnRefresh) {
if (Ext.isGecko) {
if (!me.scrollToTopTask) {
me.scrollToTopTask = Ext.create('Ext.util.DelayedTask', me.scrollToTop, me);
}
me.scrollToTopTask.delay(1);
} else {
me .scrollToTop();
}
}
},
scrollToTop: Ext.emptyFn,
addElListener: function(eventName, fn, scope){
this.mon(this, eventName, fn, scope, {
element: 'el'
});
},
getGridColumns: function() {
return this.headerCt.getGridColumns();
},
getHeaderAtIndex: function(index) {
return this.headerCt.getHeaderAtIndex(index);
},
getCell: function(record, column) {
var row = this.getNode(record);
return Ext.fly(row).down(column.getCellSelector());
},
getFeature: function(id) {
var features = this.featuresMC;
if (features) {
return features.get(id);
}
},
initFeatures: function() {
var me = this,
i = 0,
features,
len;
me.features = me.features || [];
features = me.features;
len = features.length;
me.featuresMC = Ext.create('Ext.util.MixedCollection');
for (; i < len; i++) {
if (!features[i].isFeature) {
features[i] = Ext.create('feature.' + features[i].ftype, features[i]);
}
features[i].view = me;
me.featuresMC.add(features[i]);
}
},
attachEventsForFeatures: function() {
var features = this.features,
ln = features.length,
i = 0;
for (; i < ln; i++) {
if (features[i].isFeature) {
features[i].attachEvents();
}
}
},
afterRender: function() {
var me = this;
me.callParent();
me.mon(me.el, {
scroll: me.fireBodyScroll,
scope: me
});
me.el.unselectable();
me.attachEventsForFeatures();
},
fireBodyScroll: function(e, t) {
this.fireEvent('bodyscroll', e, t);
},
prepareData: function(data, idx, record) {
var me = this,
orig = me.headerCt.prepareData(data, idx, record, me, me.ownerCt),
features = me.features,
ln = features.length,
i = 0,
node, feature;
for (; i < ln; i++) {
feature = features[i];
if (feature.isFeature) {
Ext.apply(orig, feature.getAdditionalData(data, idx, record, orig, me));
}
}
return orig;
},
collectData: function(records, startIndex) {
var preppedRecords = this.callParent(arguments),
headerCt = this.headerCt,
fullWidth = headerCt.getFullWidth(),
features = this.features,
ln = features.length,
o = {
rows: preppedRecords,
fullWidth: fullWidth
},
i = 0,
feature,
j = 0,
jln,
rowParams;
jln = preppedRecords.length;
if (this.getRowClass) {
for (; j < jln; j++) {
rowParams = {};
preppedRecords[j]['rowCls'] = this.getRowClass(records[j], j, rowParams, this.store);
}
}
for (; i < ln; i++) {
feature = features[i];
if (feature.isFeature && feature.collectData && !feature.disabled) {
o = feature.collectData(records, preppedRecords, startIndex, fullWidth, o);
break;
}
}
return o;
},
onHeaderResize: function(header, w, suppressFocus) {
var me = this,
el = me.el;
if (el) {
me.saveScrollState();
if (Ext.isIE6 || Ext.isIE7) {
if (header.el.hasCls(Ext.baseCSSPrefix + 'column-header-first')) {
w += 1;
}
}
el.select('.' + Ext.baseCSSPrefix + 'grid-col-resizer-'+header.id).setWidth(w);
el.select('.' + Ext.baseCSSPrefix + 'grid-table-resizer').setWidth(me.headerCt.getFullWidth());
me.restoreScrollState();
me.setNewTemplate();
if (!suppressFocus) {
me.el.focus();
}
}
},
onHeaderShow: function(headerCt, header, suppressFocus) {
if (header.oldWidth) {
this.onHeaderResize(header, header.oldWidth, suppressFocus);
delete header.oldWidth;
} else if (header.width && !header.flex) {
this.onHeaderResize(header, header.width, suppressFocus);
}
this.setNewTemplate();
},
onHeaderHide: function(headerCt, header, suppressFocus) {
this.onHeaderResize(header, 0, suppressFocus);
},
setNewTemplate: function() {
var me = this,
columns = me.headerCt.getColumnsForTpl(true);
me.tpl = me.getTableChunker().getTableTpl({
columns: columns,
features: me.features
});
},
getTableChunker: function() {
return this.chunker || Ext.view.TableChunker;
},
addRowCls: function(rowInfo, cls) {
var row = this.getNode(rowInfo);
if (row) {
Ext.fly(row).addCls(cls);
}
},
removeRowCls: function(rowInfo, cls) {
var row = this.getNode(rowInfo);
if (row) {
Ext.fly(row).removeCls(cls);
}
},
onRowSelect : function(rowIdx) {
this.addRowCls(rowIdx, this.selectedItemCls);
},
onRowDeselect : function(rowIdx) {
var me = this;
me.removeRowCls(rowIdx, me.selectedItemCls);
me.removeRowCls(rowIdx, me.focusedItemCls);
},
onCellSelect: function(position) {
var cell = this.getCellByPosition(position);
if (cell) {
cell.addCls(this.selectedCellCls);
}
},
onCellDeselect: function(position) {
var cell = this.getCellByPosition(position);
if (cell) {
cell.removeCls(this.selectedCellCls);
}
},
onCellFocus: function(position) {
this.focusCell(position);
},
getCellByPosition: function(position) {
var row = position.row,
column = position.column,
store = this.store,
node = this.getNode(row),
header = this.headerCt.getHeaderAtIndex(column),
cellSelector,
cell = false;
if (header && node) {
cellSelector = header.getCellSelector();
cell = Ext.fly(node).down(cellSelector);
}
return cell;
},
onRowFocus: function(rowIdx, highlight, supressFocus) {
var me = this,
row = me.getNode(rowIdx);
if (highlight) {
me.addRowCls(rowIdx, me.focusedItemCls);
if (!supressFocus) {
me.focusRow(rowIdx);
}
} else {
me.removeRowCls(rowIdx, me.focusedItemCls);
}
},
focusRow: function(rowIdx) {
var me = this,
row = me.getNode(rowIdx),
el = me.el,
adjustment = 0,
panel = me.ownerCt,
rowRegion,
elRegion,
record;
if (row && el) {
elRegion = el.getRegion();
rowRegion = Ext.fly(row).getRegion();
if (rowRegion.top < elRegion.top) {
adjustment = rowRegion.top - elRegion.top;
} else if (rowRegion.bottom > elRegion.bottom) {
adjustment = rowRegion.bottom - elRegion.bottom;
}
record = me.getRecord(row);
rowIdx = me.store.indexOf(record);
if (adjustment) {
panel.scrollByDeltaY(adjustment);
}
me.fireEvent('rowfocus', record, row, rowIdx);
}
},
focusCell: function(position) {
var me = this,
cell = me.getCellByPosition(position),
el = me.el,
adjustmentY = 0,
adjustmentX = 0,
elRegion = el.getRegion(),
panel = me.ownerCt,
cellRegion,
record;
if (cell) {
cellRegion = cell.getRegion();
if (cellRegion.top < elRegion.top) {
adjustmentY = cellRegion.top - elRegion.top;
} else if (cellRegion.bottom > elRegion.bottom) {
adjustmentY = cellRegion.bottom - elRegion.bottom;
}
if (cellRegion.left < elRegion.left) {
adjustmentX = cellRegion.left - elRegion.left;
} else if (cellRegion.right > elRegion.right) {
adjustmentX = cellRegion.right - elRegion.right;
}
if (adjustmentY) {
panel.scrollByDeltaY(adjustmentY);
}
if (adjustmentX) {
panel.scrollByDeltaX(adjustmentX);
}
el.focus();
me.fireEvent('cellfocus', record, cell, position);
}
},
scrollByDelta: function(delta, dir) {
dir = dir || 'scrollTop';
var elDom = this.el.dom;
elDom[dir] = (elDom[dir] += delta);
},
onUpdate: function(ds, index) {
this.callParent(arguments);
},
saveScrollState: function() {
var dom = this.el.dom,
state = this.scrollState;
state.left = dom.scrollLeft;
state.top = dom.scrollTop;
},
restoreScrollState: function() {
var dom = this.el.dom,
state = this.scrollState,
headerEl = this.headerCt.el.dom;
headerEl.scrollLeft = dom.scrollLeft = state.left;
dom.scrollTop = state.top;
},
refresh: function() {
this.setNewTemplate();
this.callParent(arguments);
},
processItemEvent: function(record, row, rowIndex, e) {
var me = this,
cell = e.getTarget(me.cellSelector, row),
cellIndex = cell ? cell.cellIndex : -1,
map = me.statics().EventMap,
selModel = me.getSelectionModel(),
type = e.type,
result;
if (type == 'keydown' && !cell && selModel.getCurrentPosition) {
cell = me.getCellByPosition(selModel.getCurrentPosition());
if (cell) {
cell = cell.dom;
cellIndex = cell.cellIndex;
}
}
result = me.fireEvent('uievent', type, me, cell, rowIndex, cellIndex, e);
if (result === false || me.callParent(arguments) === false) {
return false;
}
if (type == 'mouseover' || type == 'mouseout') {
return true;
}
return !(
(me['onBeforeCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
(me.fireEvent('beforecell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false) ||
(me['onCell' + map[type]](cell, cellIndex, record, row, rowIndex, e) === false) ||
(me.fireEvent('cell' + type, me, cell, cellIndex, record, row, rowIndex, e) === false)
);
},
processSpecialEvent: function(e) {
var me = this,
map = me.statics().EventMap,
features = me.features,
ln = features.length,
type = e.type,
i, feature, prefix, featureTarget,
beforeArgs, args,
panel = me.ownerCt;
me.callParent(arguments);
if (type == 'mouseover' || type == 'mouseout') {
return;
}
for (i = 0; i < ln; i++) {
feature = features[i];
if (feature.hasFeatureEvent) {
featureTarget = e.getTarget(feature.eventSelector, me.getTargetEl());
if (featureTarget) {
prefix = feature.eventPrefix;
beforeArgs = feature.getFireEventArgs('before' + prefix + type, me, featureTarget, e);
args = feature.getFireEventArgs(prefix + type, me, featureTarget, e);
if (
(me.fireEvent.apply(me, beforeArgs) === false) ||
(panel.fireEvent.apply(panel, beforeArgs) === false) ||
(me.fireEvent.apply(me, args) === false) ||
(panel.fireEvent.apply(panel, args) === false)
) {
return false;
}
}
}
}
return true;
},
onCellMouseDown: Ext.emptyFn,
onCellMouseUp: Ext.emptyFn,
onCellClick: Ext.emptyFn,
onCellDblClick: Ext.emptyFn,
onCellContextMenu: Ext.emptyFn,
onCellKeyDown: Ext.emptyFn,
onBeforeCellMouseDown: Ext.emptyFn,
onBeforeCellMouseUp: Ext.emptyFn,
onBeforeCellClick: Ext.emptyFn,
onBeforeCellDblClick: Ext.emptyFn,
onBeforeCellContextMenu: Ext.emptyFn,
onBeforeCellKeyDown: Ext.emptyFn,
expandToFit: function(header) {
if (header) {
var maxWidth = this.getMaxContentWidth(header);
delete header.flex;
header.setWidth(maxWidth);
}
},
getMaxContentWidth: function(header) {
var cellSelector = header.getCellInnerSelector(),
cells = this.el.query(cellSelector),
i = 0,
ln = cells.length,
maxWidth = header.el.dom.scrollWidth,
scrollWidth;
for (; i < ln; i++) {
scrollWidth = cells[i].scrollWidth;
if (scrollWidth > maxWidth) {
maxWidth = scrollWidth;
}
}
return maxWidth;
},
getPositionByEvent: function(e) {
var me = this,
cellNode = e.getTarget(me.cellSelector),
rowNode = e.getTarget(me.itemSelector),
record = me.getRecord(rowNode),
header = me.getHeaderByCell(cellNode);
return me.getPosition(record, header);
},
getHeaderByCell: function(cell) {
if (cell) {
var m = cell.className.match(this.cellRe);
if (m && m[1]) {
return Ext.getCmp(m[1]);
}
}
return false;
},
walkCells: function(pos, direction, e, preventWrap, verifierFn, scope) {
var me = this,
row = pos.row,
column = pos.column,
rowCount = me.store.getCount(),
firstCol = me.getFirstVisibleColumnIndex(),
lastCol = me.getLastVisibleColumnIndex(),
newPos = {row: row, column: column},
activeHeader = me.headerCt.getHeaderAtIndex(column);
if (!activeHeader || activeHeader.hidden) {
return false;
}
e = e || {};
direction = direction.toLowerCase();
switch (direction) {
case 'right':
if (column === lastCol) {
if (preventWrap || row === rowCount - 1) {
return false;
}
if (!e.ctrlKey) {
newPos.row = row + 1;
newPos.column = firstCol;
}
} else {
if (!e.ctrlKey) {
newPos.column = column + me.getRightGap(activeHeader);
} else {
newPos.column = lastCol;
}
}
break;
case 'left':
if (column === firstCol) {
if (preventWrap || row === 0) {
return false;
}
if (!e.ctrlKey) {
newPos.row = row - 1;
newPos.column = lastCol;
}
} else {
if (!e.ctrlKey) {
newPos.column = column + me.getLeftGap(activeHeader);
} else {
newPos.column = firstCol;
}
}
break;
case 'up':
if (row === 0) {
return false;
} else {
if (!e.ctrlKey) {
newPos.row = row - 1;
} else {
newPos.row = 0;
}
}
break;
case 'down':
if (row === rowCount - 1) {
return false;
} else {
if (!e.ctrlKey) {
newPos.row = row + 1;
} else {
newPos.row = rowCount - 1;
}
}
break;
}
if (verifierFn && verifierFn.call(scope || window, newPos) !== true) {
return false;
} else {
return newPos;
}
},
getFirstVisibleColumnIndex: function() {
var headerCt = this.getHeaderCt(),
allColumns = headerCt.getGridColumns(),
visHeaders = Ext.ComponentQuery.query(':not([hidden])', allColumns),
firstHeader = visHeaders[0];
return headerCt.getHeaderIndex(firstHeader);
},
getLastVisibleColumnIndex: function() {
var headerCt = this.getHeaderCt(),
allColumns = headerCt.getGridColumns(),
visHeaders = Ext.ComponentQuery.query(':not([hidden])', allColumns),
lastHeader = visHeaders[visHeaders.length - 1];
return headerCt.getHeaderIndex(lastHeader);
},
getHeaderCt: function() {
return this.headerCt;
},
getPosition: function(record, header) {
var me = this,
store = me.store,
gridCols = me.headerCt.getGridColumns();
return {
row: store.indexOf(record),
column: Ext.Array.indexOf(gridCols, header)
};
},
getRightGap: function(activeHeader) {
var headerCt = this.getHeaderCt(),
headers = headerCt.getGridColumns(),
activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
i = activeHeaderIdx + 1,
nextIdx;
for (; i <= headers.length; i++) {
if (!headers[i].hidden) {
nextIdx = i;
break;
}
}
return nextIdx - activeHeaderIdx;
},
beforeDestroy: function() {
if (this.rendered) {
this.el.removeAllListeners();
}
this.callParent(arguments);
},
getLeftGap: function(activeHeader) {
var headerCt = this.getHeaderCt(),
headers = headerCt.getGridColumns(),
activeHeaderIdx = Ext.Array.indexOf(headers, activeHeader),
i = activeHeaderIdx - 1,
prevIdx;
for (; i >= 0; i--) {
if (!headers[i].hidden) {
prevIdx = i;
break;
}
}
return prevIdx - activeHeaderIdx;
}
});
Ext.define('Ext.grid.View', {
extend: 'Ext.view.Table',
alias: 'widget.gridview',
stripeRows: true,
invalidateScrollerOnRefresh: true,
scrollToTop : function(){
if (this.rendered) {
var section = this.ownerCt,
verticalScroller = section.verticalScroller;
if (verticalScroller) {
verticalScroller.scrollToTop();
}
}
},
onAdd: function(ds, records, index) {
this.callParent(arguments);
this.doStripeRows(index);
},
onRemove: function(ds, records, index) {
this.callParent(arguments);
this.doStripeRows(index);
},
onUpdate: function(ds, record, operation) {
var index = ds.indexOf(record);
this.callParent(arguments);
this.doStripeRows(index, index);
},
doStripeRows: function(startRow, endRow) {
if (this.stripeRows) {
var rows = this.getNodes(startRow, endRow),
rowsLn = rows.length,
i = 0,
row;
for (; i < rowsLn; i++) {
row = rows[i];
row.className = row.className.replace(this.rowClsRe, ' ');
startRow++;
if (startRow % 2 === 0) {
row.className += (' ' + this.altRowCls);
}
}
}
},
refresh: function(firstPass) {
this.callParent(arguments);
this.doStripeRows(0);
var g = this.up('gridpanel');
if (g && this.invalidateScrollerOnRefresh) {
g.invalidateScroller();
}
}
});
Ext.define('Ext.grid.Panel', {
extend: 'Ext.panel.Table',
requires: ['Ext.grid.View'],
alias: ['widget.gridpanel', 'widget.grid'],
alternateClassName: ['Ext.list.ListView', 'Ext.ListView', 'Ext.grid.GridPanel'],
viewType: 'gridview',
lockable: false,
normalCfgCopy: ['invalidateScrollerOnRefresh', 'verticalScroller', 'verticalScrollDock', 'verticalScrollerType', 'scroll'],
lockedCfgCopy: ['invalidateScrollerOnRefresh'],
initComponent: function() {
var me = this;
if (me.columnLines) {
me.setColumnLines(me.columnLines);
}
me.callParent();
},
setColumnLines: function(show) {
var me = this,
method = (show) ? 'addClsWithUI' : 'removeClsWithUI';
me[method]('with-col-lines')
}
});
Ext.define('Ext.grid.RowEditor', {
extend: 'Ext.form.Panel',
requires: [
'Ext.tip.ToolTip',
'Ext.util.HashMap',
'Ext.util.KeyNav'
],
saveBtnText : 'Update',
cancelBtnText: 'Cancel',
errorsText: 'Errors',
dirtyText: 'You need to commit or cancel your changes',
lastScrollLeft: 0,
lastScrollTop: 0,
border: false,
hideMode: 'offsets',
initComponent: function() {
var me = this,
form;
me.cls = Ext.baseCSSPrefix + 'grid-row-editor';
me.layout = {
type: 'hbox',
align: 'middle'
};
me.columns = Ext.create('Ext.util.HashMap');
me.columns.getKey = function(columnHeader) {
var f;
if (columnHeader.getEditor) {
f = columnHeader.getEditor();
if (f) {
return f.id;
}
}
return columnHeader.id;
};
me.mon(me.columns, {
add: me.onFieldAdd,
remove: me.onFieldRemove,
replace: me.onFieldReplace,
scope: me
});
me.callParent(arguments);
if (me.fields) {
me.setField(me.fields);
delete me.fields;
}
form = me.getForm();
form.trackResetOnLoad = true;
},
onFieldChange: function() {
var me = this,
form = me.getForm(),
valid = form.isValid();
if (me.errorSummary && me.isVisible()) {
me[valid ? 'hideToolTip' : 'showToolTip']();
}
if (me.floatingButtons) {
me.floatingButtons.child('#update').setDisabled(!valid);
}
me.isValid = valid;
},
afterRender: function() {
var me = this,
plugin = me.editingPlugin;
me.callParent(arguments);
me.mon(me.renderTo, 'scroll', me.onCtScroll, me, { buffer: 100 });
me.mon(me.el, {
click: Ext.emptyFn,
stopPropagation: true
});
me.el.swallowEvent([
'keypress',
'keydown'
]);
me.keyNav = Ext.create('Ext.util.KeyNav', me.el, {
enter: plugin.completeEdit,
esc: plugin.onEscKey,
scope: plugin
});
me.mon(plugin.view, {
beforerefresh: me.onBeforeViewRefresh,
refresh: me.onViewRefresh,
scope: me
});
},
onBeforeViewRefresh: function(view) {
var me = this,
viewDom = view.el.dom;
if (me.el.dom.parentNode === viewDom) {
viewDom.removeChild(me.el.dom);
}
},
onViewRefresh: function(view) {
var me = this,
viewDom = view.el.dom,
context = me.context,
idx;
viewDom.appendChild(me.el.dom);
if (context && (idx = context.store.indexOf(context.record)) >= 0) {
context.row = view.getNode(idx);
me.reposition();
if (me.tooltip && me.tooltip.isVisible()) {
me.tooltip.setTarget(context.row);
}
} else {
me.editingPlugin.cancelEdit();
}
},
onCtScroll: function(e, target) {
var me = this,
scrollTop = target.scrollTop,
scrollLeft = target.scrollLeft;
if (scrollTop !== me.lastScrollTop) {
me.lastScrollTop = scrollTop;
if ((me.tooltip && me.tooltip.isVisible()) || me.hiddenTip) {
me.repositionTip();
}
}
if (scrollLeft !== me.lastScrollLeft) {
me.lastScrollLeft = scrollLeft;
me.reposition();
}
},
onColumnAdd: function(column) {
this.setField(column);
},
onColumnRemove: function(column) {
this.columns.remove(column);
},
onColumnResize: function(column, width) {
column.getEditor().setWidth(width - 2);
if (this.isVisible()) {
this.reposition();
}
},
onColumnHide: function(column) {
column.getEditor().hide();
if (this.isVisible()) {
this.reposition();
}
},
onColumnShow: function(column) {
var field = column.getEditor();
field.setWidth(column.getWidth() - 2).show();
if (this.isVisible()) {
this.reposition();
}
},
onColumnMove: function(column, fromIdx, toIdx) {
var field = column.getEditor();
if (this.items.indexOf(field) != toIdx) {
this.move(fromIdx, toIdx);
}
},
onFieldAdd: function(map, fieldId, column) {
var me = this,
colIdx = me.editingPlugin.grid.headerCt.getHeaderIndex(column),
field = column.getEditor({ xtype: 'displayfield' });
me.insert(colIdx, field);
},
onFieldRemove: function(map, fieldId, column) {
var me = this,
field = column.getEditor(),
fieldEl = field.el;
me.remove(field, false);
if (fieldEl) {
fieldEl.remove();
}
},
onFieldReplace: function(map, fieldId, column, oldColumn) {
var me = this;
me.onFieldRemove(map, fieldId, oldColumn);
},
clearFields: function() {
var me = this,
map = me.columns;
map.each(function(fieldId) {
map.removeAtKey(fieldId);
});
},
getFloatingButtons: function() {
var me = this,
cssPrefix = Ext.baseCSSPrefix,
btnsCss = cssPrefix + 'grid-row-editor-buttons',
plugin = me.editingPlugin,
btns;
if (!me.floatingButtons) {
btns = me.floatingButtons = Ext.create('Ext.Container', {
renderTpl: [
'
',
'
',
'
',
'
',
'
'
],
renderTo: me.el,
baseCls: btnsCss,
layout: {
type: 'hbox',
align: 'middle'
},
defaults: {
margins: '0 1 0 1'
},
items: [{
itemId: 'update',
flex: 1,
xtype: 'button',
handler: plugin.completeEdit,
scope: plugin,
text: me.saveBtnText,
disabled: !me.isValid
}, {
flex: 1,
xtype: 'button',
handler: plugin.cancelEdit,
scope: plugin,
text: me.cancelBtnText
}]
});
me.mon(btns.el, {
mousedown: Ext.emptyFn,
click: Ext.emptyFn,
stopEvent: true
});
}
return me.floatingButtons;
},
reposition: function(animateConfig) {
var me = this,
context = me.context,
row = context && Ext.get(context.row),
btns = me.getFloatingButtons(),
btnEl = btns.el,
grid = me.editingPlugin.grid,
viewEl = grid.view.el,
scroller = grid.verticalScroller,
mainBodyWidth = grid.headerCt.getFullWidth(),
scrollerWidth = grid.getWidth(),
width = Math.min(mainBodyWidth, scrollerWidth),
scrollLeft = grid.view.el.dom.scrollLeft,
btnWidth = btns.getWidth(),
left = (width - btnWidth) / 2 + scrollLeft,
y, rowH, newHeight,
invalidateScroller = function() {
if (scroller) {
scroller.invalidate();
btnEl.scrollIntoView(viewEl, false);
}
if (animateConfig && animateConfig.callback) {
animateConfig.callback.call(animateConfig.scope || me);
}
};
if (row && Ext.isElement(row.dom)) {
row.scrollIntoView(viewEl, false);
y = row.getXY()[1] - 5;
rowH = row.getHeight();
newHeight = rowH + 10;
if (Ext.isIE) {
newHeight += 2;
}
if (me.getHeight() != newHeight) {
me.setHeight(newHeight);
me.el.setLeft(0);
}
if (animateConfig) {
var animObj = {
to: {
y: y
},
duration: animateConfig.duration || 125,
listeners: {
afteranimate: function() {
invalidateScroller();
y = row.getXY()[1] - 5;
me.el.setY(y);
}
}
};
me.animate(animObj);
} else {
me.el.setY(y);
invalidateScroller();
}
}
if (me.getWidth() != mainBodyWidth) {
me.setWidth(mainBodyWidth);
}
btnEl.setLeft(left);
},
getEditor: function(fieldInfo) {
var me = this;
if (Ext.isNumber(fieldInfo)) {
return me.query('>[isFormField]')[fieldInfo];
} else if (fieldInfo instanceof Ext.grid.column.Column) {
return fieldInfo.getEditor();
}
},
removeField: function(field) {
var me = this;
field = me.getEditor(field);
me.mun(field, 'validitychange', me.onValidityChange, me);
me.columns.removeKey(field.id);
},
setField: function(column) {
var me = this,
field;
if (Ext.isArray(column)) {
Ext.Array.forEach(column, me.setField, me);
return;
}
field = column.getEditor(null, {
xtype: 'displayfield',
getModelData: function() {
return null;
}
});
field.margins = '0 0 0 2';
field.setWidth(column.getDesiredWidth() - 2);
me.mon(field, 'change', me.onFieldChange, me);
me.columns.add(field.id, column);
if (me.isVisible() && me.context) {
me.renderColumnData(field, me.context.record);
}
},
loadRecord: function(record) {
var me = this,
form = me.getForm();
form.loadRecord(record);
if (form.isValid()) {
me.hideToolTip();
} else {
me.showToolTip();
}
Ext.Array.forEach(me.query('>displayfield'), function(field) {
me.renderColumnData(field, record);
}, me);
},
renderColumnData: function(field, record) {
var me = this,
grid = me.editingPlugin.grid,
headerCt = grid.headerCt,
view = grid.view,
store = view.store,
column = me.columns.get(field.id),
value = record.get(column.dataIndex);
if (column.renderer) {
var metaData = { tdCls: '', style: '' },
rowIdx = store.indexOf(record),
colIdx = headerCt.getHeaderIndex(column);
value = column.renderer.call(
column.scope || headerCt.ownerCt,
value,
metaData,
record,
rowIdx,
colIdx,
store,
view
);
}
field.setRawValue(value);
field.resetOriginalValue();
},
beforeEdit: function() {
var me = this;
if (me.isVisible() && !me.autoCancel && me.isDirty()) {
me.showToolTip();
return false;
}
},
startEdit: function(record, columnHeader) {
var me = this,
grid = me.editingPlugin.grid,
view = grid.getView(),
store = grid.store,
context = me.context = Ext.apply(me.editingPlugin.context, {
view: grid.getView(),
store: store
});
context.grid.getSelectionModel().select(record);
me.loadRecord(record);
if (!me.isVisible()) {
me.show();
me.focusContextCell();
} else {
me.reposition({
callback: this.focusContextCell
});
}
},
focusContextCell: function() {
var field = this.getEditor(this.context.colIdx);
if (field && field.focus) {
field.focus();
}
},
cancelEdit: function() {
var me = this,
form = me.getForm();
me.hide();
form.clearInvalid();
form.reset();
},
completeEdit: function() {
var me = this,
form = me.getForm();
if (!form.isValid()) {
return;
}
form.updateRecord(me.context.record);
me.hide();
return true;
},
onShow: function() {
var me = this;
me.callParent(arguments);
me.reposition();
},
onHide: function() {
var me = this;
me.callParent(arguments);
me.hideToolTip();
me.invalidateScroller();
if (me.context) {
me.context.view.focus();
me.context = null;
}
},
isDirty: function() {
var me = this,
form = me.getForm();
return form.isDirty();
},
getToolTip: function() {
var me = this,
tip;
if (!me.tooltip) {
tip = me.tooltip = Ext.createWidget('tooltip', {
cls: Ext.baseCSSPrefix + 'grid-row-editor-errors',
title: me.errorsText,
autoHide: false,
closable: true,
closeAction: 'disable',
anchor: 'left'
});
}
return me.tooltip;
},
hideToolTip: function() {
var me = this,
tip = me.getToolTip();
if (tip.rendered) {
tip.disable();
}
me.hiddenTip = false;
},
showToolTip: function() {
var me = this,
tip = me.getToolTip(),
context = me.context,
row = Ext.get(context.row),
viewEl = context.grid.view.el;
tip.setTarget(row);
tip.showAt([-10000, -10000]);
tip.body.update(me.getErrors());
tip.mouseOffset = [viewEl.getWidth() - row.getWidth() + me.lastScrollLeft + 15, 0];
me.repositionTip();
tip.doLayout();
tip.enable();
},
repositionTip: function() {
var me = this,
tip = me.getToolTip(),
context = me.context,
row = Ext.get(context.row),
viewEl = context.grid.view.el,
viewHeight = viewEl.getHeight(),
viewTop = me.lastScrollTop,
viewBottom = viewTop + viewHeight,
rowHeight = row.getHeight(),
rowTop = row.dom.offsetTop,
rowBottom = rowTop + rowHeight;
if (rowBottom > viewTop && rowTop < viewBottom) {
tip.show();
me.hiddenTip = false;
} else {
tip.hide();
me.hiddenTip = true;
}
},
getErrors: function() {
var me = this,
dirtyText = !me.autoCancel && me.isDirty() ? me.dirtyText + '' + e + ' ';
})
);
}, me);
return dirtyText + '';
},
invalidateScroller: function() {
var me = this,
context = me.context,
scroller = context.grid.verticalScroller;
if (scroller) {
scroller.invalidate();
}
}
});
Ext.define('Ext.grid.header.Container', {
extend: 'Ext.container.Container',
uses: [
'Ext.grid.ColumnLayout',
'Ext.grid.column.Column',
'Ext.menu.Menu',
'Ext.menu.CheckItem',
'Ext.menu.Separator',
'Ext.grid.plugin.HeaderResizer',
'Ext.grid.plugin.HeaderReorderer'
],
border: true,
alias: 'widget.headercontainer',
baseCls: Ext.baseCSSPrefix + 'grid-header-ct',
dock: 'top',
weight: 100,
defaultType: 'gridcolumn',
defaultWidth: 100,
sortAscText: 'Sort Ascending',
sortDescText: 'Sort Descending',
sortClearText: 'Clear Sort',
columnsText: 'Columns',
lastHeaderCls: Ext.baseCSSPrefix + 'column-header-last',
firstHeaderCls: Ext.baseCSSPrefix + 'column-header-first',
headerOpenCls: Ext.baseCSSPrefix + 'column-header-open',
triStateSort: false,
ddLock: false,
dragging: false,
sortable: true,
initComponent: function() {
var me = this;
me.headerCounter = 0;
me.plugins = me.plugins || [];
if (!me.isHeader) {
me.resizer = Ext.create('Ext.grid.plugin.HeaderResizer');
me.reorderer = Ext.create('Ext.grid.plugin.HeaderReorderer');
if (!me.enableColumnResize) {
me.resizer.disable();
}
if (!me.enableColumnMove) {
me.reorderer.disable();
}
me.plugins.push(me.reorderer, me.resizer);
}
if (me.isHeader && !me.items) {
me.layout = 'auto';
}
else {
me.layout = {
type: 'gridcolumn',
availableSpaceOffset: me.availableSpaceOffset,
align: 'stretchmax',
resetStretch: true
};
}
me.defaults = me.defaults || {};
Ext.applyIf(me.defaults, {
width: me.defaultWidth,
triStateSort: me.triStateSort,
sortable: me.sortable
});
me.callParent();
me.addEvents(
'columnresize',
'headerclick',
'headertriggerclick',
'columnmove',
'columnhide',
'columnshow',
'sortchange',
'menucreate'
);
},
onDestroy: function() {
Ext.destroy(this.resizer, this.reorderer);
this.callParent();
},
onAdd: function(c) {
var me = this;
if (!c.headerId) {
c.headerId = 'h' + (++me.headerCounter);
}
me.callParent(arguments);
me.purgeCache();
},
onRemove: function(c) {
var me = this;
me.callParent(arguments);
me.purgeCache();
},
afterRender: function() {
this.callParent();
var store = this.up('[store]').store,
sorters = store.sorters,
first = sorters.first(),
hd;
if (first) {
hd = this.down('gridcolumn[dataIndex=' + first.property +']');
if (hd) {
hd.setSortState(first.direction, false, true);
}
}
},
afterLayout: function() {
if (!this.isHeader) {
var me = this,
topHeaders = me.query('>gridcolumn:not([hidden])'),
viewEl,
firstHeaderEl,
lastHeaderEl;
me.callParent(arguments);
if (topHeaders.length) {
firstHeaderEl = topHeaders[0].el;
if (firstHeaderEl !== me.pastFirstHeaderEl) {
if (me.pastFirstHeaderEl) {
me.pastFirstHeaderEl.removeCls(me.firstHeaderCls);
}
firstHeaderEl.addCls(me.firstHeaderCls);
me.pastFirstHeaderEl = firstHeaderEl;
}
lastHeaderEl = topHeaders[topHeaders.length - 1].el;
if (lastHeaderEl !== me.pastLastHeaderEl) {
if (me.pastLastHeaderEl) {
me.pastLastHeaderEl.removeCls(me.lastHeaderCls);
}
lastHeaderEl.addCls(me.lastHeaderCls);
me.pastLastHeaderEl = lastHeaderEl
}
}
}
},
onHeaderShow: function(header) {
var me = this,
gridSection = me.ownerCt,
menu = me.getMenu(),
topItems, topItemsVisible,
colCheckItem,
itemToEnable,
len, i;
if (menu) {
colCheckItem = menu.down('menucheckitem[headerId=' + header.id + ']');
if (colCheckItem) {
colCheckItem.setChecked(true, true);
}
topItems = menu.query('#columnItem>menucheckitem[checked]');
topItemsVisible = topItems.length;
if ((me.getVisibleGridColumns().length > 1) && me.disabledMenuItems && me.disabledMenuItems.length) {
if (topItemsVisible == 1) {
Ext.Array.remove(me.disabledMenuItems, topItems[0]);
}
for (i = 0, len = me.disabledMenuItems.length; i < len; i++) {
itemToEnable = me.disabledMenuItems[i];
if (!itemToEnable.isDestroyed) {
itemToEnable[itemToEnable.menu ? 'enableCheckChange' : 'enable']();
}
}
if (topItemsVisible == 1) {
me.disabledMenuItems = topItems;
} else {
me.disabledMenuItems = [];
}
}
}
if (!header.isGroupHeader) {
if (me.view) {
me.view.onHeaderShow(me, header, true);
}
if (gridSection) {
gridSection.onHeaderShow(me, header);
}
}
me.fireEvent('columnshow', me, header);
me.doLayout();
},
onHeaderHide: function(header, suppressLayout) {
var me = this,
gridSection = me.ownerCt,
menu = me.getMenu(),
colCheckItem;
if (menu) {
colCheckItem = menu.down('menucheckitem[headerId=' + header.id + ']');
if (colCheckItem) {
colCheckItem.setChecked(false, true);
}
me.setDisabledItems();
}
if (!header.isGroupHeader) {
if (me.view) {
me.view.onHeaderHide(me, header, true);
}
if (gridSection) {
gridSection.onHeaderHide(me, header);
}
if (!suppressLayout) {
me.doLayout();
}
}
me.fireEvent('columnhide', me, header);
},
setDisabledItems: function(){
var me = this,
menu = me.getMenu(),
i = 0,
len,
itemsToDisable,
itemToDisable;
itemsToDisable = menu.query('#columnItem>menucheckitem[checked]');
if ((itemsToDisable.length === 1)) {
if (!me.disabledMenuItems) {
me.disabledMenuItems = [];
}
if ((me.getVisibleGridColumns().length === 1) && itemsToDisable[0].menu) {
itemsToDisable = itemsToDisable.concat(itemsToDisable[0].menu.query('menucheckitem[checked]'));
}
len = itemsToDisable.length;
for (i = 0; i < len; i++) {
itemToDisable = itemsToDisable[i];
if (!Ext.Array.contains(me.disabledMenuItems, itemToDisable)) {
itemToDisable.disabled = false;
itemToDisable[itemToDisable.menu ? 'disableCheckChange' : 'disable']();
me.disabledMenuItems.push(itemToDisable);
}
}
}
},
tempLock: function() {
this.ddLock = true;
Ext.Function.defer(function() {
this.ddLock = false;
}, 200, this);
},
onHeaderResize: function(header, w, suppressFocus) {
this.tempLock();
if (this.view && this.view.rendered) {
this.view.onHeaderResize(header, w, suppressFocus);
}
this.fireEvent('columnresize', this, header, w);
},
onHeaderClick: function(header, e, t) {
this.fireEvent("headerclick", this, header, e, t);
},
onHeaderTriggerClick: function(header, e, t) {
if (this.fireEvent("headertriggerclick", this, header, e, t) !== false) {
this.showMenuBy(t, header);
}
},
showMenuBy: function(t, header) {
var menu = this.getMenu(),
ascItem = menu.down('#ascItem'),
descItem = menu.down('#descItem'),
sortableMth;
menu.activeHeader = menu.ownerCt = header;
menu.setFloatParent(header);
header.titleContainer.addCls(this.headerOpenCls);
sortableMth = header.sortable ? 'enable' : 'disable';
if (ascItem) {
ascItem[sortableMth]();
}
if (descItem) {
descItem[sortableMth]();
}
menu.showBy(t);
},
onMenuDeactivate: function() {
var menu = this.getMenu();
menu.activeHeader.titleContainer.removeCls(this.headerOpenCls);
},
moveHeader: function(fromIdx, toIdx) {
this.tempLock();
this.onHeaderMoved(this.move(fromIdx, toIdx), fromIdx, toIdx);
},
purgeCache: function() {
var me = this;
delete me.gridDataColumns;
if (me.menu) {
me.menu.destroy();
delete me.menu;
}
},
onHeaderMoved: function(header, fromIdx, toIdx) {
var me = this,
gridSection = me.ownerCt;
if (gridSection) {
gridSection.onHeaderMove(me, header, fromIdx, toIdx);
}
me.fireEvent("columnmove", me, header, fromIdx, toIdx);
},
getMenu: function() {
var me = this;
if (!me.menu) {
me.menu = Ext.create('Ext.menu.Menu', {
hideOnParentHide: false,
items: me.getMenuItems(),
listeners: {
deactivate: me.onMenuDeactivate,
scope: me
}
});
me.setDisabledItems();
me.fireEvent('menucreate', me, me.menu);
}
return me.menu;
},
getMenuItems: function() {
var me = this,
menuItems = [],
hideableColumns = me.enableColumnHide ? me.getColumnMenu(me) : null;
if (me.sortable) {
menuItems = [{
itemId: 'ascItem',
text: me.sortAscText,
cls: 'xg-hmenu-sort-asc',
handler: me.onSortAscClick,
scope: me
},{
itemId: 'descItem',
text: me.sortDescText,
cls: 'xg-hmenu-sort-desc',
handler: me.onSortDescClick,
scope: me
}];
};
if (hideableColumns && hideableColumns.length) {
menuItems.push('-', {
itemId: 'columnItem',
text: me.columnsText,
cls: Ext.baseCSSPrefix + 'cols-icon',
menu: hideableColumns
});
}
return menuItems;
},
onSortAscClick: function() {
var menu = this.getMenu(),
activeHeader = menu.activeHeader;
activeHeader.setSortState('ASC');
},
onSortDescClick: function() {
var menu = this.getMenu(),
activeHeader = menu.activeHeader;
activeHeader.setSortState('DESC');
},
getColumnMenu: function(headerContainer) {
var menuItems = [],
i = 0,
item,
items = headerContainer.query('>gridcolumn[hideable]'),
itemsLn = items.length,
menuItem;
for (; i < itemsLn; i++) {
item = items[i];
menuItem = Ext.create('Ext.menu.CheckItem', {
text: item.text,
checked: !item.hidden,
hideOnClick: false,
headerId: item.id,
menu: item.isGroupHeader ? this.getColumnMenu(item) : undefined,
checkHandler: this.onColumnCheckChange,
scope: this
});
if (itemsLn === 1) {
menuItem.disabled = true;
}
menuItems.push(menuItem);
item.on({
destroy: Ext.Function.bind(menuItem.destroy, menuItem)
});
}
return menuItems;
},
onColumnCheckChange: function(checkItem, checked) {
var header = Ext.getCmp(checkItem.headerId);
header[checked ? 'show' : 'hide']();
},
getColumnsForTpl: function(flushCache) {
var cols = [],
headers = this.getGridColumns(flushCache),
headersLn = headers.length,
i = 0,
header,
width;
for (; i < headersLn; i++) {
header = headers[i];
if (header.hidden) {
width = 0;
} else {
width = header.getDesiredWidth();
if ((i == 0) && (Ext.isIE6 || Ext.isIE7)) {
width += 1;
}
}
cols.push({
dataIndex: header.dataIndex,
align: header.align,
width: width,
id: header.id,
cls: header.tdCls,
columnId: header.getItemId()
});
}
return cols;
},
getColumnCount: function() {
return this.getGridColumns().length;
},
getFullWidth: function(flushCache) {
var fullWidth = 0,
headers = this.getVisibleGridColumns(flushCache),
headersLn = headers.length,
i = 0;
for (; i < headersLn; i++) {
if (!isNaN(headers[i].width)) {
if (headers[i].getDesiredWidth) {
fullWidth += headers[i].getDesiredWidth();
} else {
fullWidth += headers[i].getWidth();
}
}
}
return fullWidth;
},
clearOtherSortStates: function(activeHeader) {
var headers = this.getGridColumns(),
headersLn = headers.length,
i = 0,
oldSortState;
for (; i < headersLn; i++) {
if (headers[i] !== activeHeader) {
oldSortState = headers[i].sortState;
headers[i].setSortState(null, true);
}
}
},
getVisibleGridColumns: function(refreshCache) {
return Ext.ComponentQuery.query(':not([hidden])', this.getGridColumns(refreshCache));
},
getGridColumns: function(refreshCache) {
var me = this,
result = refreshCache ? null : me.gridDataColumns;
if (!result) {
me.gridDataColumns = result = [];
me.cascade(function(c) {
if ((c !== me) && !c.isGroupHeader) {
result.push(c);
}
});
}
return result;
},
getHeaderIndex: function(header) {
var columns = this.getGridColumns();
return Ext.Array.indexOf(columns, header);
},
getHeaderAtIndex: function(index) {
var columns = this.getGridColumns();
return columns[index];
},
prepareData: function(data, rowIdx, record, view, panel) {
var obj = {},
headers = this.gridDataColumns || this.getGridColumns(),
headersLn = headers.length,
colIdx = 0,
header,
headerId,
renderer,
value,
metaData,
store = panel.store;
for (; colIdx < headersLn; colIdx++) {
metaData = {
tdCls: '',
style: ''
};
header = headers[colIdx];
headerId = header.id;
renderer = header.renderer;
value = data[header.dataIndex];
if (typeof renderer === "string") {
header.renderer = renderer = Ext.util.Format[renderer];
}
if (typeof renderer === "function") {
value = renderer.call(
header.scope || this.ownerCt,
value,
metaData,
record,
rowIdx,
colIdx,
store,
view
);
}
obj[headerId+'-modified'] = record.isModified(header.dataIndex) ? Ext.baseCSSPrefix + 'grid-dirty-cell' : '';
obj[headerId+'-tdCls'] = metaData.tdCls;
obj[headerId+'-tdAttr'] = metaData.tdAttr;
obj[headerId+'-style'] = metaData.style;
if (value === undefined || value === null || value === '') {
value = ' ';
}
obj[headerId] = value;
}
return obj;
},
expandToFit: function(header) {
if (this.view) {
this.view.expandToFit(header);
}
}
});
Ext.define('Ext.grid.column.Column', {
extend: 'Ext.grid.header.Container',
alias: 'widget.gridcolumn',
requires: ['Ext.util.KeyNav'],
alternateClassName: 'Ext.grid.Column',
baseCls: Ext.baseCSSPrefix + 'column-header ' + Ext.baseCSSPrefix + 'unselectable',
hoverCls: Ext.baseCSSPrefix + 'column-header-over',
handleWidth: 5,
sortState: null,
possibleSortStates: ['ASC', 'DESC'],
renderTpl:
'' +
'
' +
'{text}' +
' ' +
'
' +
'
',
indicatorCls: 'x-grid-drop-indicator',
constructor: function(config) {
var me = this;
Ext.apply(me, config);
if (!me.ddGroup) {
me.ddGroup = 'view-dd-zone-' + me.view.id;
}
me.callParent([me.view.el]);
},
fireViewEvent: function() {
var me = this,
result;
me.lock();
result = me.view.fireEvent.apply(me.view, arguments);
me.unlock();
return result;
},
getTargetFromEvent : function(e) {
var node = e.getTarget(this.view.getItemSelector()),
mouseY, nodeList, testNode, i, len, box;
if (!node) {
mouseY = e.getPageY();
for (i = 0, nodeList = this.view.getNodes(), len = nodeList.length; i < len; i++) {
testNode = nodeList[i];
box = Ext.fly(testNode).getBox();
if (mouseY <= box.bottom) {
return testNode;
}
}
}
return node;
},
getIndicator: function() {
var me = this;
if (!me.indicator) {
me.indicator = Ext.createWidget('component', {
html: me.indicatorHtml,
cls: me.indicatorCls,
ownerCt: me.view,
floating: true,
shadow: false
});
}
return me.indicator;
},
getPosition: function(e, node) {
var y = e.getXY()[1],
region = Ext.fly(node).getRegion(),
pos;
if ((region.bottom - y) >= (region.bottom - region.top) / 2) {
pos = "before";
} else {
pos = "after";
}
return pos;
},
containsRecordAtOffset: function(records, record, offset) {
if (!record) {
return false;
}
var view = this.view,
recordIndex = view.indexOf(record),
nodeBefore = view.getNode(recordIndex + offset),
recordBefore = nodeBefore ? view.getRecord(nodeBefore) : null;
return recordBefore && Ext.Array.contains(records, recordBefore);
},
positionIndicator: function(node, data, e) {
var me = this,
view = me.view,
pos = me.getPosition(e, node),
overRecord = view.getRecord(node),
draggingRecords = data.records,
indicator, indicatorY;
if (!Ext.Array.contains(draggingRecords, overRecord) && (
pos == 'before' && !me.containsRecordAtOffset(draggingRecords, overRecord, -1) ||
pos == 'after' && !me.containsRecordAtOffset(draggingRecords, overRecord, 1)
)) {
me.valid = true;
if (me.overRecord != overRecord || me.currentPosition != pos) {
indicatorY = Ext.fly(node).getY() - view.el.getY() - 1;
if (pos == 'after') {
indicatorY += Ext.fly(node).getHeight();
}
me.getIndicator().setWidth(Ext.fly(view.el).getWidth()).showAt(0, indicatorY);
me.overRecord = overRecord;
me.currentPosition = pos;
}
} else {
me.invalidateDrop();
}
},
invalidateDrop: function() {
if (this.valid) {
this.valid = false;
this.getIndicator().hide();
}
},
onNodeOver: function(node, dragZone, e, data) {
var me = this;
if (!Ext.Array.contains(data.records, me.view.getRecord(node))) {
me.positionIndicator(node, data, e);
}
return me.valid ? me.dropAllowed : me.dropNotAllowed;
},
notifyOut: function(node, dragZone, e, data) {
var me = this;
me.callParent(arguments);
delete me.overRecord;
delete me.currentPosition;
if (me.indicator) {
me.indicator.hide();
}
},
onContainerOver : function(dd, e, data) {
var me = this,
view = me.view,
count = view.store.getCount();
if (count) {
me.positionIndicator(view.getNode(count - 1), data, e);
}
else {
delete me.overRecord;
delete me.currentPosition;
me.getIndicator().setWidth(Ext.fly(view.el).getWidth()).showAt(0, 0);
me.valid = true;
}
return me.dropAllowed;
},
onContainerDrop : function(dd, e, data) {
return this.onNodeDrop(dd, null, e, data);
},
onNodeDrop: function(node, dragZone, e, data) {
var me = this,
dropped = false,
processDrop = function () {
me.invalidateDrop();
me.handleNodeDrop(data, me.overRecord, me.currentPosition);
dropped = true;
me.fireViewEvent('drop', node, data, me.overRecord, me.currentPosition);
},
performOperation = false;
if (me.valid) {
performOperation = me.fireViewEvent('beforedrop', node, data, me.overRecord, me.currentPosition, processDrop);
if (performOperation !== false) {
if (!dropped) {
processDrop();
}
}
}
return performOperation;
}
});
Ext.define('Ext.grid.ViewDropZone', {
extend: 'Ext.view.DropZone',
indicatorHtml: '
',
indicatorCls: 'x-grid-drop-indicator',
handleNodeDrop : function(data, record, position) {
var view = this.view,
store = view.getStore(),
index, records, i, len;
if (data.copy) {
records = data.records;
data.records = [];
for (i = 0, len = records.length; i < len; i++) {
data.records.push(records[i].copy(records[i].getId()));
}
} else {
data.view.store.remove(data.records, data.view === view);
}
index = store.indexOf(record);
if (position !== 'before') {
index++;
}
store.insert(index, data.records);
view.getSelectionModel().select(data.records);
}
});
Ext.define('Ext.grid.column.Action', {
extend: 'Ext.grid.column.Column',
alias: ['widget.actioncolumn'],
alternateClassName: 'Ext.grid.ActionColumn',
header: ' ',
actionIdRe: /x-action-col-(\d+)/,
altText: '',
sortable: false,
constructor: function(config) {
var me = this,
cfg = Ext.apply({}, config),
items = cfg.items || [me],
l = items.length,
i,
item;
delete cfg.items;
me.callParent([cfg]);
me.items = items;
me.renderer = function(v, meta) {
v = Ext.isFunction(cfg.renderer) ? cfg.renderer.apply(this, arguments)||'' : '';
meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
for (i = 0; i < l; i++) {
item = items[i];
v += '';
},
closeTableWrap: function() {
return '
',
'{collapsed}' + me.groupHeaderTpl + '
{[this.recurse(values)]} '
].join('');
},
getFragmentTpl: function() {
return {
indentByDepth: this.indentByDepth,
depthToIndent: this.depthToIndent
};
},
indentByDepth: function(values) {
var depth = values.depth || 0;
return 'style="padding-left:'+ depth * this.depthToIndent + 'px;"';
},
destroy: function() {
var me = this;
delete me.view;
delete me.prunedHeader;
},
attachEvents: function() {
var me = this,
view = me.view,
header, headerId, menu, menuItem;
view.on({
scope: me,
groupclick: me.onGroupClick,
rowfocus: me.onRowFocus
});
view.store.on('groupchange', me.onGroupChange, me);
me.pruneGroupedHeader();
if (me.enableGroupingMenu) {
me.injectGroupingMenu();
}
if (me.hideGroupedHeader) {
header = view.headerCt.down('gridcolumn[dataIndex=' + me.getGroupField() + ']');
headerId = header.id;
menu = view.headerCt.getMenu();
menuItem = menu.down('menuitem[headerId='+ headerId +']');
if (menuItem) {
menuItem.setChecked(false);
}
}
},
injectGroupingMenu: function() {
var me = this,
view = me.view,
headerCt = view.headerCt;
headerCt.showMenuBy = me.showMenuBy;
headerCt.getMenuItems = me.getMenuItems();
},
showMenuBy: function(t, header) {
var menu = this.getMenu(),
groupMenuItem = menu.down('#groupMenuItem'),
groupableMth = header.groupable === false ? 'disable' : 'enable';
groupMenuItem[groupableMth]();
Ext.grid.header.Container.prototype.showMenuBy.apply(this, arguments);
},
getMenuItems: function() {
var me = this,
groupByText = me.groupByText,
disabled = me.disabled,
showGroupsText = me.showGroupsText,
enableNoGroups = me.enableNoGroups,
groupMenuItemClick = Ext.Function.bind(me.onGroupMenuItemClick, me),
groupToggleMenuItemClick = Ext.Function.bind(me.onGroupToggleMenuItemClick, me);
return function() {
var o = Ext.grid.header.Container.prototype.getMenuItems.call(this);
o.push('-', {
itemId: 'groupMenuItem',
text: groupByText,
handler: groupMenuItemClick
});
if (enableNoGroups) {
o.push({
itemId: 'groupToggleMenuItem',
text: showGroupsText,
checked: !disabled,
checkHandler: groupToggleMenuItemClick
});
}
return o;
};
},
onGroupMenuItemClick: function(menuItem, e) {
var menu = menuItem.parentMenu,
hdr = menu.activeHeader,
view = this.view;
delete this.lastGroupIndex;
this.enable();
view.store.group(hdr.dataIndex);
this.pruneGroupedHeader();
},
onGroupToggleMenuItemClick: function(menuItem, checked) {
this[checked ? 'enable' : 'disable']();
},
pruneGroupedHeader: function() {
var me = this,
view = me.view,
store = view.store,
groupField = me.getGroupField(),
headerCt = view.headerCt,
header = headerCt.down('header[dataIndex=' + groupField + ']');
if (header) {
if (me.prunedHeader) {
me.prunedHeader.show();
}
me.prunedHeader = header;
header.hide();
}
},
getGroupField: function(){
var group = this.view.store.groupers.first();
if (group) {
return group.property;
}
return '';
},
onRowFocus: function(rowIdx) {
var node = this.view.getNode(rowIdx),
groupBd = Ext.fly(node).up('.' + this.collapsedCls);
if (groupBd) {
this.expand(groupBd);
}
},
expand: function(groupBd) {
var me = this,
view = me.view,
grid = view.up('gridpanel'),
groupBdDom = Ext.getDom(groupBd);
me.collapsedState[groupBdDom.id] = false;
groupBd.removeCls(me.collapsedCls);
groupBd.prev().removeCls(me.hdCollapsedCls);
grid.determineScrollbars();
grid.invalidateScroller();
view.fireEvent('groupexpand');
},
collapse: function(groupBd) {
var me = this,
view = me.view,
grid = view.up('gridpanel'),
groupBdDom = Ext.getDom(groupBd);
me.collapsedState[groupBdDom.id] = true;
groupBd.addCls(me.collapsedCls);
groupBd.prev().addCls(me.hdCollapsedCls);
grid.determineScrollbars();
grid.invalidateScroller();
view.fireEvent('groupcollapse');
},
onGroupChange: function(){
this.view.refresh();
},
onGroupClick: function(view, group, idx, foo, e) {
var me = this,
toggleCls = me.toggleCls,
groupBd = Ext.fly(group.nextSibling, '_grouping');
if (groupBd.hasCls(me.collapsedCls)) {
me.expand(groupBd);
} else {
me.collapse(groupBd);
}
},
getMetaRowTplFragments: function() {
return {
isRow: this.isRow,
closeRow: this.closeRow
};
},
isRow: function() {
return '';
},
closeRow: function() {
return ' ';
},
mutateMetaRowTpl: function(metaRowTpl) {
metaRowTpl.unshift('{[this.isRow()]}');
metaRowTpl.push('{[this.closeRow()]}');
},
getAdditionalData: function(data, idx, record, orig) {
var view = this.view,
hCt = view.headerCt,
col = hCt.items.getAt(0),
o = {},
tdAttrKey = col.id + '-tdAttr';
o[tdAttrKey] = this.indentByDepth(data) + " " + (orig[tdAttrKey] ? orig[tdAttrKey] : '');
o.collapsed = 'true';
return o;
},
getGroupRows: function(group, records, preppedRecords, fullWidth) {
var me = this,
children = group.children,
rows = group.rows = [],
view = me.view;
group.viewId = view.id;
Ext.Array.each(records, function(record, idx) {
if (Ext.Array.indexOf(children, record) != -1) {
rows.push(Ext.apply(preppedRecords[idx], {
depth: 1
}));
}
});
delete group.children;
group.fullWidth = fullWidth;
if (me.collapsedState[view.id + '-gp-' + group.name]) {
group.collapsedCls = me.collapsedCls;
group.hdCollapsedCls = me.hdCollapsedCls;
}
return group;
},
collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
var me = this,
store = me.view.store,
groups;
if (!me.disabled && store.isGrouped()) {
groups = store.getGroups();
Ext.Array.each(groups, function(group, idx){
me.getGroupRows(group, records, preppedRecords, fullWidth);
}, me);
return {
rows: groups,
fullWidth: fullWidth
};
}
return o;
},
getFireEventArgs: function(type, view, featureTarget, e) {
var returnArray = [type, view, featureTarget],
groupBd = Ext.fly(featureTarget.nextSibling, '_grouping'),
groupBdId = Ext.getDom(groupBd).id,
prefix = view.id + '-gp-',
groupName = groupBdId.substr(prefix.length);
returnArray.push(groupName, e);
return returnArray;
}
});
Ext.define('Ext.grid.feature.GroupingSummary', {
extend: 'Ext.grid.feature.Grouping',
alias: 'feature.groupingsummary',
mixins: {
summary: 'Ext.grid.feature.AbstractSummary'
},
getFeatureTpl: function() {
var tpl = this.callParent(arguments);
if (this.showSummaryRow) {
tpl = tpl.replace('', '');
tpl += '{[this.printSummaryRow(xindex)]}';
}
return tpl;
},
getFragmentTpl: function() {
var me = this,
fragments = me.callParent();
Ext.apply(fragments, me.getSummaryFragments());
if (me.showSummaryRow) {
me.summaryGroups = me.view.store.getGroups();
me.summaryData = me.generateSummaryData();
}
return fragments;
},
getPrintData: function(index){
var me = this,
columns = me.view.headerCt.getColumnsForTpl(),
i = 0,
length = columns.length,
data = [],
name = me.summaryGroups[index - 1].name,
active = me.summaryData[name],
column;
for (; i < length; ++i) {
column = columns[i];
column.gridSummaryValue = this.getColumnValue(column, active);
data.push(column);
}
return data;
},
generateSummaryData: function(){
var me = this,
data = {},
remoteData = {},
store = me.view.store,
groupField = this.getGroupField(),
reader = store.proxy.reader,
groups = me.summaryGroups,
columns = me.view.headerCt.getColumnsForTpl(),
remote,
i,
length,
fieldData,
root,
key,
comp;
for (i = 0, length = groups.length; i < length; ++i) {
data[groups[i].name] = {};
}
if (me.remoteRoot && reader.rawData) {
root = reader.root;
reader.root = me.remoteRoot;
reader.buildExtractors(true);
Ext.Array.each(reader.getRoot(reader.rawData), function(value) {
remoteData[value[groupField]] = value;
});
reader.root = root;
reader.buildExtractors(true);
}
for (i = 0, length = columns.length; i < length; ++i) {
comp = Ext.getCmp(columns[i].id);
fieldData = me.getSummary(store, comp.summaryType, comp.dataIndex, true);
for (key in fieldData) {
if (fieldData.hasOwnProperty(key)) {
data[key][comp.id] = fieldData[key];
}
}
for (key in remoteData) {
if (remoteData.hasOwnProperty(key)) {
remote = remoteData[key][comp.dataIndex];
if (remote !== undefined) {
data[key][comp.id] = remote;
}
}
}
}
return data;
}
});
Ext.define('Ext.grid.feature.RowBody', {
extend: 'Ext.grid.feature.Feature',
alias: 'feature.rowbody',
rowBodyHiddenCls: Ext.baseCSSPrefix + 'grid-row-body-hidden',
rowBodyTrCls: Ext.baseCSSPrefix + 'grid-rowbody-tr',
rowBodyTdCls: Ext.baseCSSPrefix + 'grid-cell-rowbody',
rowBodyDivCls: Ext.baseCSSPrefix + 'grid-rowbody',
eventPrefix: 'rowbody',
eventSelector: '.' + Ext.baseCSSPrefix + 'grid-rowbody-tr',
getRowBody: function(values) {
return [
' ',
'',
'{rowBody}
',
' ',
' '
].join('');
},
getMetaRowTplFragments: function() {
return {
getRowBody: this.getRowBody,
rowBodyTrCls: this.rowBodyTrCls,
rowBodyTdCls: this.rowBodyTdCls,
rowBodyDivCls: this.rowBodyDivCls
};
},
mutateMetaRowTpl: function(metaRowTpl) {
metaRowTpl.push('{[this.getRowBody(values)]}');
},
getAdditionalData: function(data, idx, record, orig) {
var headerCt = this.view.headerCt,
colspan = headerCt.getColumnCount();
return {
rowBody: "",
rowBodyCls: this.rowBodyCls,
rowBodyColspan: colspan
};
}
});
Ext.define('Ext.grid.feature.RowWrap', {
extend: 'Ext.grid.feature.Feature',
alias: 'feature.rowwrap',
hasFeatureEvent: false,
mutateMetaRowTpl: function(metaRowTpl) {
metaRowTpl[0] = metaRowTpl[0].replace(Ext.baseCSSPrefix + 'grid-row', '');
metaRowTpl[0] = metaRowTpl[0].replace("{[this.embedRowCls()]}", "");
metaRowTpl.unshift('');
metaRowTpl.unshift('');
metaRowTpl.push('
');
metaRowTpl.push('');
},
embedColSpan: function() {
return '{colspan}';
},
embedFullWidth: function() {
return '{fullWidth}';
},
getAdditionalData: function(data, idx, record, orig) {
var headerCt = this.view.headerCt,
colspan = headerCt.getColumnCount(),
fullWidth = headerCt.getFullWidth(),
items = headerCt.query('gridcolumn'),
itemsLn = items.length,
i = 0,
o = {
colspan: colspan,
fullWidth: fullWidth
},
id,
tdClsKey,
colResizerCls;
for (; i < itemsLn; i++) {
id = items[i].id;
tdClsKey = id + '-tdCls';
colResizerCls = Ext.baseCSSPrefix + 'grid-col-resizer-'+id;
o[tdClsKey] = colResizerCls + " " + (orig[tdClsKey] ? orig[tdClsKey] : '');
o[id+'-tdAttr'] = " style=\"width: " + (items[i].hidden ? 0 : items[i].getDesiredWidth()) + "px;\" ";
if (orig[id+'-tdAttr']) {
o[id+'-tdAttr'] += orig[id+'-tdAttr'];
}
}
return o;
},
getMetaRowTplFragments: function() {
return {
embedFullWidth: this.embedFullWidth,
embedColSpan: this.embedColSpan
};
}
});
Ext.define('Ext.grid.feature.Summary', {
extend: 'Ext.grid.feature.AbstractSummary',
alias: 'feature.summary',
getFragmentTpl: function() {
this.summaryData = this.generateSummaryData();
return this.getSummaryFragments();
},
getTableFragments: function(){
if (this.showSummaryRow) {
return {
closeRows: this.closeRows
};
}
},
closeRows: function() {
return '{[this.printSummaryRow()]}';
},
getPrintData: function(index){
var me = this,
columns = me.view.headerCt.getColumnsForTpl(),
i = 0,
length = columns.length,
data = [],
active = me.summaryData,
column;
for (; i < length; ++i) {
column = columns[i];
column.gridSummaryValue = this.getColumnValue(column, active);
data.push(column);
}
return data;
},
generateSummaryData: function(){
var me = this,
data = {},
store = me.view.store,
columns = me.view.headerCt.getColumnsForTpl(),
i = 0,
length = columns.length,
fieldData,
key,
comp;
for (i = 0, length = columns.length; i < length; ++i) {
comp = Ext.getCmp(columns[i].id);
data[comp.id] = me.getSummary(store, comp.summaryType, comp.dataIndex, false);
}
return data;
}
});
Ext.define('Ext.grid.header.DragZone', {
extend: 'Ext.dd.DragZone',
colHeaderCls: Ext.baseCSSPrefix + 'column-header',
maxProxyWidth: 120,
constructor: function(headerCt) {
this.headerCt = headerCt;
this.ddGroup = this.getDDGroup();
this.callParent([headerCt.el]);
this.proxy.el.addCls(Ext.baseCSSPrefix + 'grid-col-dd');
},
getDDGroup: function() {
return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
},
getDragData: function(e) {
var header = e.getTarget('.'+this.colHeaderCls),
headerCmp;
if (header) {
headerCmp = Ext.getCmp(header.id);
if (!this.headerCt.dragging && headerCmp.draggable && !(headerCmp.isOnLeftEdge(e) || headerCmp.isOnRightEdge(e))) {
var ddel = document.createElement('div');
ddel.innerHTML = Ext.getCmp(header.id).text;
return {
ddel: ddel,
header: headerCmp
};
}
}
return false;
},
onBeforeDrag: function() {
return !(this.headerCt.dragging || this.disabled);
},
onInitDrag: function() {
this.headerCt.dragging = true;
this.callParent(arguments);
},
onDragDrop: function() {
this.headerCt.dragging = false;
this.callParent(arguments);
},
afterRepair: function() {
this.callParent();
this.headerCt.dragging = false;
},
getRepairXY: function() {
return this.dragData.header.el.getXY();
},
disable: function() {
this.disabled = true;
},
enable: function() {
this.disabled = false;
}
});
Ext.define('Ext.grid.header.DropZone', {
extend: 'Ext.dd.DropZone',
colHeaderCls: Ext.baseCSSPrefix + 'column-header',
proxyOffsets: [-4, -9],
constructor: function(headerCt){
this.headerCt = headerCt;
this.ddGroup = this.getDDGroup();
this.callParent([headerCt.el]);
},
getDDGroup: function() {
return 'header-dd-zone-' + this.headerCt.up('[scrollerOwner]').id;
},
getTargetFromEvent : function(e){
return e.getTarget('.' + this.colHeaderCls);
},
getTopIndicator: function() {
if (!this.topIndicator) {
this.topIndicator = Ext.core.DomHelper.append(Ext.getBody(), {
cls: "col-move-top",
html: " "
}, true);
}
return this.topIndicator;
},
getBottomIndicator: function() {
if (!this.bottomIndicator) {
this.bottomIndicator = Ext.core.DomHelper.append(Ext.getBody(), {
cls: "col-move-bottom",
html: " "
}, true);
}
return this.bottomIndicator;
},
getLocation: function(e, t) {
var x = e.getXY()[0],
region = Ext.fly(t).getRegion(),
pos, header;
if ((region.right - x) <= (region.right - region.left) / 2) {
pos = "after";
} else {
pos = "before";
}
return {
pos: pos,
header: Ext.getCmp(t.id),
node: t
};
},
positionIndicator: function(draggedHeader, node, e){
var location = this.getLocation(e, node),
header = location.header,
pos = location.pos,
nextHd = draggedHeader.nextSibling('gridcolumn:not([hidden])'),
prevHd = draggedHeader.previousSibling('gridcolumn:not([hidden])'),
region, topIndicator, bottomIndicator, topAnchor, bottomAnchor,
topXY, bottomXY, headerCtEl, minX, maxX;
if (!header.draggable && header.getIndex() == 0) {
return false;
}
this.lastLocation = location;
if ((draggedHeader !== header) &&
((pos === "before" && nextHd !== header) ||
(pos === "after" && prevHd !== header)) &&
!header.isDescendantOf(draggedHeader)) {
var allDropZones = Ext.dd.DragDropManager.getRelated(this),
ln = allDropZones.length,
i = 0,
dropZone;
for (; i < ln; i++) {
dropZone = allDropZones[i];
if (dropZone !== this && dropZone.invalidateDrop) {
dropZone.invalidateDrop();
}
}
this.valid = true;
topIndicator = this.getTopIndicator();
bottomIndicator = this.getBottomIndicator();
if (pos === 'before') {
topAnchor = 'tl';
bottomAnchor = 'bl';
} else {
topAnchor = 'tr';
bottomAnchor = 'br';
}
topXY = header.el.getAnchorXY(topAnchor);
bottomXY = header.el.getAnchorXY(bottomAnchor);
headerCtEl = this.headerCt.el;
minX = headerCtEl.getLeft();
maxX = headerCtEl.getRight();
topXY[0] = Ext.Number.constrain(topXY[0], minX, maxX);
bottomXY[0] = Ext.Number.constrain(bottomXY[0], minX, maxX);
topXY[0] -= 4;
topXY[1] -= 9;
bottomXY[0] -= 4;
topIndicator.setXY(topXY);
bottomIndicator.setXY(bottomXY);
topIndicator.show();
bottomIndicator.show();
} else {
this.invalidateDrop();
}
},
invalidateDrop: function() {
this.valid = false;
this.hideIndicators();
},
onNodeOver: function(node, dragZone, e, data) {
if (data.header.el.dom !== node) {
this.positionIndicator(data.header, node, e);
}
return this.valid ? this.dropAllowed : this.dropNotAllowed;
},
hideIndicators: function() {
this.getTopIndicator().hide();
this.getBottomIndicator().hide();
},
onNodeOut: function() {
this.hideIndicators();
},
onNodeDrop: function(node, dragZone, e, data) {
if (this.valid) {
this.invalidateDrop();
var hd = data.header,
lastLocation = this.lastLocation,
fromCt = hd.ownerCt,
fromIdx = fromCt.items.indexOf(hd),
toCt = lastLocation.header.ownerCt,
toIdx = toCt.items.indexOf(lastLocation.header),
headerCt = this.headerCt,
groupCt,
scrollerOwner;
if (lastLocation.pos === 'after') {
toIdx++;
}
if (fromCt !== toCt && fromCt.lockableInjected && toCt.lockableInjected && toCt.lockedCt) {
scrollerOwner = fromCt.up('[scrollerOwner]');
scrollerOwner.lock(hd, toIdx);
} else if (fromCt !== toCt && fromCt.lockableInjected && toCt.lockableInjected && fromCt.lockedCt) {
scrollerOwner = fromCt.up('[scrollerOwner]');
scrollerOwner.unlock(hd, toIdx);
} else {
if ((fromCt === toCt) && (toIdx > fromCt.items.indexOf(hd))) {
toIdx--;
}
if (fromCt !== toCt) {
fromCt.suspendLayout = true;
fromCt.remove(hd, false);
fromCt.suspendLayout = false;
}
if (fromCt.isGroupHeader) {
if (!fromCt.items.getCount()) {
groupCt = fromCt.ownerCt;
groupCt.suspendLayout = true;
groupCt.remove(fromCt, false);
fromCt.el.dom.parentNode.removeChild(fromCt.el.dom);
groupCt.suspendLayout = false;
} else {
fromCt.minWidth = fromCt.getWidth() - hd.getWidth();
fromCt.setWidth(fromCt.minWidth);
}
}
toCt.suspendLayout = true;
if (fromCt === toCt) {
toCt.move(fromIdx, toIdx);
} else {
toCt.insert(toIdx, hd);
}
toCt.suspendLayout = false;
if (toCt.isGroupHeader) {
hd.savedFlex = hd.flex;
delete hd.flex;
hd.width = hd.getWidth();
toCt.minWidth = toCt.getWidth() + hd.getWidth() - (hd.savedFlex ? 1 : 0);
toCt.setWidth(toCt.minWidth);
} else {
if (hd.savedFlex) {
hd.flex = hd.savedFlex;
delete hd.width;
}
}
headerCt.purgeCache();
headerCt.doLayout();
headerCt.onHeaderMoved(hd, fromIdx, toIdx);
if (!fromCt.items.getCount()) {
fromCt.destroy();
}
}
}
}
});
Ext.define('Ext.grid.plugin.Editing', {
alias: 'editing.editing',
requires: [
'Ext.grid.column.Column',
'Ext.util.KeyNav'
],
mixins: {
observable: 'Ext.util.Observable'
},
clicksToEdit: 2,
defaultFieldXType: 'textfield',
editStyle: '',
constructor: function(config) {
var me = this;
Ext.apply(me, config);
me.addEvents(
'beforeedit',
'edit',
'validateedit'
);
me.mixins.observable.constructor.call(me);
me.relayEvents(me, ['afteredit'], 'after');
},
init: function(grid) {
var me = this;
me.grid = grid;
me.view = grid.view;
me.initEvents();
me.mon(grid, 'reconfigure', me.onReconfigure, me);
me.onReconfigure();
grid.relayEvents(me, ['beforeedit', 'edit', 'validateedit']);
grid.isEditable = true;
grid.editingPlugin = grid.view.editingPlugin = me;
},
onReconfigure: function(){
this.initFieldAccessors(this.view.getGridColumns());
},
destroy: function() {
var me = this,
grid = me.grid,
headerCt = grid.headerCt,
events = grid.events;
Ext.destroy(me.keyNav);
me.removeFieldAccessors(grid.getView().getGridColumns());
me.clearListeners();
delete me.grid.editingPlugin;
delete me.grid.view.editingPlugin;
delete me.grid;
delete me.view;
delete me.editor;
delete me.keyNav;
},
getEditStyle: function() {
return this.editStyle;
},
initFieldAccessors: function(column) {
var me = this;
if (Ext.isArray(column)) {
Ext.Array.forEach(column, me.initFieldAccessors, me);
return;
}
Ext.applyIf(column, {
getEditor: function(record, defaultField) {
return me.getColumnField(this, defaultField);
},
setEditor: function(field) {
me.setColumnField(this, field);
}
});
},
removeFieldAccessors: function(column) {
var me = this;
if (Ext.isArray(column)) {
Ext.Array.forEach(column, me.removeFieldAccessors, me);
return;
}
delete column.getEditor;
delete column.setEditor;
},
getColumnField: function(columnHeader, defaultField) {
var field = columnHeader.field;
if (!field && columnHeader.editor) {
field = columnHeader.editor;
delete columnHeader.editor;
}
if (!field && defaultField) {
field = defaultField;
}
if (field) {
if (Ext.isString(field)) {
field = { xtype: field };
}
if (Ext.isObject(field) && !field.isFormField) {
field = Ext.ComponentManager.create(field, this.defaultFieldXType);
columnHeader.field = field;
}
Ext.apply(field, {
name: columnHeader.dataIndex
});
return field;
}
},
setColumnField: function(column, field) {
if (Ext.isObject(field) && !field.isFormField) {
field = Ext.ComponentManager.create(field, this.defaultFieldXType);
}
column.field = field;
},
initEvents: function() {
var me = this;
me.initEditTriggers();
me.initCancelTriggers();
},
initCancelTriggers: Ext.emptyFn,
initEditTriggers: function() {
var me = this,
view = me.view,
clickEvent = me.clicksToEdit === 1 ? 'click' : 'dblclick';
me.mon(view, 'cell' + clickEvent, me.startEditByClick, me);
view.on('render', function() {
me.keyNav = Ext.create('Ext.util.KeyNav', view.el, {
enter: me.onEnterKey,
esc: me.onEscKey,
scope: me
});
}, me, { single: true });
},
onEnterKey: function(e) {
var me = this,
grid = me.grid,
selModel = grid.getSelectionModel(),
record,
columnHeader = grid.headerCt.getHeaderAtIndex(0);
if (selModel.getCurrentPosition) {
pos = selModel.getCurrentPosition();
record = grid.store.getAt(pos.row);
columnHeader = grid.headerCt.getHeaderAtIndex(pos.column);
}
else {
record = selModel.getLastSelected();
}
me.startEdit(record, columnHeader);
},
onEscKey: function(e) {
this.cancelEdit();
},
startEditByClick: function(view, cell, colIdx, record, row, rowIdx, e) {
this.startEdit(record, view.getHeaderAtIndex(colIdx));
},
beforeEdit: Ext.emptyFn,
startEdit: function(record, columnHeader) {
var me = this,
context = me.getEditingContext(record, columnHeader);
if (me.beforeEdit(context) === false || me.fireEvent('beforeedit', context) === false || context.cancel) {
return false;
}
me.context = context;
me.editing = true;
},
getEditingContext: function(record, columnHeader) {
var me = this,
grid = me.grid,
store = grid.store,
rowIdx,
colIdx,
view = grid.getView(),
value;
if (Ext.isNumber(record)) {
rowIdx = record;
record = store.getAt(rowIdx);
} else {
rowIdx = store.indexOf(record);
}
if (Ext.isNumber(columnHeader)) {
colIdx = columnHeader;
columnHeader = grid.headerCt.getHeaderAtIndex(colIdx);
} else {
colIdx = columnHeader.getIndex();
}
value = record.get(columnHeader.dataIndex);
return {
grid: grid,
record: record,
field: columnHeader.dataIndex,
value: value,
row: view.getNode(rowIdx),
column: columnHeader,
rowIdx: rowIdx,
colIdx: colIdx
};
},
cancelEdit: function() {
this.editing = false;
},
completeEdit: function() {
var me = this;
if (me.editing && me.validateEdit()) {
me.fireEvent('edit', me.context);
}
delete me.context;
me.editing = false;
},
validateEdit: function() {
var me = this,
context = me.context;
return me.fireEvent('validateedit', me, context) !== false && !context.cancel;
}
});
Ext.define('Ext.grid.plugin.CellEditing', {
alias: 'plugin.cellediting',
extend: 'Ext.grid.plugin.Editing',
requires: ['Ext.grid.CellEditor', 'Ext.util.DelayedTask'],
constructor: function() {
this.callParent(arguments);
this.editors = Ext.create('Ext.util.MixedCollection', false, function(editor) {
return editor.editorId;
});
this.editTask = Ext.create('Ext.util.DelayedTask');
},
onReconfigure: function(){
this.editors.clear();
this.callParent();
},
destroy: function() {
var me = this;
me.editTask.cancel();
me.editors.each(Ext.destroy, Ext);
me.editors.clear();
me.callParent(arguments);
},
onBodyScroll: function() {
var ed = this.getActiveEditor();
if (ed && ed.field) {
if (ed.field.triggerBlur) {
ed.field.triggerBlur();
} else {
ed.field.blur();
}
}
},
initCancelTriggers: function() {
var me = this,
grid = me.grid,
view = grid.view;
view.addElListener('mousewheel', me.cancelEdit, me);
me.mon(view, 'bodyscroll', me.onBodyScroll, me);
me.mon(grid, {
columnresize: me.cancelEdit,
columnmove: me.cancelEdit,
scope: me
});
},
startEdit: function(record, columnHeader) {
var me = this,
ed = me.getEditor(record, columnHeader),
value = record.get(columnHeader.dataIndex),
context = me.getEditingContext(record, columnHeader);
record = context.record;
columnHeader = context.column;
me.completeEdit();
if (columnHeader && !columnHeader.getEditor(record)) {
return false;
}
if (ed) {
context.originalValue = context.value = value;
if (me.beforeEdit(context) === false || me.fireEvent('beforeedit', context) === false || context.cancel) {
return false;
}
me.context = context;
me.setActiveEditor(ed);
me.setActiveRecord(record);
me.setActiveColumn(columnHeader);
me.editTask.delay(15, ed.startEdit, ed, [me.getCell(record, columnHeader), value]);
} else {
me.grid.getView().getEl(columnHeader).focus((Ext.isWebKit || Ext.isIE) ? 10 : false);
}
},
completeEdit: function() {
var activeEd = this.getActiveEditor();
if (activeEd) {
activeEd.completeEdit();
}
},
setActiveEditor: function(ed) {
this.activeEditor = ed;
},
getActiveEditor: function() {
return this.activeEditor;
},
setActiveColumn: function(column) {
this.activeColumn = column;
},
getActiveColumn: function() {
return this.activeColumn;
},
setActiveRecord: function(record) {
this.activeRecord = record;
},
getActiveRecord: function() {
return this.activeRecord;
},
getEditor: function(record, column) {
var me = this,
editors = me.editors,
editorId = column.getItemId(),
editor = editors.getByKey(editorId);
if (editor) {
return editor;
} else {
editor = column.getEditor(record);
if (!editor) {
return false;
}
if (!(editor instanceof Ext.grid.CellEditor)) {
editor = Ext.create('Ext.grid.CellEditor', {
editorId: editorId,
field: editor
});
}
editor.parentEl = me.grid.getEditorParent();
editor.on({
scope: me,
specialkey: me.onSpecialKey,
complete: me.onEditComplete,
canceledit: me.cancelEdit
});
editors.add(editor);
return editor;
}
},
getCell: function(record, column) {
return this.grid.getView().getCell(record, column);
},
onSpecialKey: function(ed, field, e) {
var grid = this.grid,
sm;
if (e.getKey() === e.TAB) {
e.stopEvent();
sm = grid.getSelectionModel();
if (sm.onEditorTab) {
sm.onEditorTab(this, e);
}
}
},
onEditComplete : function(ed, value, startValue) {
var me = this,
grid = me.grid,
sm = grid.getSelectionModel(),
activeColumn = me.getActiveColumn(),
dataIndex;
if (activeColumn) {
dataIndex = activeColumn.dataIndex;
me.setActiveEditor(null);
me.setActiveColumn(null);
me.setActiveRecord(null);
delete sm.wasEditing;
if (!me.validateEdit()) {
return;
}
if (value !== startValue) {
me.context.record.set(dataIndex, value);
} else {
grid.getView().getEl(activeColumn).focus();
}
me.context.value = value;
me.fireEvent('edit', me, me.context);
}
},
cancelEdit: function() {
var me = this,
activeEd = me.getActiveEditor(),
viewEl = me.grid.getView().getEl(me.getActiveColumn());
me.setActiveEditor(null);
me.setActiveColumn(null);
me.setActiveRecord(null);
if (activeEd) {
activeEd.cancelEdit();
viewEl.focus();
}
},
startEditByPosition: function(position) {
var me = this,
grid = me.grid,
sm = grid.getSelectionModel(),
editRecord = grid.store.getAt(position.row),
editColumnHeader = grid.headerCt.getHeaderAtIndex(position.column);
if (sm.selectByPosition) {
sm.selectByPosition(position);
}
me.startEdit(editRecord, editColumnHeader);
}
});
Ext.define('Ext.grid.plugin.DragDrop', {
extend: 'Ext.AbstractPlugin',
alias: 'plugin.gridviewdragdrop',
uses: [
'Ext.view.DragZone',
'Ext.grid.ViewDropZone'
],
dragText : '{0} selected row{1}',
ddGroup : "GridDD",
enableDrop: true,
enableDrag: true,
init : function(view) {
view.on('render', this.onViewRender, this, {single: true});
},
destroy: function() {
Ext.destroy(this.dragZone, this.dropZone);
},
onViewRender : function(view) {
var me = this;
if (me.enableDrag) {
me.dragZone = Ext.create('Ext.view.DragZone', {
view: view,
ddGroup: me.dragGroup || me.ddGroup,
dragText: me.dragText
});
}
if (me.enableDrop) {
me.dropZone = Ext.create('Ext.grid.ViewDropZone', {
view: view,
ddGroup: me.dropGroup || me.ddGroup
});
}
}
});
Ext.define('Ext.grid.plugin.HeaderReorderer', {
extend: 'Ext.util.Observable',
requires: ['Ext.grid.header.DragZone', 'Ext.grid.header.DropZone'],
alias: 'plugin.gridheaderreorderer',
init: function(headerCt) {
this.headerCt = headerCt;
headerCt.on('render', this.onHeaderCtRender, this);
},
destroy: function() {
Ext.destroy(this.dragZone, this.dropZone);
},
onHeaderCtRender: function() {
this.dragZone = Ext.create('Ext.grid.header.DragZone', this.headerCt);
this.dropZone = Ext.create('Ext.grid.header.DropZone', this.headerCt);
if (this.disabled) {
this.dragZone.disable();
}
},
enable: function() {
this.disabled = false;
if (this.dragZone) {
this.dragZone.enable();
}
},
disable: function() {
this.disabled = true;
if (this.dragZone) {
this.dragZone.disable();
}
}
});
Ext.define('Ext.grid.plugin.HeaderResizer', {
extend: 'Ext.util.Observable',
requires: ['Ext.dd.DragTracker', 'Ext.util.Region'],
alias: 'plugin.gridheaderresizer',
disabled: false,
configs: {
dynamic: true
},
colHeaderCls: Ext.baseCSSPrefix + 'column-header',
minColWidth: 40,
maxColWidth: 1000,
wResizeCursor: 'col-resize',
eResizeCursor: 'col-resize',
init: function(headerCt) {
this.headerCt = headerCt;
headerCt.on('render', this.afterHeaderRender, this, {single: true});
},
destroy: function() {
if (this.tracker) {
this.tracker.destroy();
}
},
afterHeaderRender: function() {
var headerCt = this.headerCt,
el = headerCt.el;
headerCt.mon(el, 'mousemove', this.onHeaderCtMouseMove, this);
this.tracker = Ext.create('Ext.dd.DragTracker', {
disabled: this.disabled,
onBeforeStart: Ext.Function.bind(this.onBeforeStart, this),
onStart: Ext.Function.bind(this.onStart, this),
onDrag: Ext.Function.bind(this.onDrag, this),
onEnd: Ext.Function.bind(this.onEnd, this),
tolerance: 3,
autoStart: 300,
el: el
});
},
onHeaderCtMouseMove: function(e, t) {
if (this.headerCt.dragging) {
if (this.activeHd) {
this.activeHd.el.dom.style.cursor = '';
delete this.activeHd;
}
} else {
var headerEl = e.getTarget('.' + this.colHeaderCls, 3, true),
overHeader, resizeHeader;
if (headerEl){
overHeader = Ext.getCmp(headerEl.id);
if (overHeader.isOnLeftEdge(e)) {
resizeHeader = overHeader.previousNode('gridcolumn:not([hidden]):not([isGroupHeader])');
}
else if (overHeader.isOnRightEdge(e)) {
resizeHeader = overHeader;
}
else {
resizeHeader = null;
}
if (resizeHeader) {
if (resizeHeader.isGroupHeader) {
resizeHeader = resizeHeader.getVisibleGridColumns();
resizeHeader = resizeHeader[resizeHeader.length - 1];
}
if (resizeHeader && !(resizeHeader.fixed || this.disabled)) {
this.activeHd = resizeHeader;
overHeader.el.dom.style.cursor = this.eResizeCursor;
}
} else {
overHeader.el.dom.style.cursor = '';
delete this.activeHd;
}
}
}
},
onBeforeStart : function(e){
var t = e.getTarget();
this.dragHd = this.activeHd;
if (!!this.dragHd && !Ext.fly(t).hasCls('x-column-header-trigger') && !this.headerCt.dragging) {
this.tracker.constrainTo = this.getConstrainRegion();
return true;
} else {
this.headerCt.dragging = false;
return false;
}
},
getConstrainRegion: function() {
var dragHdEl = this.dragHd.el,
region = Ext.util.Region.getRegion(dragHdEl);
return region.adjust(
0,
this.maxColWidth - dragHdEl.getWidth(),
0,
this.minColWidth
);
},
onStart: function(e){
var me = this,
dragHd = me.dragHd,
dragHdEl = dragHd.el,
width = dragHdEl.getWidth(),
headerCt = me.headerCt,
t = e.getTarget();
if (me.dragHd && !Ext.fly(t).hasCls('x-column-header-trigger')) {
headerCt.dragging = true;
}
me.origWidth = width;
if (!me.dynamic) {
var xy = dragHdEl.getXY(),
gridSection = headerCt.up('[scrollerOwner]'),
dragHct = me.dragHd.up(':not([isGroupHeader])'),
firstSection = dragHct.up(),
lhsMarker = gridSection.getLhsMarker(),
rhsMarker = gridSection.getRhsMarker(),
el = rhsMarker.parent(),
offsetLeft = el.getLeft(true),
offsetTop = el.getTop(true),
topLeft = el.translatePoints(xy),
markerHeight = firstSection.body.getHeight() + headerCt.getHeight(),
top = topLeft.top - offsetTop;
lhsMarker.setTop(top);
rhsMarker.setTop(top);
lhsMarker.setHeight(markerHeight);
rhsMarker.setHeight(markerHeight);
lhsMarker.setLeft(topLeft.left - offsetLeft);
rhsMarker.setLeft(topLeft.left + width - offsetLeft);
}
},
onDrag: function(e){
if (!this.dynamic) {
var xy = this.tracker.getXY('point'),
gridSection = this.headerCt.up('[scrollerOwner]'),
rhsMarker = gridSection.getRhsMarker(),
el = rhsMarker.parent(),
topLeft = el.translatePoints(xy),
offsetLeft = el.getLeft(true);
rhsMarker.setLeft(topLeft.left - offsetLeft);
} else {
this.doResize();
}
},
onEnd: function(e){
this.headerCt.dragging = false;
if (this.dragHd) {
if (!this.dynamic) {
var dragHd = this.dragHd,
gridSection = this.headerCt.up('[scrollerOwner]'),
lhsMarker = gridSection.getLhsMarker(),
rhsMarker = gridSection.getRhsMarker(),
currWidth = dragHd.getWidth(),
offset = this.tracker.getOffset('point'),
offscreen = -9999;
lhsMarker.setLeft(offscreen);
rhsMarker.setLeft(offscreen);
}
this.doResize();
}
},
doResize: function() {
if (this.dragHd) {
var dragHd = this.dragHd,
nextHd,
offset = this.tracker.getOffset('point');
if (dragHd.flex) {
delete dragHd.flex;
}
if (this.headerCt.forceFit) {
nextHd = dragHd.nextNode('gridcolumn:not([hidden]):not([isGroupHeader])');
if (nextHd) {
this.headerCt.componentLayout.layoutBusy = true;
}
}
dragHd.minWidth = this.origWidth + offset[0];
dragHd.setWidth(dragHd.minWidth);
if (nextHd) {
delete nextHd.flex;
nextHd.setWidth(nextHd.getWidth() - offset[0]);
this.headerCt.componentLayout.layoutBusy = false;
this.headerCt.doComponentLayout();
}
}
},
disable: function() {
this.disabled = true;
if (this.tracker) {
this.tracker.disable();
}
},
enable: function() {
this.disabled = false;
if (this.tracker) {
this.tracker.enable();
}
}
});
Ext.define('Ext.grid.plugin.RowEditing', {
extend: 'Ext.grid.plugin.Editing',
alias: 'plugin.rowediting',
requires: [
'Ext.grid.RowEditor'
],
editStyle: 'row',
autoCancel: true,
errorSummary: true,
constructor: function() {
var me = this;
me.callParent(arguments);
if (!me.clicksToMoveEditor) {
me.clicksToMoveEditor = me.clicksToEdit;
}
me.autoCancel = !!me.autoCancel;
},
destroy: function() {
var me = this;
Ext.destroy(me.editor);
me.callParent(arguments);
},
startEdit: function(record, columnHeader) {
var me = this,
editor = me.getEditor();
if (me.callParent(arguments) === false) {
return false;
}
if (editor.beforeEdit() !== false) {
editor.startEdit(me.context.record, me.context.column);
}
},
cancelEdit: function() {
var me = this;
if (me.editing) {
me.getEditor().cancelEdit();
me.callParent(arguments);
}
},
completeEdit: function() {
var me = this;
if (me.editing && me.validateEdit()) {
me.editing = false;
me.fireEvent('edit', me.context);
}
},
validateEdit: function() {
var me = this;
return me.callParent(arguments) && me.getEditor().completeEdit();
},
getEditor: function() {
var me = this;
if (!me.editor) {
me.editor = me.initEditor();
}
return me.editor;
},
initEditor: function() {
var me = this,
grid = me.grid,
view = me.view,
headerCt = grid.headerCt;
return Ext.create('Ext.grid.RowEditor', {
autoCancel: me.autoCancel,
errorSummary: me.errorSummary,
fields: headerCt.getGridColumns(),
hidden: true,
editingPlugin: me,
renderTo: view.el
});
},
initEditTriggers: function() {
var me = this,
grid = me.grid,
view = me.view,
headerCt = grid.headerCt,
moveEditorEvent = me.clicksToMoveEditor === 1 ? 'click' : 'dblclick';
me.callParent(arguments);
if (me.clicksToMoveEditor !== me.clicksToEdit) {
me.mon(view, 'cell' + moveEditorEvent, me.moveEditorByClick, me);
}
view.on('render', function() {
me.mon(headerCt, {
add: me.onColumnAdd,
remove: me.onColumnRemove,
columnresize: me.onColumnResize,
columnhide: me.onColumnHide,
columnshow: me.onColumnShow,
columnmove: me.onColumnMove,
scope: me
});
}, me, { single: true });
},
startEditByClick: function() {
var me = this;
if (!me.editing || me.clicksToMoveEditor === me.clicksToEdit) {
me.callParent(arguments);
}
},
moveEditorByClick: function() {
var me = this;
if (me.editing) {
me.superclass.startEditByClick.apply(me, arguments);
}
},
onColumnAdd: function(ct, column) {
if (column.isHeader) {
var me = this,
editor;
me.initFieldAccessors(column);
editor = me.getEditor();
if (editor && editor.onColumnAdd) {
editor.onColumnAdd(column);
}
}
},
onColumnRemove: function(ct, column) {
if (column.isHeader) {
var me = this,
editor = me.getEditor();
if (editor && editor.onColumnRemove) {
editor.onColumnRemove(column);
}
me.removeFieldAccessors(column);
}
},
onColumnResize: function(ct, column, width) {
if (column.isHeader) {
var me = this,
editor = me.getEditor();
if (editor && editor.onColumnResize) {
editor.onColumnResize(column, width);
}
}
},
onColumnHide: function(ct, column) {
var me = this,
editor = me.getEditor();
if (editor && editor.onColumnHide) {
editor.onColumnHide(column);
}
},
onColumnShow: function(ct, column) {
var me = this,
editor = me.getEditor();
if (editor && editor.onColumnShow) {
editor.onColumnShow(column);
}
},
onColumnMove: function(ct, column, fromIdx, toIdx) {
var me = this,
editor = me.getEditor();
if (editor && editor.onColumnMove) {
editor.onColumnMove(column, fromIdx, toIdx);
}
},
setColumnField: function(column, field) {
var me = this;
me.callParent(arguments);
me.getEditor().setField(column.field, column);
}
});
Ext.define('Ext.grid.property.Grid', {
extend: 'Ext.grid.Panel',
alias: 'widget.propertygrid',
alternateClassName: 'Ext.grid.PropertyGrid',
uses: [
'Ext.grid.plugin.CellEditing',
'Ext.grid.property.Store',
'Ext.grid.property.HeaderContainer',
'Ext.XTemplate',
'Ext.grid.CellEditor',
'Ext.form.field.Date',
'Ext.form.field.Text',
'Ext.form.field.Number'
],
valueField: 'value',
nameField: 'name',
enableColumnMove: false,
columnLines: true,
stripeRows: false,
trackMouseOver: false,
clicksToEdit: 1,
enableHdMenu: false,
initComponent : function(){
var me = this;
me.addCls(Ext.baseCSSPrefix + 'property-grid');
me.plugins = me.plugins || [];
me.plugins.push(Ext.create('Ext.grid.plugin.CellEditing', {
clicksToEdit: me.clicksToEdit,
startEdit: function(record, column) {
return this.self.prototype.startEdit.call(this, record, me.headerCt.child('#' + me.valueField));
}
}));
me.selModel = {
selType: 'cellmodel',
onCellSelect: function(position) {
if (position.column != 1) {
position.column = 1;
}
return this.self.prototype.onCellSelect.call(this, position);
}
};
me.customRenderers = me.customRenderers || {};
me.customEditors = me.customEditors || {};
if (!me.store) {
me.propStore = me.store = Ext.create('Ext.grid.property.Store', me, me.source);
}
me.store.sort('name', 'ASC');
me.columns = Ext.create('Ext.grid.property.HeaderContainer', me, me.store);
me.addEvents(
'beforepropertychange',
'propertychange'
);
me.callParent();
me.getView().walkCells = this.walkCells;
me.editors = {
'date' : Ext.create('Ext.grid.CellEditor', { field: Ext.create('Ext.form.field.Date', {selectOnFocus: true})}),
'string' : Ext.create('Ext.grid.CellEditor', { field: Ext.create('Ext.form.field.Text', {selectOnFocus: true})}),
'number' : Ext.create('Ext.grid.CellEditor', { field: Ext.create('Ext.form.field.Number', {selectOnFocus: true})}),
'boolean' : Ext.create('Ext.grid.CellEditor', { field: Ext.create('Ext.form.field.ComboBox', {
editable: false,
store: [[ true, me.headerCt.trueText ], [false, me.headerCt.falseText ]]
})})
};
me.store.on('update', me.onUpdate, me);
},
onUpdate : function(store, record, operation) {
var me = this,
v, oldValue;
if (operation == Ext.data.Model.EDIT) {
v = record.get(me.valueField);
oldValue = record.modified.value;
if (me.fireEvent('beforepropertychange', me.source, record.getId(), v, oldValue) !== false) {
if (me.source) {
me.source[record.getId()] = v;
}
record.commit();
me.fireEvent('propertychange', me.source, record.getId(), v, oldValue);
} else {
record.reject();
}
}
},
walkCells: function(pos, direction, e, preventWrap, verifierFn, scope) {
if (direction == 'left') {
direction = 'up';
} else if (direction == 'right') {
direction = 'down';
}
pos = Ext.view.Table.prototype.walkCells.call(this, pos, direction, e, preventWrap, verifierFn, scope);
if (!pos.column) {
pos.column = 1;
}
return pos;
},
getCellEditor : function(record, column) {
var me = this,
propName = record.get(me.nameField),
val = record.get(me.valueField),
editor = me.customEditors[propName];
if (editor) {
if (!(editor instanceof Ext.grid.CellEditor)) {
if (!(editor instanceof Ext.form.field.Base)) {
editor = Ext.ComponentManager.create(editor, 'textfield');
}
editor = me.customEditors[propName] = Ext.create('Ext.grid.CellEditor', { field: editor });
}
} else if (Ext.isDate(val)) {
editor = me.editors.date;
} else if (Ext.isNumber(val)) {
editor = me.editors.number;
} else if (Ext.isBoolean(val)) {
editor = me.editors['boolean'];
} else {
editor = me.editors.string;
}
editor.editorId = propName;
return editor;
},
beforeDestroy: function() {
var me = this;
me.callParent();
me.destroyEditors(me.editors);
me.destroyEditors(me.customEditors);
delete me.source;
},
destroyEditors: function (editors) {
for (var ed in editors) {
if (editors.hasOwnProperty(ed)) {
Ext.destroy(editors[ed]);
}
}
},
setSource: function(source) {
this.source = source;
this.propStore.setSource(source);
},
getSource: function() {
return this.propStore.getSource();
},
setProperty: function(prop, value, create) {
this.propStore.setValue(prop, value, create);
},
removeProperty: function(prop) {
this.propStore.remove(prop);
}
});
Ext.define('Ext.grid.property.HeaderContainer', {
extend: 'Ext.grid.header.Container',
alternateClassName: 'Ext.grid.PropertyColumnModel',
nameWidth: 115,
nameText : 'Name',
valueText : 'Value',
dateFormat : 'm/j/Y',
trueText: 'true',
falseText: 'false',
nameColumnCls: Ext.baseCSSPrefix + 'grid-property-name',
constructor : function(grid, store) {
var me = this;
me.grid = grid;
me.store = store;
me.callParent([{
items: [{
header: me.nameText,
width: grid.nameColumnWidth || me.nameWidth,
sortable: true,
dataIndex: grid.nameField,
renderer: Ext.Function.bind(me.renderProp, me),
itemId: grid.nameField,
menuDisabled :true,
tdCls: me.nameColumnCls
}, {
header: me.valueText,
renderer: Ext.Function.bind(me.renderCell, me),
getEditor: Ext.Function.bind(me.getCellEditor, me),
flex: 1,
fixed: true,
dataIndex: grid.valueField,
itemId: grid.valueField,
menuDisabled: true
}]
}]);
},
getCellEditor: function(record){
return this.grid.getCellEditor(record, this);
},
renderProp : function(v) {
return this.getPropertyName(v);
},
renderCell : function(val, meta, rec) {
var me = this,
renderer = me.grid.customRenderers[rec.get(me.grid.nameField)],
result = val;
if (renderer) {
return renderer.apply(me, arguments);
}
if (Ext.isDate(val)) {
result = me.renderDate(val);
} else if (Ext.isBoolean(val)) {
result = me.renderBool(val);
}
return Ext.util.Format.htmlEncode(result);
},
renderDate : Ext.util.Format.date,
renderBool : function(bVal) {
return this[bVal ? 'trueText' : 'falseText'];
},
getPropertyName : function(name) {
var pn = this.grid.propertyNames;
return pn && pn[name] ? pn[name] : name;
}
});
Ext.define('Ext.grid.property.Property', {
extend: 'Ext.data.Model',
alternateClassName: 'Ext.PropGridProperty',
fields: [{
name: 'name',
type: 'string'
}, {
name: 'value'
}],
idProperty: 'name'
});
Ext.define('Ext.grid.property.Store', {
extend: 'Ext.data.Store',
alternateClassName: 'Ext.grid.PropertyStore',
uses: ['Ext.data.reader.Reader', 'Ext.data.proxy.Proxy', 'Ext.data.ResultSet', 'Ext.grid.property.Property'],
constructor : function(grid, source){
var me = this;
me.grid = grid;
me.source = source;
me.callParent([{
data: source,
model: Ext.grid.property.Property,
proxy: me.getProxy()
}]);
},
getProxy: function() {
if (!this.proxy) {
Ext.grid.property.Store.prototype.proxy = Ext.create('Ext.data.proxy.Memory', {
model: Ext.grid.property.Property,
reader: this.getReader()
});
}
return this.proxy;
},
getReader: function() {
if (!this.reader) {
Ext.grid.property.Store.prototype.reader = Ext.create('Ext.data.reader.Reader', {
model: Ext.grid.property.Property,
buildExtractors: Ext.emptyFn,
read: function(dataObject) {
return this.readRecords(dataObject);
},
readRecords: function(dataObject) {
var val,
propName,
result = {
records: [],
success: true
};
for (propName in dataObject) {
if (dataObject.hasOwnProperty(propName)) {
val = dataObject[propName];
if (this.isEditableValue(val)) {
result.records.push(new Ext.grid.property.Property({
name: propName,
value: val
}, propName));
}
}
}
result.total = result.count = result.records.length;
return Ext.create('Ext.data.ResultSet', result);
},
isEditableValue: function(val){
return Ext.isPrimitive(val) || Ext.isDate(val);
}
});
}
return this.reader;
},
setSource : function(dataObject) {
var me = this;
me.source = dataObject;
me.suspendEvents();
me.removeAll();
me.proxy.data = dataObject;
me.load();
me.resumeEvents();
me.fireEvent('datachanged', me);
},
getProperty : function(row) {
return Ext.isNumber(row) ? this.getAt(row) : this.getById(row);
},
setValue : function(prop, value, create){
var me = this,
rec = me.getRec(prop);
if (rec) {
rec.set('value', value);
me.source[prop] = value;
} else if (create) {
me.source[prop] = value;
rec = new Ext.grid.property.Property({name: prop, value: value}, prop);
me.add(rec);
}
},
remove : function(prop) {
var rec = this.getRec(prop);
if (rec) {
this.callParent([rec]);
delete this.source[prop];
}
},
getRec : function(prop) {
return this.getById(prop);
},
getSource : function() {
return this.source;
}
});
Ext.define('Ext.layout.component.Body', {
alias: ['layout.body'],
extend: 'Ext.layout.component.Component',
uses: ['Ext.layout.container.Container'],
type: 'body',
onLayout: function(width, height) {
var me = this,
owner = me.owner;
me.setTargetSize(width, height);
me.setBodySize.apply(me, arguments);
if (owner && owner.layout && owner.layout.isLayout) {
if (!Ext.isNumber(owner.height) || !Ext.isNumber(owner.width)) {
owner.layout.bindToOwnerCtComponent = true;
}
else {
owner.layout.bindToOwnerCtComponent = false;
}
}
me.callParent(arguments);
},
setBodySize: function(width, height) {
var me = this,
owner = me.owner,
frameSize = owner.frameSize,
isNumber = Ext.isNumber;
if (isNumber(width)) {
width -= owner.el.getFrameWidth('lr') - frameSize.left - frameSize.right;
}
if (isNumber(height)) {
height -= owner.el.getFrameWidth('tb') - frameSize.top - frameSize.bottom;
}
me.setElementSize(owner.body, width, height);
}
});
Ext.define('Ext.layout.component.FieldSet', {
extend: 'Ext.layout.component.Body',
alias: ['layout.fieldset'],
type: 'fieldset',
doContainerLayout: function() {
if (!this.owner.collapsed) {
this.callParent();
}
}
});
Ext.define('Ext.layout.component.Tab', {
alias: ['layout.tab'],
extend: 'Ext.layout.component.Button',
beforeLayout: function() {
var me = this, dirty = me.lastClosable !== me.owner.closable;
if (dirty) {
delete me.adjWidth;
}
return this.callParent(arguments) || dirty;
},
onLayout: function () {
var me = this;
me.callParent(arguments);
me.lastClosable = me.owner.closable;
}
});
Ext.define('Ext.layout.component.field.File', {
alias: ['layout.filefield'],
extend: 'Ext.layout.component.field.Field',
type: 'filefield',
sizeBodyContents: function(width, height) {
var me = this,
owner = me.owner;
if (!owner.buttonOnly) {
me.setElementSize(owner.inputEl, Ext.isNumber(width) ? width - owner.button.getWidth() - owner.buttonMargin : width);
}
}
});
Ext.define('Ext.layout.component.field.Slider', {
alias: ['layout.sliderfield'],
extend: 'Ext.layout.component.field.Field',
type: 'sliderfield',
sizeBodyContents: function(width, height) {
var owner = this.owner,
thumbs = owner.thumbs,
length = thumbs.length,
inputEl = owner.inputEl,
innerEl = owner.innerEl,
endEl = owner.endEl,
i = 0;
for(; i < length; ++i) {
thumbs[i].el.stopAnimation();
}
if (owner.vertical) {
inputEl.setHeight(height);
innerEl.setHeight(Ext.isNumber(height) ? height - inputEl.getPadding('t') - endEl.getPadding('b') : height);
}
else {
inputEl.setWidth(width);
innerEl.setWidth(Ext.isNumber(width) ? width - inputEl.getPadding('l') - endEl.getPadding('r') : width);
}
owner.syncThumbs();
}
});
Ext.define('Ext.layout.container.Absolute', {
alias: 'layout.absolute',
extend: 'Ext.layout.container.Anchor',
requires: ['Ext.chart.axis.Axis', 'Ext.fx.Anim'],
alternateClassName: 'Ext.layout.AbsoluteLayout',
itemCls: Ext.baseCSSPrefix + 'abs-layout-item',
type: 'absolute',
onLayout: function() {
var me = this,
target = me.getTarget(),
targetIsBody = target.dom === document.body;
if (!targetIsBody) {
target.position();
}
me.paddingLeft = target.getPadding('l');
me.paddingTop = target.getPadding('t');
me.callParent(arguments);
},
adjustWidthAnchor: function(value, comp) {
return value ? value - comp.getPosition(true)[0] : value;
},
adjustHeightAnchor: function(value, comp) {
return value ? value - comp.getPosition(true)[1] : value;
}
});
Ext.define('Ext.layout.container.Accordion', {
extend: 'Ext.layout.container.VBox',
alias: ['layout.accordion'],
alternateClassName: 'Ext.layout.AccordionLayout',
align: 'stretch',
fill : true,
autoWidth : true,
titleCollapse : true,
hideCollapseTool : false,
collapseFirst : false,
animate : true,
activeOnTop : false,
multi: false,
constructor: function() {
var me = this;
me.callParent(arguments);
me.initialAnimate = me.animate;
me.animate = false;
if (me.fill === false) {
me.itemCls = Ext.baseCSSPrefix + 'accordion-item';
}
},
beforeLayout: function() {
var me = this;
me.callParent(arguments);
if (me.fill) {
if (!me.owner.el.dom.style.height || !me.getLayoutTargetSize().height) {
return false;
}
} else {
me.owner.componentLayout.monitorChildren = false;
me.autoSize = true;
me.owner.setAutoScroll(true);
}
},
renderItems : function(items, target) {
var me = this,
ln = items.length,
i = 0,
comp,
targetSize = me.getLayoutTargetSize(),
renderedPanels = [],
border;
for (; i < ln; i++) {
comp = items[i];
if (!comp.rendered) {
renderedPanels.push(comp);
if (me.collapseFirst) {
comp.collapseFirst = me.collapseFirst;
}
if (me.hideCollapseTool) {
comp.hideCollapseTool = me.hideCollapseTool;
comp.titleCollapse = true;
}
else if (me.titleCollapse) {
comp.titleCollapse = me.titleCollapse;
}
delete comp.hideHeader;
comp.collapsible = true;
comp.title = comp.title || ' ';
comp.width = targetSize.width;
if (me.fill) {
delete comp.height;
delete comp.flex;
if (me.expandedItem !== undefined) {
comp.collapsed = true;
}
else if (comp.hasOwnProperty('collapsed') && comp.collapsed === false) {
comp.flex = 1;
me.expandedItem = i;
} else {
comp.collapsed = true;
}
me.owner.mon(comp, {
show: me.onComponentShow,
beforeexpand: me.onComponentExpand,
beforecollapse: me.onComponentCollapse,
scope: me
});
} else {
delete comp.flex;
comp.animCollapse = me.initialAnimate;
comp.autoHeight = true;
comp.autoScroll = false;
}
}
}
if (ln && me.expandedItem === undefined) {
me.expandedItem = 0;
comp = items[0];
comp.collapsed = false;
if (me.fill) {
comp.flex = 1;
}
}
me.callParent(arguments);
ln = renderedPanels.length;
for (i = 0; i < ln; i++) {
comp = renderedPanels[i];
delete comp.width;
comp.header.addCls(Ext.baseCSSPrefix + 'accordion-hd');
comp.body.addCls(Ext.baseCSSPrefix + 'accordion-body');
}
},
onLayout: function() {
var me = this;
if (me.fill) {
me.callParent(arguments);
} else {
var targetSize = me.getLayoutTargetSize(),
items = me.getVisibleItems(),
len = items.length,
i = 0, comp;
for (; i < len; i++) {
comp = items[i];
if (comp.collapsed) {
items[i].setWidth(targetSize.width);
} else {
items[i].setSize(null, null);
}
}
}
me.updatePanelClasses();
return me;
},
updatePanelClasses: function() {
var children = this.getLayoutItems(),
ln = children.length,
siblingCollapsed = true,
i, child;
for (i = 0; i < ln; i++) {
child = children[i];
if (siblingCollapsed) {
child.header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded');
}
else {
child.header.addCls(Ext.baseCSSPrefix + 'accordion-hd-sibling-expanded');
}
if (i + 1 == ln && child.collapsed) {
child.header.addCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed');
}
else {
child.header.removeCls(Ext.baseCSSPrefix + 'accordion-hd-last-collapsed');
}
siblingCollapsed = child.collapsed;
}
},
onComponentExpand: function(toExpand) {
var me = this,
it = me.owner.items.items,
len = it.length,
i = 0,
comp;
for (; i < len; i++) {
comp = it[i];
if (comp === toExpand && comp.collapsed) {
me.setExpanded(comp);
} else if (!me.multi && (comp.rendered && comp.header.rendered && comp !== toExpand && !comp.collapsed)) {
me.setCollapsed(comp);
}
}
me.animate = me.initialAnimate;
me.layout();
me.animate = false;
return false;
},
onComponentCollapse: function(comp) {
var me = this,
toExpand = comp.next() || comp.prev(),
expanded = me.multi ? me.owner.query('>panel:not([collapsed])') : [];
if (me.multi) {
me.setCollapsed(comp);
if (expanded.length === 1 && expanded[0] === comp) {
me.setExpanded(toExpand);
}
me.animate = me.initialAnimate;
me.layout();
me.animate = false;
}
else if (toExpand) {
me.onComponentExpand(toExpand);
}
return false;
},
onComponentShow: function(comp) {
this.onComponentExpand(comp);
},
setCollapsed: function(comp) {
var otherDocks = comp.getDockedItems(),
dockItem,
len = otherDocks.length,
i = 0;
comp.hiddenDocked = [];
for (; i < len; i++) {
dockItem = otherDocks[i];
if ((dockItem !== comp.header) && !dockItem.hidden) {
dockItem.hidden = true;
comp.hiddenDocked.push(dockItem);
}
}
comp.addCls(comp.collapsedCls);
comp.header.addCls(comp.collapsedHeaderCls);
comp.height = comp.header.getHeight();
comp.el.setHeight(comp.height);
comp.collapsed = true;
delete comp.flex;
comp.fireEvent('collapse', comp);
if (comp.collapseTool) {
comp.collapseTool.setType('expand-' + comp.getOppositeDirection(comp.collapseDirection));
}
},
setExpanded: function(comp) {
var otherDocks = comp.hiddenDocked,
len = otherDocks ? otherDocks.length : 0,
i = 0;
for (; i < len; i++) {
otherDocks[i].show();
}
if (!comp.body.isVisible()) {
comp.body.show();
}
delete comp.collapsed;
delete comp.height;
delete comp.componentLayout.lastComponentSize;
comp.suspendLayout = false;
comp.flex = 1;
comp.removeCls(comp.collapsedCls);
comp.header.removeCls(comp.collapsedHeaderCls);
comp.fireEvent('expand', comp);
if (comp.collapseTool) {
comp.collapseTool.setType('collapse-' + comp.collapseDirection);
}
comp.setAutoScroll(comp.initialConfig.autoScroll);
}
});
Ext.define('Ext.resizer.Splitter', {
extend: 'Ext.Component',
requires: ['Ext.XTemplate'],
uses: ['Ext.resizer.SplitterTracker'],
alias: 'widget.splitter',
renderTpl: [
'
',
'{text}',
' ',
'',
' hidefocus="true" unselectable="on">',
'',
'',
'',
'',
' ',
'',
''
],
maskOnDisable: false,
activate: function() {
var me = this;
if (!me.activated && me.canActivate && me.rendered && !me.isDisabled() && me.isVisible()) {
me.el.addCls(me.activeCls);
me.focus();
me.activated = true;
me.fireEvent('activate', me);
}
},
blur: function() {
this.$focused = false;
this.callParent(arguments);
},
deactivate: function() {
var me = this;
if (me.activated) {
me.el.removeCls(me.activeCls);
me.blur();
me.hideMenu();
me.activated = false;
me.fireEvent('deactivate', me);
}
},
deferExpandMenu: function() {
var me = this;
if (!me.menu.rendered || !me.menu.isVisible()) {
me.parentMenu.activeChild = me.menu;
me.menu.parentItem = me;
me.menu.parentMenu = me.menu.ownerCt = me.parentMenu;
me.menu.showBy(me, me.menuAlign);
}
},
deferHideMenu: function() {
if (this.menu.isVisible()) {
this.menu.hide();
}
},
deferHideParentMenus: function() {
Ext.menu.Manager.hideAll();
},
expandMenu: function(delay) {
var me = this;
if (me.menu) {
clearTimeout(me.hideMenuTimer);
if (delay === 0) {
me.deferExpandMenu();
} else {
me.expandMenuTimer = Ext.defer(me.deferExpandMenu, Ext.isNumber(delay) ? delay : me.menuExpandDelay, me);
}
}
},
focus: function() {
this.$focused = true;
this.callParent(arguments);
},
getRefItems: function(deep){
var menu = this.menu,
items;
if (menu) {
items = menu.getRefItems(deep);
items.unshift(menu);
}
return items || [];
},
hideMenu: function(delay) {
var me = this;
if (me.menu) {
clearTimeout(me.expandMenuTimer);
me.hideMenuTimer = Ext.defer(me.deferHideMenu, Ext.isNumber(delay) ? delay : me.menuHideDelay, me);
}
},
initComponent: function() {
var me = this,
prefix = Ext.baseCSSPrefix,
cls = [prefix + 'menu-item'];
me.addEvents(
'activate',
'click',
'deactivate'
);
if (me.plain) {
cls.push(prefix + 'menu-item-plain');
}
if (me.cls) {
cls.push(me.cls);
}
me.cls = cls.join(' ');
if (me.menu) {
me.menu = Ext.menu.Manager.get(me.menu);
}
me.callParent(arguments);
},
onClick: function(e) {
var me = this;
if (!me.href) {
e.stopEvent();
}
if (me.disabled) {
return;
}
if (me.hideOnClick) {
me.deferHideParentMenusTimer = Ext.defer(me.deferHideParentMenus, me.clickHideDelay, me);
}
Ext.callback(me.handler, me.scope || me, [me, e]);
me.fireEvent('click', me, e);
if (!me.hideOnClick) {
me.focus();
}
},
onDestroy: function() {
var me = this;
clearTimeout(me.expandMenuTimer);
clearTimeout(me.hideMenuTimer);
clearTimeout(me.deferHideParentMenusTimer);
if (me.menu) {
delete me.menu.parentItem;
delete me.menu.parentMenu;
delete me.menu.ownerCt;
if (me.destroyMenu !== false) {
me.menu.destroy();
}
}
me.callParent(arguments);
},
onRender: function(ct, pos) {
var me = this,
prefix = '.' + Ext.baseCSSPrefix;
Ext.applyIf(me.renderData, {
href: me.href || '#',
hrefTarget: me.hrefTarget,
icon: me.icon || Ext.BLANK_IMAGE_URL,
iconCls: me.iconCls + (me.checkChangeDisabled ? ' ' + me.disabledCls : ''),
menu: Ext.isDefined(me.menu),
plain: me.plain,
text: me.text
});
Ext.applyIf(me.renderSelectors, {
itemEl: prefix + 'menu-item-link',
iconEl: prefix + 'menu-item-icon',
textEl: prefix + 'menu-item-text',
arrowEl: prefix + 'menu-item-arrow'
});
me.callParent(arguments);
},
setHandler: function(fn, scope) {
this.handler = fn || null;
this.scope = scope;
},
setIconCls: function(iconCls) {
var me = this;
if (me.iconEl) {
if (me.iconCls) {
me.iconEl.removeCls(me.iconCls);
}
if (iconCls) {
me.iconEl.addCls(iconCls);
}
}
me.iconCls = iconCls;
},
setText: function(text) {
var me = this,
el = me.textEl || me.el;
me.text = text;
if (me.rendered) {
el.update(text || '');
me.ownerCt.redoComponentLayout();
}
}
});
Ext.define('Ext.menu.CheckItem', {
extend: 'Ext.menu.Item',
alias: 'widget.menucheckitem',
checkedCls: Ext.baseCSSPrefix + 'menu-item-checked',
uncheckedCls: Ext.baseCSSPrefix + 'menu-item-unchecked',
groupCls: Ext.baseCSSPrefix + 'menu-group-icon',
hideOnClick: false,
afterRender: function() {
var me = this;
this.callParent();
me.checked = !me.checked;
me.setChecked(!me.checked, true);
},
initComponent: function() {
var me = this;
me.addEvents(
'beforecheckchange',
'checkchange'
);
me.callParent(arguments);
Ext.menu.Manager.registerCheckable(me);
if (me.group) {
if (!me.iconCls) {
me.iconCls = me.groupCls;
}
if (me.initialConfig.hideOnClick !== false) {
me.hideOnClick = true;
}
}
},
disableCheckChange: function() {
var me = this;
if (me.iconEl) {
me.iconEl.addCls(me.disabledCls);
}
me.checkChangeDisabled = true;
},
enableCheckChange: function() {
var me = this;
me.iconEl.removeCls(me.disabledCls);
me.checkChangeDisabled = false;
},
onClick: function(e) {
var me = this;
if(!me.disabled && !me.checkChangeDisabled && !(me.checked && me.group)) {
me.setChecked(!me.checked);
}
this.callParent([e]);
},
onDestroy: function() {
Ext.menu.Manager.unregisterCheckable(this);
this.callParent(arguments);
},
setChecked: function(checked, suppressEvents) {
var me = this;
if (me.checked !== checked && (suppressEvents || me.fireEvent('beforecheckchange', me, checked) !== false)) {
if (me.el) {
me.el[checked ? 'addCls' : 'removeCls'](me.checkedCls)[!checked ? 'addCls' : 'removeCls'](me.uncheckedCls);
}
me.checked = checked;
Ext.menu.Manager.onCheckChange(me, checked);
if (!suppressEvents) {
Ext.callback(me.checkHandler, me.scope, [me, checked]);
me.fireEvent('checkchange', me, checked);
}
}
}
});
Ext.define('Ext.menu.KeyNav', {
extend: 'Ext.util.KeyNav',
requires: ['Ext.FocusManager'],
constructor: function(menu) {
var me = this;
me.menu = menu;
me.callParent([menu.el, {
down: me.down,
enter: me.enter,
esc: me.escape,
left: me.left,
right: me.right,
space: me.enter,
tab: me.tab,
up: me.up
}]);
},
down: function(e) {
var me = this,
fi = me.menu.focusedItem;
if (fi && e.getKey() == Ext.EventObject.DOWN && me.isWhitelisted(fi)) {
return true;
}
me.focusNextItem(1);
},
enter: function(e) {
var menu = this.menu;
if (menu.activeItem) {
menu.onClick(e);
}
},
escape: function(e) {
Ext.menu.Manager.hideAll();
},
focusNextItem: function(step) {
var menu = this.menu,
items = menu.items,
focusedItem = menu.focusedItem,
startIdx = focusedItem ? items.indexOf(focusedItem) : -1,
idx = startIdx + step;
while (idx != startIdx) {
if (idx < 0) {
idx = items.length - 1;
} else if (idx >= items.length) {
idx = 0;
}
var item = items.getAt(idx);
if (menu.canActivateItem(item)) {
menu.setActiveItem(item);
break;
}
idx += step;
}
},
isWhitelisted: function(item) {
return Ext.FocusManager.isWhitelisted(item);
},
left: function(e) {
var menu = this.menu,
fi = menu.focusedItem,
ai = menu.activeItem;
if (fi && this.isWhitelisted(fi)) {
return true;
}
menu.hide();
if (menu.parentMenu) {
menu.parentMenu.focus();
}
},
right: function(e) {
var menu = this.menu,
fi = menu.focusedItem,
ai = menu.activeItem,
am;
if (fi && this.isWhitelisted(fi)) {
return true;
}
if (ai) {
am = menu.activeItem.menu;
if (am) {
ai.expandMenu(0);
Ext.defer(function() {
am.setActiveItem(am.items.getAt(0));
}, 25);
}
}
},
tab: function(e) {
var me = this;
if (e.shiftKey) {
me.up(e);
} else {
me.down(e);
}
},
up: function(e) {
var me = this,
fi = me.menu.focusedItem;
if (fi && e.getKey() == Ext.EventObject.UP && me.isWhitelisted(fi)) {
return true;
}
me.focusNextItem(-1);
}
});
Ext.define('Ext.menu.Separator', {
extend: 'Ext.menu.Item',
alias: 'widget.menuseparator',
canActivate: false,
focusable: false,
hideOnClick: false,
plain: true,
separatorCls: Ext.baseCSSPrefix + 'menu-item-separator',
text: ' ',
onRender: function(ct, pos) {
var me = this,
sepCls = me.separatorCls;
me.cls += ' ' + sepCls;
Ext.applyIf(me.renderSelectors, {
itemSepEl: '.' + sepCls
});
me.callParent(arguments);
}
});
Ext.define('Ext.menu.Menu', {
extend: 'Ext.panel.Panel',
alias: 'widget.menu',
requires: [
'Ext.layout.container.Fit',
'Ext.layout.container.VBox',
'Ext.menu.CheckItem',
'Ext.menu.Item',
'Ext.menu.KeyNav',
'Ext.menu.Manager',
'Ext.menu.Separator'
],
allowOtherMenus: false,
ariaRole: 'menu',
defaultAlign: 'tl-bl?',
floating: true,
constrain: true,
hidden: true,
hideMode: 'visibility',
ignoreParentClicks: false,
isMenu: true,
showSeparator : true,
minWidth: 120,
initComponent: function() {
var me = this,
prefix = Ext.baseCSSPrefix,
cls = [prefix + 'menu'],
bodyCls = me.bodyCls ? [me.bodyCls] : [];
me.addEvents(
'click',
'mouseenter',
'mouseleave',
'mouseover'
);
Ext.menu.Manager.register(me);
if (me.plain) {
cls.push(prefix + 'menu-plain');
}
me.cls = cls.join(' ');
bodyCls.unshift(prefix + 'menu-body');
me.bodyCls = bodyCls.join(' ');
me.layout = {
type: 'vbox',
align: 'stretchmax',
autoSize: true,
clearInnerCtOnLayout: true,
overflowHandler: 'Scroller'
};
if (me.floating === false && me.initialConfig.hidden !== true) {
me.hidden = false;
}
me.callParent(arguments);
me.on('beforeshow', function() {
var hasItems = !!me.items.length;
if (hasItems && me.rendered) {
me.el.setStyle('visibility', null);
}
return hasItems;
});
},
afterRender: function(ct) {
var me = this,
prefix = Ext.baseCSSPrefix,
space = ' ';
me.callParent(arguments);
if (me.showSeparator) {
me.iconSepEl = me.layout.getRenderTarget().insertFirst({
cls: prefix + 'menu-icon-separator',
html: space
});
}
me.focusEl = me.el.createChild({
cls: prefix + 'menu-focus',
tabIndex: '-1',
html: space
});
me.mon(me.el, {
click: me.onClick,
mouseover: me.onMouseOver,
scope: me
});
me.mouseMonitor = me.el.monitorMouseLeave(100, me.onMouseLeave, me);
if (me.showSeparator && ((!Ext.isStrict && Ext.isIE) || Ext.isIE6)) {
me.iconSepEl.setHeight(me.el.getHeight());
}
me.keyNav = Ext.create('Ext.menu.KeyNav', me);
},
afterLayout: function() {
var me = this;
me.callParent(arguments);
if ((!Ext.iStrict && Ext.isIE) || Ext.isIE6) {
var innerCt = me.layout.getRenderTarget(),
innerCtWidth = 0,
dis = me.dockedItems,
l = dis.length,
i = 0,
di, clone, newWidth;
innerCtWidth = innerCt.getWidth();
newWidth = innerCtWidth + me.body.getBorderWidth('lr') + me.body.getPadding('lr');
me.body.setWidth(newWidth);
for (; i < l, di = dis.getAt(i); i++) {
if (di.dock == 'left' || di.dock == 'right') {
newWidth += di.getWidth();
}
}
me.el.setWidth(newWidth);
}
},
canActivateItem: function(item) {
return item && !item.isDisabled() && item.isVisible() && (item.canActivate || item.getXTypes().indexOf('menuitem') < 0);
},
deactivateActiveItem: function() {
var me = this;
if (me.activeItem) {
me.activeItem.deactivate();
if (!me.activeItem.activated) {
delete me.activeItem;
}
}
if (me.focusedItem) {
me.focusedItem.blur();
if (!me.focusedItem.$focused) {
delete me.focusedItem;
}
}
},
clearStretch: function () {
if (this.rendered) {
this.items.each(function (item) {
if (item.componentLayout) {
delete item.componentLayout.lastComponentSize;
}
if (item.el) {
item.el.setWidth(null);
}
});
}
},
onAdd: function () {
var me = this;
me.clearStretch();
me.callParent(arguments);
if (Ext.isIE6 || Ext.isIE7) {
Ext.Function.defer(me.doComponentLayout, 10, me);
}
},
onRemove: function () {
this.clearStretch();
this.callParent(arguments);
},
redoComponentLayout: function () {
if (this.rendered) {
this.clearStretch();
this.doComponentLayout();
}
},
getFocusEl: function() {
return this.focusEl;
},
hide: function() {
this.deactivateActiveItem();
this.callParent(arguments);
},
getItemFromEvent: function(e) {
return this.getChildByElement(e.getTarget());
},
lookupComponent: function(cmp) {
var me = this;
if (Ext.isString(cmp)) {
cmp = me.lookupItemFromString(cmp);
} else if (Ext.isObject(cmp)) {
cmp = me.lookupItemFromObject(cmp);
}
cmp.minWidth = cmp.minWidth || me.minWidth;
return cmp;
},
lookupItemFromObject: function(cmp) {
var me = this,
prefix = Ext.baseCSSPrefix,
cls,
intercept;
if (!cmp.isComponent) {
if (!cmp.xtype) {
cmp = Ext.create('Ext.menu.' + (Ext.isBoolean(cmp.checked) ? 'Check': '') + 'Item', cmp);
} else {
cmp = Ext.ComponentManager.create(cmp, cmp.xtype);
}
}
if (cmp.isMenuItem) {
cmp.parentMenu = me;
}
if (!cmp.isMenuItem && !cmp.dock) {
cls = [prefix + 'menu-item', prefix + 'menu-item-cmp'];
intercept = Ext.Function.createInterceptor;
cmp.focus = intercept(cmp.focus, function() {
this.$focused = true;
}, cmp);
cmp.blur = intercept(cmp.blur, function() {
this.$focused = false;
}, cmp);
if (!me.plain && (cmp.indent === true || cmp.iconCls === 'no-icon')) {
cls.push(prefix + 'menu-item-indent');
}
if (cmp.rendered) {
cmp.el.addCls(cls);
} else {
cmp.cls = (cmp.cls ? cmp.cls : '') + ' ' + cls.join(' ');
}
cmp.isMenuItem = true;
}
return cmp;
},
lookupItemFromString: function(cmp) {
return (cmp == 'separator' || cmp == '-') ?
Ext.createWidget('menuseparator')
: Ext.createWidget('menuitem', {
canActivate: false,
hideOnClick: false,
plain: true,
text: cmp
});
},
onClick: function(e) {
var me = this,
item;
if (me.disabled) {
e.stopEvent();
return;
}
if ((e.getTarget() == me.focusEl.dom) || e.within(me.layout.getRenderTarget())) {
item = me.getItemFromEvent(e) || me.activeItem;
if (item) {
if (item.getXTypes().indexOf('menuitem') >= 0) {
if (!item.menu || !me.ignoreParentClicks) {
item.onClick(e);
} else {
e.stopEvent();
}
}
}
me.fireEvent('click', me, item, e);
}
},
onDestroy: function() {
var me = this;
Ext.menu.Manager.unregister(me);
if (me.rendered) {
me.el.un(me.mouseMonitor);
me.keyNav.destroy();
delete me.keyNav;
}
me.callParent(arguments);
},
onMouseLeave: function(e) {
var me = this;
me.deactivateActiveItem();
if (me.disabled) {
return;
}
me.fireEvent('mouseleave', me, e);
},
onMouseOver: function(e) {
var me = this,
fromEl = e.getRelatedTarget(),
mouseEnter = !me.el.contains(fromEl),
item = me.getItemFromEvent(e);
if (mouseEnter && me.parentMenu) {
me.parentMenu.setActiveItem(me.parentItem);
me.parentMenu.mouseMonitor.mouseenter();
}
if (me.disabled) {
return;
}
if (item) {
me.setActiveItem(item);
if (item.activated && item.expandMenu) {
item.expandMenu();
}
}
if (mouseEnter) {
me.fireEvent('mouseenter', me, e);
}
me.fireEvent('mouseover', me, item, e);
},
setActiveItem: function(item) {
var me = this;
if (item && (item != me.activeItem && item != me.focusedItem)) {
me.deactivateActiveItem();
if (me.canActivateItem(item)) {
if (item.activate) {
item.activate();
if (item.activated) {
me.activeItem = item;
me.focusedItem = item;
me.focus();
}
} else {
item.focus();
me.focusedItem = item;
}
}
item.el.scrollIntoView(me.layout.getRenderTarget());
}
},
showBy: function(cmp, pos, off) {
var me = this,
xy,
region;
if (me.floating && cmp) {
me.layout.autoSize = true;
me.doAutoRender();
cmp = cmp.el || cmp;
xy = me.el.getAlignToXY(cmp, pos || me.defaultAlign, off);
if (me.floatParent) {
region = me.floatParent.getTargetEl().getViewRegion();
xy[0] -= region.x;
xy[1] -= region.y;
}
me.showAt(xy);
}
return me;
},
showAt: function(){
this.callParent(arguments);
if (this.floating) {
this.doConstrain();
}
},
doConstrain : function() {
var me = this,
y = me.el.getY(),
max, full,
vector,
returnY = y, normalY, parentEl, scrollTop, viewHeight;
delete me.height;
me.setSize();
full = me.getHeight();
if (me.floating) {
parentEl = Ext.fly(me.el.dom.parentNode);
scrollTop = parentEl.getScroll().top;
viewHeight = parentEl.getViewSize().height;
normalY = y - scrollTop;
max = me.maxHeight ? me.maxHeight : viewHeight - normalY;
if (full > viewHeight) {
max = viewHeight;
returnY = y - normalY;
} else if (max < full) {
returnY = y - (full - max);
max = full;
}
}else{
max = me.getHeight();
}
if (me.maxHeight){
max = Math.min(me.maxHeight, max);
}
if (full > max && max > 0){
me.layout.autoSize = false;
me.setHeight(max);
if (me.showSeparator){
me.iconSepEl.setHeight(me.layout.getRenderTarget().dom.scrollHeight);
}
}
vector = me.getConstrainVector(me.el.dom.parentNode);
if (vector) {
me.setPosition(me.getPosition()[0] + vector[0]);
}
me.el.setY(returnY);
}
});
Ext.define('Ext.menu.ColorPicker', {
extend: 'Ext.menu.Menu',
alias: 'widget.colormenu',
requires: [
'Ext.picker.Color'
],
hideOnClick : true,
pickerId : null,
initComponent : function(){
var me = this;
Ext.apply(me, {
plain: true,
showSeparator: false,
items: Ext.applyIf({
cls: Ext.baseCSSPrefix + 'menu-color-item',
id: me.pickerId,
xtype: 'colorpicker'
}, me.initialConfig)
});
me.callParent(arguments);
me.picker = me.down('colorpicker');
me.relayEvents(me.picker, ['select']);
if (me.hideOnClick) {
me.on('select', me.hidePickerOnSelect, me);
}
},
hidePickerOnSelect: function() {
Ext.menu.Manager.hideAll();
}
});
Ext.define('Ext.menu.DatePicker', {
extend: 'Ext.menu.Menu',
alias: 'widget.datemenu',
requires: [
'Ext.picker.Date'
],
hideOnClick : true,
pickerId : null,
initComponent : function(){
var me = this;
Ext.apply(me, {
showSeparator: false,
plain: true,
border: false,
bodyPadding: 0,
items: Ext.applyIf({
cls: Ext.baseCSSPrefix + 'menu-date-item',
id: me.pickerId,
xtype: 'datepicker'
}, me.initialConfig)
});
me.callParent(arguments);
me.picker = me.down('datepicker');
me.relayEvents(me.picker, ['select']);
if (me.hideOnClick) {
me.on('select', me.hidePickerOnSelect, me);
}
},
hidePickerOnSelect: function() {
Ext.menu.Manager.hideAll();
}
});
Ext.define('Ext.panel.Tool', {
extend: 'Ext.Component',
requires: ['Ext.tip.QuickTipManager'],
alias: 'widget.tool',
baseCls: Ext.baseCSSPrefix + 'tool',
disabledCls: Ext.baseCSSPrefix + 'tool-disabled',
toolPressedCls: Ext.baseCSSPrefix + 'tool-pressed',
toolOverCls: Ext.baseCSSPrefix + 'tool-over',
ariaRole: 'button',
renderTpl: ['
';
},
onRowMouseDown: function(view, record, item, index, e) {
view.el.focus();
var me = this,
checker = e.getTarget('.' + Ext.baseCSSPrefix + 'grid-row-checker');
if (me.checkOnly && !checker) {
return;
}
if (checker) {
var mode = me.getSelectionMode();
if (mode !== 'SINGLE') {
me.setSelectionMode('SIMPLE');
}
me.selectWithEvent(record, e);
me.setSelectionMode(mode);
} else {
me.selectWithEvent(record, e);
}
},
onSelectChange: function() {
this.callParent(arguments);
var hdSelectStatus = this.selected.getCount() === this.store.getCount();
this.toggleUiHeader(hdSelectStatus);
}
});
Ext.define('Ext.selection.TreeModel', {
extend: 'Ext.selection.RowModel',
alias: 'selection.treemodel',
pruneRemoved: false,
onKeyRight: function(e, t) {
var focused = this.getLastFocused(),
view = this.view;
if (focused) {
if (focused.isExpanded()) {
this.onKeyDown(e, t);
} else if (!focused.isLeaf()) {
view.expand(focused);
}
}
},
onKeyLeft: function(e, t) {
var focused = this.getLastFocused(),
view = this.view,
viewSm = view.getSelectionModel(),
parentNode, parentRecord;
if (focused) {
parentNode = focused.parentNode;
if (focused.isExpanded()) {
view.collapse(focused);
} else if (parentNode && !parentNode.isRoot()) {
if (e.shiftKey) {
viewSm.selectRange(parentNode, focused, e.ctrlKey, 'up');
viewSm.setLastFocused(parentNode);
} else if (e.ctrlKey) {
viewSm.setLastFocused(parentNode);
} else {
viewSm.select(parentNode);
}
}
}
},
onKeyPress: function(e, t) {
var selected, checked;
if (e.getKey() === e.SPACE || e.getKey() === e.ENTER) {
e.stopEvent();
selected = this.getLastSelected();
if (selected && selected.isLeaf()) {
checked = selected.get('checked');
if (Ext.isBoolean(checked)) {
selected.set('checked', !checked);
}
}
} else {
this.callParent(arguments);
}
}
});
Ext.define('Ext.slider.Thumb', {
requires: ['Ext.dd.DragTracker', 'Ext.util.Format'],
topZIndex: 10000,
constructor: function(config) {
var me = this;
Ext.apply(me, config || {}, {
cls: Ext.baseCSSPrefix + 'slider-thumb',
constrain: false
});
me.callParent([config]);
if (me.slider.vertical) {
Ext.apply(me, Ext.slider.Thumb.Vertical);
}
},
render: function() {
var me = this;
me.el = me.slider.innerEl.insertFirst({cls: me.cls});
if (me.disabled) {
me.disable();
}
me.initEvents();
},
move: function(v, animate){
if(!animate){
this.el.setLeft(v);
}else{
Ext.create('Ext.fx.Anim', {
target: this.el,
duration: 350,
to: {
left: v
}
});
}
},
bringToFront: function() {
this.el.setStyle('zIndex', this.topZIndex);
},
sendToBack: function() {
this.el.setStyle('zIndex', '');
},
enable: function() {
var me = this;
me.disabled = false;
if (me.el) {
me.el.removeCls(me.slider.disabledCls);
}
},
disable: function() {
var me = this;
me.disabled = true;
if (me.el) {
me.el.addCls(me.slider.disabledCls);
}
},
initEvents: function() {
var me = this,
el = me.el;
me.tracker = Ext.create('Ext.dd.DragTracker', {
onBeforeStart: Ext.Function.bind(me.onBeforeDragStart, me),
onStart : Ext.Function.bind(me.onDragStart, me),
onDrag : Ext.Function.bind(me.onDrag, me),
onEnd : Ext.Function.bind(me.onDragEnd, me),
tolerance : 3,
autoStart : 300,
overCls : Ext.baseCSSPrefix + 'slider-thumb-over'
});
me.tracker.initEl(el);
},
onBeforeDragStart : function(e) {
if (this.disabled) {
return false;
} else {
this.slider.promoteThumb(this);
return true;
}
},
onDragStart: function(e){
var me = this;
me.el.addCls(Ext.baseCSSPrefix + 'slider-thumb-drag');
me.dragging = true;
me.dragStartValue = me.value;
me.slider.fireEvent('dragstart', me.slider, e, me);
},
onDrag: function(e) {
var me = this,
slider = me.slider,
index = me.index,
newValue = me.getNewValue(),
above,
below;
if (me.constrain) {
above = slider.thumbs[index + 1];
below = slider.thumbs[index - 1];
if (below !== undefined && newValue <= below.value) {
newValue = below.value;
}
if (above !== undefined && newValue >= above.value) {
newValue = above.value;
}
}
slider.setValue(index, newValue, false);
slider.fireEvent('drag', slider, e, me);
},
getNewValue: function() {
var slider = this.slider,
pos = slider.innerEl.translatePoints(this.tracker.getXY());
return Ext.util.Format.round(slider.reverseValue(pos.left), slider.decimalPrecision);
},
onDragEnd: function(e) {
var me = this,
slider = me.slider,
value = me.value;
me.el.removeCls(Ext.baseCSSPrefix + 'slider-thumb-drag');
me.dragging = false;
slider.fireEvent('dragend', slider, e);
if (me.dragStartValue != value) {
slider.fireEvent('changecomplete', slider, value, me);
}
},
destroy: function() {
Ext.destroy(this.tracker);
},
statics: {
Vertical: {
getNewValue: function() {
var slider = this.slider,
innerEl = slider.innerEl,
pos = innerEl.translatePoints(this.tracker.getXY()),
bottom = innerEl.getHeight() - pos.top;
return Ext.util.Format.round(slider.reverseValue(bottom), slider.decimalPrecision);
},
move: function(v, animate) {
if (!animate) {
this.el.setBottom(v);
} else {
Ext.create('Ext.fx.Anim', {
target: this.el,
duration: 350,
to: {
bottom: v
}
});
}
}
}
}
});
Ext.define('Ext.slider.Tip', {
extend: 'Ext.tip.Tip',
minWidth: 10,
alias: 'widget.slidertip',
offsets : [0, -10],
isSliderTip: true,
init: function(slider) {
var me = this;
slider.on({
scope : me,
dragstart: me.onSlide,
drag : me.onSlide,
dragend : me.hide,
destroy : me.destroy
});
},
onSlide : function(slider, e, thumb) {
var me = this;
me.show();
me.update(me.getText(thumb));
me.doComponentLayout();
me.el.alignTo(thumb.el, 'b-t?', me.offsets);
},
getText : function(thumb) {
return String(thumb.value);
}
});
Ext.define('Ext.slider.Multi', {
extend: 'Ext.form.field.Base',
alias: 'widget.multislider',
alternateClassName: 'Ext.slider.MultiSlider',
requires: [
'Ext.slider.Thumb',
'Ext.slider.Tip',
'Ext.Number',
'Ext.util.Format',
'Ext.Template',
'Ext.layout.component.field.Slider'
],
fieldSubTpl: [
'',
{
disableFormats: true,
compiled: true
}
],
vertical: false,
minValue: 0,
maxValue: 100,
decimalPrecision: 0,
keyIncrement: 1,
increment: 0,
clickRange: [5,15],
clickToChange : true,
animate: true,
dragging: false,
constrainThumbs: true,
componentLayout: 'sliderfield',
useTips : true,
tipText : null,
ariaRole: 'slider',
initValue: function() {
var me = this,
extValue = Ext.value,
values = extValue(me.values, [extValue(me.value, extValue(me.minValue, 0))]),
i = 0,
len = values.length;
me.originalValue = values;
for (; i < len; i++) {
me.addThumb(values[i]);
}
},
initComponent : function() {
var me = this,
tipPlug,
hasTip;
me.thumbs = [];
me.keyIncrement = Math.max(me.increment, me.keyIncrement);
me.addEvents(
'beforechange',
'change',
'changecomplete',
'dragstart',
'drag',
'dragend'
);
if (me.vertical) {
Ext.apply(me, Ext.slider.Multi.Vertical);
}
me.callParent();
if (me.useTips) {
tipPlug = me.tipText ? {getText: me.tipText} : {};
me.plugins = me.plugins || [];
Ext.each(me.plugins, function(plug){
if (plug.isSliderTip) {
hasTip = true;
return false;
}
});
if (!hasTip) {
me.plugins.push(Ext.create('Ext.slider.Tip', tipPlug));
}
}
},
addThumb: function(value) {
var me = this,
thumb = Ext.create('Ext.slider.Thumb', {
value : value,
slider : me,
index : me.thumbs.length,
constrain: me.constrainThumbs
});
me.thumbs.push(thumb);
if (me.rendered) {
thumb.render();
}
return thumb;
},
promoteThumb: function(topThumb) {
var thumbs = this.thumbs,
ln = thumbs.length,
zIndex, thumb, i;
for (i = 0; i < ln; i++) {
thumb = thumbs[i];
if (thumb == topThumb) {
thumb.bringToFront();
} else {
thumb.sendToBack();
}
}
},
onRender : function() {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
thumb;
Ext.applyIf(me.subTplData, {
vertical: me.vertical ? Ext.baseCSSPrefix + 'slider-vert' : Ext.baseCSSPrefix + 'slider-horz',
minValue: me.minValue,
maxValue: me.maxValue,
value: me.value
});
Ext.applyIf(me.renderSelectors, {
endEl: '.' + Ext.baseCSSPrefix + 'slider-end',
innerEl: '.' + Ext.baseCSSPrefix + 'slider-inner',
focusEl: '.' + Ext.baseCSSPrefix + 'slider-focus'
});
me.callParent(arguments);
for (; i < len; i++) {
thumbs[i].render();
}
thumb = me.innerEl.down('.' + Ext.baseCSSPrefix + 'slider-thumb');
me.halfThumb = (me.vertical ? thumb.getHeight() : thumb.getWidth()) / 2;
},
onChange : function(slider, v) {
this.setValue(v, undefined, true);
},
initEvents : function() {
var me = this;
me.mon(me.el, {
scope : me,
mousedown: me.onMouseDown,
keydown : me.onKeyDown,
change : me.onChange
});
me.focusEl.swallowEvent("click", true);
},
onMouseDown : function(e) {
var me = this,
thumbClicked = false,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
local;
if (me.disabled) {
return;
}
for (; i < len; i++) {
thumbClicked = thumbClicked || e.target == thumbs[i].el.dom;
}
if (me.clickToChange && !thumbClicked) {
local = me.innerEl.translatePoints(e.getXY());
me.onClickChange(local);
}
me.focus();
},
onClickChange : function(local) {
var me = this,
thumb, index;
if (local.top > me.clickRange[0] && local.top < me.clickRange[1]) {
thumb = me.getNearest(local, 'left');
if (!thumb.disabled) {
index = thumb.index;
me.setValue(index, Ext.util.Format.round(me.reverseValue(local.left), me.decimalPrecision), undefined, true);
}
}
},
getNearest: function(local, prop) {
var me = this,
localValue = prop == 'top' ? me.innerEl.getHeight() - local[prop] : local[prop],
clickValue = me.reverseValue(localValue),
nearestDistance = (me.maxValue - me.minValue) + 5,
index = 0,
nearest = null,
thumbs = me.thumbs,
i = 0,
len = thumbs.length,
thumb,
value,
dist;
for (; i < len; i++) {
thumb = me.thumbs[i];
value = thumb.value;
dist = Math.abs(value - clickValue);
if (Math.abs(dist <= nearestDistance)) {
nearest = thumb;
index = i;
nearestDistance = dist;
}
}
return nearest;
},
onKeyDown : function(e) {
var me = this,
k,
val;
if(me.disabled || me.thumbs.length !== 1) {
e.preventDefault();
return;
}
k = e.getKey();
switch(k) {
case e.UP:
case e.RIGHT:
e.stopEvent();
val = e.ctrlKey ? me.maxValue : me.getValue(0) + me.keyIncrement;
me.setValue(0, val, undefined, true);
break;
case e.DOWN:
case e.LEFT:
e.stopEvent();
val = e.ctrlKey ? me.minValue : me.getValue(0) - me.keyIncrement;
me.setValue(0, val, undefined, true);
break;
default:
e.preventDefault();
}
},
afterRender : function() {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
thumb,
v;
me.callParent(arguments);
for (; i < len; i++) {
thumb = thumbs[i];
if (thumb.value !== undefined) {
v = me.normalizeValue(thumb.value);
if (v !== thumb.value) {
me.setValue(i, v, false);
} else {
thumb.move(me.translateValue(v), false);
}
}
}
},
getRatio : function() {
var w = this.innerEl.getWidth(),
v = this.maxValue - this.minValue;
return v === 0 ? w : (w/v);
},
normalizeValue : function(v) {
var me = this;
v = Ext.Number.snap(v, this.increment, this.minValue, this.maxValue);
v = Ext.util.Format.round(v, me.decimalPrecision);
v = Ext.Number.constrain(v, me.minValue, me.maxValue);
return v;
},
setMinValue : function(val) {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
t;
me.minValue = val;
me.inputEl.dom.setAttribute('aria-valuemin', val);
for (; i < len; ++i) {
t = thumbs[i];
t.value = t.value < val ? val : t.value;
}
me.syncThumbs();
},
setMaxValue : function(val) {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
t;
me.maxValue = val;
me.inputEl.dom.setAttribute('aria-valuemax', val);
for (; i < len; ++i) {
t = thumbs[i];
t.value = t.value > val ? val : t.value;
}
me.syncThumbs();
},
setValue : function(index, value, animate, changeComplete) {
var me = this,
thumb = me.thumbs[index];
value = me.normalizeValue(value);
if (value !== thumb.value && me.fireEvent('beforechange', me, value, thumb.value, thumb) !== false) {
thumb.value = value;
if (me.rendered) {
me.inputEl.set({
'aria-valuenow': value,
'aria-valuetext': value
});
thumb.move(me.translateValue(value), Ext.isDefined(animate) ? animate !== false : me.animate);
me.fireEvent('change', me, value, thumb);
if (changeComplete) {
me.fireEvent('changecomplete', me, value, thumb);
}
}
}
},
translateValue : function(v) {
var ratio = this.getRatio();
return (v * ratio) - (this.minValue * ratio) - this.halfThumb;
},
reverseValue : function(pos) {
var ratio = this.getRatio();
return (pos + (this.minValue * ratio)) / ratio;
},
focus : function() {
this.focusEl.focus(10);
},
onDisable: function() {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
thumb,
el,
xy;
me.callParent();
for (; i < len; i++) {
thumb = thumbs[i];
el = thumb.el;
thumb.disable();
if(Ext.isIE) {
xy = el.getXY();
el.hide();
me.innerEl.addCls(me.disabledCls).dom.disabled = true;
if (!me.thumbHolder) {
me.thumbHolder = me.endEl.createChild({cls: Ext.baseCSSPrefix + 'slider-thumb ' + me.disabledCls});
}
me.thumbHolder.show().setXY(xy);
}
}
},
onEnable: function() {
var me = this,
i = 0,
thumbs = me.thumbs,
len = thumbs.length,
thumb,
el;
this.callParent();
for (; i < len; i++) {
thumb = thumbs[i];
el = thumb.el;
thumb.enable();
if (Ext.isIE) {
me.innerEl.removeCls(me.disabledCls).dom.disabled = false;
if (me.thumbHolder) {
me.thumbHolder.hide();
}
el.show();
me.syncThumbs();
}
}
},
syncThumbs : function() {
if (this.rendered) {
var thumbs = this.thumbs,
length = thumbs.length,
i = 0;
for (; i < length; i++) {
thumbs[i].move(this.translateValue(thumbs[i].value));
}
}
},
getValue : function(index) {
return Ext.isNumber(index) ? this.thumbs[index].value : this.getValues();
},
getValues: function() {
var values = [],
i = 0,
thumbs = this.thumbs,
len = thumbs.length;
for (; i < len; i++) {
values.push(thumbs[i].value);
}
return values;
},
getSubmitValue: function() {
var me = this;
return (me.disabled || !me.submitValue) ? null : me.getValue();
},
reset: function() {
var me = this,
Array = Ext.Array;
Array.forEach(Array.from(me.originalValue), function(val, i) {
me.setValue(i, val);
});
me.clearInvalid();
delete me.wasValid;
},
beforeDestroy : function() {
var me = this;
Ext.destroyMembers(me.innerEl, me.endEl, me.focusEl);
Ext.each(me.thumbs, function(thumb) {
Ext.destroy(thumb);
}, me);
me.callParent();
},
statics: {
Vertical: {
getRatio : function() {
var h = this.innerEl.getHeight(),
v = this.maxValue - this.minValue;
return h/v;
},
onClickChange : function(local) {
var me = this,
thumb, index, bottom;
if (local.left > me.clickRange[0] && local.left < me.clickRange[1]) {
thumb = me.getNearest(local, 'top');
if (!thumb.disabled) {
index = thumb.index;
bottom = me.reverseValue(me.innerEl.getHeight() - local.top);
me.setValue(index, Ext.util.Format.round(me.minValue + bottom, me.decimalPrecision), undefined, true);
}
}
}
}
}
});
Ext.define('Ext.slider.Single', {
extend: 'Ext.slider.Multi',
alias: ['widget.slider', 'widget.sliderfield'],
alternateClassName: ['Ext.Slider', 'Ext.form.SliderField', 'Ext.slider.SingleSlider', 'Ext.slider.Slider'],
getValue: function() {
return this.callParent([0]);
},
setValue: function(value, animate) {
var args = Ext.toArray(arguments),
len = args.length;
if (len == 1 || (len <= 3 && typeof arguments[1] != 'number')) {
args.unshift(0);
}
return this.callParent(args);
},
getNearest : function(){
return this.thumbs[0];
}
});
Ext.define('Ext.tab.Tab', {
extend: 'Ext.button.Button',
alias: 'widget.tab',
requires: [
'Ext.layout.component.Tab',
'Ext.util.KeyNav'
],
componentLayout: 'tab',
isTab: true,
baseCls: Ext.baseCSSPrefix + 'tab',
activeCls: 'active',
closableCls: 'closable',
closable: true,
closeText: 'Close Tab',
active: false,
scale: false,
position: 'top',
initComponent: function() {
var me = this;
me.addEvents(
'activate',
'deactivate',
'beforeclose',
'close'
);
me.callParent(arguments);
if (me.card) {
me.setCard(me.card);
}
},
onRender: function() {
var me = this;
me.addClsWithUI(me.position);
me.syncClosableUI();
me.callParent(arguments);
if (me.active) {
me.activate(true);
}
me.syncClosableElements();
me.keyNav = Ext.create('Ext.util.KeyNav', me.el, {
enter: me.onEnterKey,
del: me.onDeleteKey,
scope: me
});
},
enable : function(silent) {
var me = this;
me.callParent(arguments);
me.removeClsWithUI(me.position + '-disabled');
return me;
},
disable : function(silent) {
var me = this;
me.callParent(arguments);
me.addClsWithUI(me.position + '-disabled');
return me;
},
onDestroy: function() {
var me = this;
if (me.closeEl) {
me.closeEl.un('click', Ext.EventManager.preventDefault);
me.closeEl = null;
}
Ext.destroy(me.keyNav);
delete me.keyNav;
me.callParent(arguments);
},
setClosable: function(closable) {
var me = this;
closable = (!arguments.length || !!closable);
if (me.closable != closable) {
me.closable = closable;
if (me.card) {
me.card.closable = closable;
}
me.syncClosableUI();
if (me.rendered) {
me.syncClosableElements();
me.doComponentLayout();
if (me.ownerCt) {
me.ownerCt.doLayout();
}
}
}
},
syncClosableElements: function () {
var me = this;
if (me.closable) {
if (!me.closeEl) {
me.closeEl = me.el.createChild({
tag: 'a',
cls: me.baseCls + '-close-btn',
href: '#',
title: me.closeText
}).on('click', Ext.EventManager.preventDefault);
}
} else {
var closeEl = me.closeEl;
if (closeEl) {
closeEl.un('click', Ext.EventManager.preventDefault);
closeEl.remove();
me.closeEl = null;
}
}
},
syncClosableUI: function () {
var me = this, classes = [me.closableCls, me.closableCls + '-' + me.position];
if (me.closable) {
me.addClsWithUI(classes);
} else {
me.removeClsWithUI(classes);
}
},
setCard: function(card) {
var me = this;
me.card = card;
me.setText(me.title || card.title);
me.setIconCls(me.iconCls || card.iconCls);
},
onCloseClick: function() {
var me = this;
if (me.fireEvent('beforeclose', me) !== false) {
if (me.tabBar) {
if (me.tabBar.closeTab(me) === false) {
return;
}
} else {
me.fireEvent('close', me);
}
}
},
fireClose: function(){
this.fireEvent('close', this);
},
onEnterKey: function(e) {
var me = this;
if (me.tabBar) {
me.tabBar.onClick(e, me.el);
}
},
onDeleteKey: function(e) {
var me = this;
if (me.closable) {
me.onCloseClick();
}
},
activate : function(supressEvent) {
var me = this;
me.active = true;
me.addClsWithUI([me.activeCls, me.position + '-' + me.activeCls]);
if (supressEvent !== true) {
me.fireEvent('activate', me);
}
},
deactivate : function(supressEvent) {
var me = this;
me.active = false;
me.removeClsWithUI([me.activeCls, me.position + '-' + me.activeCls]);
if (supressEvent !== true) {
me.fireEvent('deactivate', me);
}
}
});
Ext.define('Ext.tab.Bar', {
extend: 'Ext.panel.Header',
alias: 'widget.tabbar',
baseCls: Ext.baseCSSPrefix + 'tab-bar',
requires: [
'Ext.tab.Tab',
'Ext.FocusManager'
],
defaultType: 'tab',
plain: false,
renderTpl: [
' {baseCls}-body-{ui} {parent.baseCls}-body-{parent.ui}-{.} " style="{bodyStyle}" >
',
' {baseCls}-strip-{ui} {parent.baseCls}-strip-{parent.ui}-{.} ">
'
],
minTabWidth: 30,
maxTabWidth: undefined,
initComponent: function() {
var me = this,
keys;
if (me.plain) {
me.setUI(me.ui + '-plain');
}
me.addClsWithUI(me.dock);
me.addEvents(
'change'
);
Ext.applyIf(me.renderSelectors, {
body : '.' + me.baseCls + '-body',
strip: '.' + me.baseCls + '-strip'
});
me.callParent(arguments);
me.layout.align = (me.orientation == 'vertical') ? 'left' : 'top';
me.layout.overflowHandler = Ext.create('Ext.layout.container.boxOverflow.Scroller', me.layout);
me.items.removeAt(me.items.getCount() - 1);
me.items.removeAt(me.items.getCount() - 1);
keys = me.orientation == 'vertical' ? ['up', 'down'] : ['left', 'right'];
Ext.FocusManager.subscribe(me, {
keys: keys
});
},
onAdd: function(tab) {
var me = this,
tabPanel = me.tabPanel,
hasOwner = !!tabPanel;
me.callParent(arguments);
tab.position = me.dock;
if (hasOwner) {
tab.minWidth = tabPanel.minTabWidth;
}
else {
tab.minWidth = me.minTabWidth + (tab.iconCls ? 25 : 0);
}
tab.maxWidth = me.maxTabWidth || (hasOwner ? tabPanel.maxTabWidth : undefined);
},
afterRender: function() {
var me = this;
me.mon(me.el, {
scope: me,
click: me.onClick,
delegate: '.' + Ext.baseCSSPrefix + 'tab'
});
me.callParent(arguments);
},
afterComponentLayout : function() {
var me = this;
me.callParent(arguments);
me.strip.setWidth(me.el.getWidth());
},
onClick: function(e, target) {
var tab = Ext.getCmp(target.id),
tabPanel = this.tabPanel,
allowActive = true;
target = e.getTarget();
if (tab && tab.isDisabled && !tab.isDisabled()) {
if (tab.closable && target === tab.closeEl.dom) {
tab.onCloseClick();
} else {
if (tabPanel) {
tabPanel.setActiveTab(tab.card);
} else {
this.setActiveTab(tab);
}
tab.focus();
}
}
},
closeTab: function(tab) {
var me = this,
card = tab.card,
tabPanel = me.tabPanel,
nextTab;
if (card && card.fireEvent('beforeclose', card) === false) {
return false;
}
if (tab.active && me.items.getCount() > 1) {
nextTab = tab.next('tab') || me.items.items[0];
me.setActiveTab(nextTab);
if (tabPanel) {
tabPanel.setActiveTab(nextTab.card);
}
}
tab.fireClose();
me.remove(tab);
if (tabPanel && card) {
card.fireEvent('close', card);
tabPanel.remove(card);
}
if (nextTab) {
nextTab.focus();
}
},
setActiveTab: function(tab) {
if (tab.disabled) {
return;
}
var me = this;
if (me.activeTab) {
me.activeTab.deactivate();
}
tab.activate();
if (me.rendered) {
me.layout.layout();
tab.el.scrollIntoView(me.layout.getRenderTarget());
}
me.activeTab = tab;
me.fireEvent('change', me, tab, tab.card);
}
});
Ext.define('Ext.tab.Panel', {
extend: 'Ext.panel.Panel',
alias: 'widget.tabpanel',
alternateClassName: ['Ext.TabPanel'],
requires: ['Ext.layout.container.Card', 'Ext.tab.Bar'],
tabPosition : 'top',
removePanelHeader: true,
plain: false,
itemCls: 'x-tabpanel-child',
deferredRender : true,
initComponent: function() {
var me = this,
dockedItems = me.dockedItems || [],
activeTab = me.activeTab || 0;
me.layout = Ext.create('Ext.layout.container.Card', Ext.apply({
owner: me,
deferredRender: me.deferredRender,
itemCls: me.itemCls
}, me.layout));
me.tabBar = Ext.create('Ext.tab.Bar', Ext.apply({}, me.tabBar, {
dock: me.tabPosition,
plain: me.plain,
border: me.border,
cardLayout: me.layout,
tabPanel: me
}));
if (dockedItems && !Ext.isArray(dockedItems)) {
dockedItems = [dockedItems];
}
dockedItems.push(me.tabBar);
me.dockedItems = dockedItems;
me.addEvents(
'beforetabchange',
'tabchange'
);
me.callParent(arguments);
me.setActiveTab(activeTab);
me.on('afterlayout', me.afterInitialLayout, me, {single: true});
},
afterInitialLayout: function() {
var me = this,
card = me.getComponent(me.activeTab);
if (card) {
me.layout.setActiveItem(card);
}
},
setActiveTab: function(card) {
var me = this,
previous;
card = me.getComponent(card);
if (card) {
previous = me.getActiveTab();
if (previous && previous !== card && me.fireEvent('beforetabchange', me, card, previous) === false) {
return false;
}
me.tabBar.setActiveTab(card.tab);
me.activeTab = card;
if (me.rendered) {
me.layout.setActiveItem(card);
}
if (previous && previous !== card) {
me.fireEvent('tabchange', me, card, previous);
}
}
},
getActiveTab: function() {
return this.activeTab;
},
getTabBar: function() {
return this.tabBar;
},
onAdd: function(item, index) {
var me = this,
cfg = item.tabConfig || {},
defaultConfig = {
xtype: 'tab',
card: item,
disabled: item.disabled,
closable: item.closable,
hidden: item.hidden,
tabBar: me.tabBar
};
if (item.closeText) {
defaultConfig.closeText = item.closeText;
}
cfg = Ext.applyIf(cfg, defaultConfig);
item.tab = me.tabBar.insert(index, cfg);
item.on({
scope : me,
enable: me.onItemEnable,
disable: me.onItemDisable,
beforeshow: me.onItemBeforeShow,
iconchange: me.onItemIconChange,
titlechange: me.onItemTitleChange
});
if (item.isPanel) {
if (me.removePanelHeader) {
item.preventHeader = true;
if (item.rendered) {
item.updateHeader();
}
}
if (item.isPanel && me.border) {
item.setBorder(false);
}
}
if (this.rendered && me.items.getCount() === 1) {
me.setActiveTab(0);
}
},
onItemEnable: function(item){
item.tab.enable();
},
onItemDisable: function(item){
item.tab.disable();
},
onItemBeforeShow: function(item) {
if (item !== this.activeTab) {
this.setActiveTab(item);
return false;
}
},
onItemIconChange: function(item, newIconCls) {
item.tab.setIconCls(newIconCls);
this.getTabBar().doLayout();
},
onItemTitleChange: function(item, newTitle) {
item.tab.setText(newTitle);
this.getTabBar().doLayout();
},
doRemove: function(item, autoDestroy) {
var me = this,
items = me.items,
hasItemsLeft = items.getCount() > 1;
if (me.destroying || !hasItemsLeft) {
me.activeTab = null;
} else if (item === me.activeTab) {
me.setActiveTab(item.next() || items.getAt(0));
}
me.callParent(arguments);
delete item.tab.card;
delete item.tab;
},
onRemove: function(item, autoDestroy) {
var me = this;
item.un({
scope : me,
enable: me.onItemEnable,
disable: me.onItemDisable,
beforeshow: me.onItemBeforeShow
});
if (!me.destroying && item.tab.ownerCt == me.tabBar) {
me.tabBar.remove(item.tab);
}
}
});
Ext.define('Ext.toolbar.Spacer', {
extend: 'Ext.Component',
alias: 'widget.tbspacer',
alternateClassName: 'Ext.Toolbar.Spacer',
baseCls: Ext.baseCSSPrefix + 'toolbar-spacer',
focusable: false
});
Ext.define('Ext.tree.Column', {
extend: 'Ext.grid.column.Column',
alias: 'widget.treecolumn',
initComponent: function() {
var origRenderer = this.renderer || this.defaultRenderer,
origScope = this.scope || window;
this.renderer = function(value, metaData, record, rowIdx, colIdx, store, view) {
var buf = [],
format = Ext.String.format,
depth = record.getDepth(),
treePrefix = Ext.baseCSSPrefix + 'tree-',
elbowPrefix = treePrefix + 'elbow-',
expanderCls = treePrefix + 'expander',
imgText = '{2} ', href, target, formattedValue);
}
if (cls) {
metaData.tdCls += ' ' + cls;
}
return buf.join("") + formattedValue;
};
this.callParent(arguments);
},
defaultRenderer: function(value) {
return value;
}
});
Ext.define('Ext.tree.View', {
extend: 'Ext.view.Table',
alias: 'widget.treeview',
loadingCls: Ext.baseCSSPrefix + 'grid-tree-loading',
expandedCls: Ext.baseCSSPrefix + 'grid-tree-node-expanded',
expanderSelector: '.' + Ext.baseCSSPrefix + 'tree-expander',
checkboxSelector: '.' + Ext.baseCSSPrefix + 'tree-checkbox',
expanderIconOverCls: Ext.baseCSSPrefix + 'tree-expander-over',
blockRefresh: true,
rootVisible: true,
expandDuration: 250,
collapseDuration: 250,
toggleOnDblClick: true,
initComponent: function() {
var me = this;
if (me.initialConfig.animate === undefined) {
me.animate = Ext.enableFx;
}
me.store = Ext.create('Ext.data.NodeStore', {
recursive: true,
rootVisible: me.rootVisible,
listeners: {
beforeexpand: me.onBeforeExpand,
expand: me.onExpand,
beforecollapse: me.onBeforeCollapse,
collapse: me.onCollapse,
scope: me
}
});
if (me.node) {
me.setRootNode(me.node);
}
me.animQueue = {};
me.callParent(arguments);
},
onClear: function(){
this.store.removeAll();
},
setRootNode: function(node) {
var me = this;
me.store.setNode(node);
me.node = node;
if (!me.rootVisible) {
node.expand();
}
},
onRender: function() {
var me = this,
opts = {delegate: me.expanderSelector},
el;
me.callParent(arguments);
el = me.el;
el.on({
scope: me,
delegate: me.expanderSelector,
mouseover: me.onExpanderMouseOver,
mouseout: me.onExpanderMouseOut
});
el.on({
scope: me,
delegate: me.checkboxSelector,
click: me.onCheckboxChange
});
},
onCheckboxChange: function(e, t) {
var item = e.getTarget(this.getItemSelector(), this.getTargetEl()),
record, value;
if (item) {
record = this.getRecord(item);
value = !record.get('checked');
record.set('checked', value);
this.fireEvent('checkchange', record, value);
}
},
getChecked: function() {
var checked = [];
this.node.cascadeBy(function(rec){
if (rec.get('checked')) {
checked.push(rec);
}
});
return checked;
},
isItemChecked: function(rec){
return rec.get('checked');
},
createAnimWrap: function(record, index) {
var thHtml = '',
headerCt = this.panel.headerCt,
headers = headerCt.getGridColumns(),
i = 0, len = headers.length, item,
node = this.getNode(record),
tmpEl, nodeEl;
for (; i < len; i++) {
item = headers[i];
thHtml += '',
'',
' '
].join('')
}, 'after');
return {
record: record,
node: node,
el: tmpEl,
expanding: false,
collapsing: false,
animating: false,
animateEl: tmpEl.down('div'),
targetEl: tmpEl.down('tbody')
};
},
getAnimWrap: function(parent) {
if (!this.animate) {
return null;
}
while (parent) {
if (parent.animWrap) {
return parent.animWrap;
}
parent = parent.parentNode;
}
return null;
},
doAdd: function(nodes, records, index) {
var me = this,
record = records[0],
parent = record.parentNode,
a = me.all.elements,
relativeIndex = 0,
animWrap = me.getAnimWrap(parent),
targetEl, children, len;
if (!animWrap || !animWrap.expanding) {
me.resetScrollers();
return me.callParent(arguments);
}
parent = animWrap.record;
targetEl = animWrap.targetEl;
children = targetEl.dom.childNodes;
len = children.length - 1;
relativeIndex = index - me.indexOf(parent) - 1;
if (!len || relativeIndex >= len) {
targetEl.appendChild(nodes);
}
else {
Ext.fly(children[relativeIndex + 1]).insertSibling(nodes, 'before', true);
}
Ext.Array.insert(a, index, nodes);
if (animWrap.isAnimating) {
me.onExpand(parent);
}
},
doRemove: function(record, index) {
var me = this,
parent = record.parentNode,
all = me.all,
animWrap = me.getAnimWrap(record),
node = all.item(index).dom;
if (!animWrap || !animWrap.collapsing) {
me.resetScrollers();
return me.callParent(arguments);
}
animWrap.targetEl.appendChild(node);
all.removeElement(index);
},
onBeforeExpand: function(parent, records, index) {
var me = this,
animWrap;
if (!me.rendered || !me.animate) {
return;
}
if (me.getNode(parent)) {
animWrap = me.getAnimWrap(parent);
if (!animWrap) {
animWrap = parent.animWrap = me.createAnimWrap(parent);
animWrap.animateEl.setHeight(0);
}
else if (animWrap.collapsing) {
animWrap.targetEl.select(me.itemSelector).remove();
}
animWrap.expanding = true;
animWrap.collapsing = false;
}
},
onExpand: function(parent) {
var me = this,
queue = me.animQueue,
id = parent.getId(),
animWrap,
animateEl,
targetEl,
queueItem;
if (me.singleExpand) {
me.ensureSingleExpand(parent);
}
animWrap = me.getAnimWrap(parent);
if (!animWrap) {
me.resetScrollers();
return;
}
animateEl = animWrap.animateEl;
targetEl = animWrap.targetEl;
animateEl.stopAnimation();
queue[id] = true;
animateEl.slideIn('t', {
duration: me.expandDuration,
listeners: {
scope: me,
lastframe: function() {
animWrap.el.insertSibling(targetEl.query(me.itemSelector), 'before');
animWrap.el.remove();
me.resetScrollers();
delete animWrap.record.animWrap;
delete queue[id];
}
}
});
animWrap.isAnimating = true;
},
resetScrollers: function(){
var panel = this.panel;
panel.determineScrollbars();
panel.invalidateScroller();
},
onBeforeCollapse: function(parent, records, index) {
var me = this,
animWrap;
if (!me.rendered || !me.animate) {
return;
}
if (me.getNode(parent)) {
animWrap = me.getAnimWrap(parent);
if (!animWrap) {
animWrap = parent.animWrap = me.createAnimWrap(parent, index);
}
else if (animWrap.expanding) {
animWrap.targetEl.select(this.itemSelector).remove();
}
animWrap.expanding = false;
animWrap.collapsing = true;
}
},
onCollapse: function(parent) {
var me = this,
queue = me.animQueue,
id = parent.getId(),
animWrap = me.getAnimWrap(parent),
animateEl, targetEl;
if (!animWrap) {
me.resetScrollers();
return;
}
animateEl = animWrap.animateEl;
targetEl = animWrap.targetEl;
queue[id] = true;
animateEl.stopAnimation();
animateEl.slideOut('t', {
duration: me.collapseDuration,
listeners: {
scope: me,
lastframe: function() {
animWrap.el.remove();
delete animWrap.record.animWrap;
me.resetScrollers();
delete queue[id];
}
}
});
animWrap.isAnimating = true;
},
isAnimating: function(node) {
return !!this.animQueue[node.getId()];
},
collectData: function(records) {
var data = this.callParent(arguments),
rows = data.rows,
len = rows.length,
i = 0,
row, record;
for (; i < len; i++) {
row = rows[i];
record = records[i];
if (record.get('qtip')) {
row.rowAttr = 'data-qtip="' + record.get('qtip') + '"';
if (record.get('qtitle')) {
row.rowAttr += ' ' + 'data-qtitle="' + record.get('qtitle') + '"';
}
}
if (record.isExpanded()) {
row.rowCls = (row.rowCls || '') + ' ' + this.expandedCls;
}
if (record.isLoading()) {
row.rowCls = (row.rowCls || '') + ' ' + this.loadingCls;
}
}
return data;
},
expand: function(record, deep, callback, scope) {
return record.expand(deep, callback, scope);
},
collapse: function(record, deep, callback, scope) {
return record.collapse(deep, callback, scope);
},
toggle: function(record) {
this[record.isExpanded() ? 'collapse' : 'expand'](record);
},
onItemDblClick: function(record, item, index) {
this.callParent(arguments);
if (this.toggleOnDblClick) {
this.toggle(record);
}
},
onBeforeItemMouseDown: function(record, item, index, e) {
if (e.getTarget(this.expanderSelector, item)) {
return false;
}
return this.callParent(arguments);
},
onItemClick: function(record, item, index, e) {
if (e.getTarget(this.expanderSelector, item)) {
this.toggle(record);
return false;
}
return this.callParent(arguments);
},
onExpanderMouseOver: function(e, t) {
e.getTarget(this.cellSelector, 10, true).addCls(this.expanderIconOverCls);
},
onExpanderMouseOut: function(e, t) {
e.getTarget(this.cellSelector, 10, true).removeCls(this.expanderIconOverCls);
},
getTreeStore: function() {
return this.panel.store;
},
ensureSingleExpand: function(node) {
var parent = node.parentNode;
if (parent) {
parent.eachChild(function(child) {
if (child !== node && child.isExpanded()) {
child.collapse();
}
});
}
}
});
Ext.define('Ext.tree.Panel', {
extend: 'Ext.panel.Table',
alias: 'widget.treepanel',
alternateClassName: ['Ext.tree.TreePanel', 'Ext.TreePanel'],
requires: ['Ext.tree.View', 'Ext.selection.TreeModel', 'Ext.tree.Column'],
viewType: 'treeview',
selType: 'treemodel',
treeCls: Ext.baseCSSPrefix + 'tree-panel',
deferRowRender: false,
lines: true,
useArrows: false,
singleExpand: false,
ddConfig: {
enableDrag: true,
enableDrop: true
},
rootVisible: true,
displayField: 'text',
root: null,
normalCfgCopy: ['displayField', 'root', 'singleExpand', 'useArrows', 'lines', 'rootVisible', 'scroll'],
lockedCfgCopy: ['displayField', 'root', 'singleExpand', 'useArrows', 'lines', 'rootVisible'],
constructor: function(config) {
config = config || {};
if (config.animate === undefined) {
config.animate = Ext.enableFx;
}
this.enableAnimations = config.animate;
delete config.animate;
this.callParent([config]);
},
initComponent: function() {
var me = this,
cls = [me.treeCls];
if (me.useArrows) {
cls.push(Ext.baseCSSPrefix + 'tree-arrows');
me.lines = false;
}
if (me.lines) {
cls.push(Ext.baseCSSPrefix + 'tree-lines');
} else if (!me.useArrows) {
cls.push(Ext.baseCSSPrefix + 'tree-no-lines');
}
if (Ext.isString(me.store)) {
me.store = Ext.StoreMgr.lookup(me.store);
} else if (!me.store || Ext.isObject(me.store) && !me.store.isStore) {
me.store = Ext.create('Ext.data.TreeStore', Ext.apply({}, me.store || {}, {
root: me.root,
fields: me.fields,
model: me.model,
folderSort: me.folderSort
}));
} else if (me.root) {
me.store = Ext.data.StoreManager.lookup(me.store);
me.store.setRootNode(me.root);
if (me.folderSort !== undefined) {
me.store.folderSort = me.folderSort;
me.store.sort();
}
}
me.viewConfig = Ext.applyIf(me.viewConfig || {}, {
rootVisible: me.rootVisible,
animate: me.enableAnimations,
singleExpand: me.singleExpand,
node: me.store.getRootNode(),
hideHeaders: me.hideHeaders
});
me.mon(me.store, {
scope: me,
rootchange: me.onRootChange,
clear: me.onClear
});
me.relayEvents(me.store, [
'beforeload',
'load'
]);
me.store.on({
append: me.createRelayer('itemappend'),
remove: me.createRelayer('itemremove'),
move: me.createRelayer('itemmove'),
insert: me.createRelayer('iteminsert'),
beforeappend: me.createRelayer('beforeitemappend'),
beforeremove: me.createRelayer('beforeitemremove'),
beforemove: me.createRelayer('beforeitemmove'),
beforeinsert: me.createRelayer('beforeiteminsert'),
expand: me.createRelayer('itemexpand'),
collapse: me.createRelayer('itemcollapse'),
beforeexpand: me.createRelayer('beforeitemexpand'),
beforecollapse: me.createRelayer('beforeitemcollapse')
});
if (!me.columns) {
if (me.initialConfig.hideHeaders === undefined) {
me.hideHeaders = true;
}
me.columns = [{
xtype : 'treecolumn',
text : 'Name',
flex : 1,
dataIndex: me.displayField
}];
}
if (me.cls) {
cls.push(me.cls);
}
me.cls = cls.join(' ');
me.callParent();
me.relayEvents(me.getView(), [
'checkchange'
]);
if (!me.getView().rootVisible && !me.getRootNode()) {
me.setRootNode({
expanded: true
});
}
},
onClear: function(){
this.view.onClear();
},
setRootNode: function() {
return this.store.setRootNode.apply(this.store, arguments);
},
getRootNode: function() {
return this.store.getRootNode();
},
onRootChange: function(root) {
this.view.setRootNode(root);
},
getChecked: function() {
return this.getView().getChecked();
},
isItemChecked: function(rec) {
return rec.get('checked');
},
expandAll : function(callback, scope) {
var root = this.getRootNode();
if (root) {
root.expand(true, callback, scope);
}
},
collapseAll : function(callback, scope) {
var root = this.getRootNode();
if (root) {
if (this.getView().rootVisible) {
root.collapse(true, callback, scope);
}
else {
root.collapseChildren(true, callback, scope);
}
}
},
expandPath: function(path, field, separator, callback, scope) {
var me = this,
current = me.getRootNode(),
index = 1,
view = me.getView(),
keys,
expander;
field = field || me.getRootNode().idProperty;
separator = separator || '/';
if (Ext.isEmpty(path)) {
Ext.callback(callback, scope || me, [false, null]);
return;
}
keys = path.split(separator);
if (current.get(field) != keys[1]) {
Ext.callback(callback, scope || me, [false, current]);
return;
}
expander = function(){
if (++index === keys.length) {
Ext.callback(callback, scope || me, [true, current]);
return;
}
var node = current.findChild(field, keys[index]);
if (!node) {
Ext.callback(callback, scope || me, [false, current]);
return;
}
current = node;
current.expand(false, expander);
};
current.expand(false, expander);
},
selectPath: function(path, field, separator, callback, scope) {
var me = this,
keys,
last;
field = field || me.getRootNode().idProperty;
separator = separator || '/';
keys = path.split(separator);
last = keys.pop();
me.expandPath(keys.join(separator), field, separator, function(success, node){
var doSuccess = false;
if (success && node) {
node = node.findChild(field, last);
if (node) {
me.getSelectionModel().select(node);
Ext.callback(callback, scope || me, [true, node]);
doSuccess = true;
}
} else if (node === me.getRootNode()) {
doSuccess = true;
}
Ext.callback(callback, scope || me, [doSuccess, node]);
}, me);
}
});
Ext.define('Ext.view.DragZone', {
extend: 'Ext.dd.DragZone',
containerScroll: false,
constructor: function(config) {
var me = this;
Ext.apply(me, config);
if (!me.ddGroup) {
me.ddGroup = 'view-dd-zone-' + me.view.id;
}
me.callParent([me.view.el.dom.parentNode]);
me.ddel = Ext.get(document.createElement('div'));
me.ddel.addCls(Ext.baseCSSPrefix + 'grid-dd-wrap');
},
init: function(id, sGroup, config) {
this.initTarget(id, sGroup, config);
this.view.mon(this.view, {
itemmousedown: this.onItemMouseDown,
scope: this
});
},
onItemMouseDown: function(view, record, item, index, e) {
if (!this.isPreventDrag(e, record, item, index)) {
this.handleMouseDown(e);
if (view.getSelectionModel().selectionMode == 'MULTI' && !e.ctrlKey && view.getSelectionModel().isSelected(record)) {
return false;
}
}
},
isPreventDrag: function(e) {
return false;
},
getDragData: function(e) {
var view = this.view,
item = e.getTarget(view.getItemSelector()),
record, selectionModel, records;
if (item) {
record = view.getRecord(item);
selectionModel = view.getSelectionModel();
records = selectionModel.getSelection();
return {
copy: this.view.copy || (this.view.allowCopy && e.ctrlKey),
event: new Ext.EventObjectImpl(e),
view: view,
ddel: this.ddel,
item: item,
records: records,
fromPosition: Ext.fly(item).getXY()
};
}
},
onInitDrag: function(x, y) {
var me = this,
data = me.dragData,
view = data.view,
selectionModel = view.getSelectionModel(),
record = view.getRecord(data.item),
e = data.event;
if (!selectionModel.isSelected(record) || e.hasModifier()) {
selectionModel.selectWithEvent(record, e, true);
}
data.records = selectionModel.getSelection();
me.ddel.update(me.getDragText());
me.proxy.update(me.ddel.dom);
me.onStartDrag(x, y);
return true;
},
getDragText: function() {
var count = this.dragData.records.length;
return Ext.String.format(this.dragText, count, count == 1 ? '' : 's');
},
getRepairXY : function(e, data){
return data ? data.fromPosition : false;
}
});
Ext.define('Ext.tree.ViewDragZone', {
extend: 'Ext.view.DragZone',
isPreventDrag: function(e, record) {
return (record.get('allowDrag') === false) || !!e.getTarget(this.view.expanderSelector);
},
afterRepair: function() {
var me = this,
view = me.view,
selectedRowCls = view.selectedItemCls,
records = me.dragData.records,
fly = Ext.fly;
if (Ext.enableFx && me.repairHighlight) {
Ext.Array.forEach(records, function(record) {
var item = view.getNode(record);
fly(item.firstChild).highlight(me.repairHighlightColor, {
listeners: {
beforeanimate: function() {
if (view.isSelected(item)) {
fly(item).removeCls(selectedRowCls);
}
},
afteranimate: function() {
if (view.isSelected(item)) {
fly(item).addCls(selectedRowCls);
}
}
}
});
});
}
me.dragging = false;
}
});
Ext.define('Ext.tree.ViewDropZone', {
extend: 'Ext.view.DropZone',
allowParentInserts: false,
allowContainerDrops: false,
appendOnly: false,
expandDelay : 500,
indicatorCls: 'x-tree-ddindicator',
expandNode : function(node) {
var view = this.view;
if (!node.isLeaf() && !node.isExpanded()) {
view.expand(node);
this.expandProcId = false;
}
},
queueExpand : function(node) {
this.expandProcId = Ext.Function.defer(this.expandNode, this.expandDelay, this, [node]);
},
cancelExpand : function() {
if (this.expandProcId) {
clearTimeout(this.expandProcId);
this.expandProcId = false;
}
},
getPosition: function(e, node) {
var view = this.view,
record = view.getRecord(node),
y = e.getPageY(),
noAppend = record.isLeaf(),
noBelow = false,
region = Ext.fly(node).getRegion(),
fragment;
if (record.isRoot()) {
return 'append';
}
if (this.appendOnly) {
return noAppend ? false : 'append';
}
if (!this.allowParentInsert) {
noBelow = record.hasChildNodes() && record.isExpanded();
}
fragment = (region.bottom - region.top) / (noAppend ? 2 : 3);
if (y >= region.top && y < (region.top + fragment)) {
return 'before';
}
else if (!noBelow && (noAppend || (y >= (region.bottom - fragment) && y <= region.bottom))) {
return 'after';
}
else {
return 'append';
}
},
isValidDropPoint : function(node, position, dragZone, e, data) {
if (!node || !data.item) {
return false;
}
var view = this.view,
targetNode = view.getRecord(node),
draggedRecords = data.records,
dataLength = draggedRecords.length,
ln = draggedRecords.length,
i, record;
if (!(targetNode && position && dataLength)) {
return false;
}
for (i = 0; i < ln; i++) {
record = draggedRecords[i];
if (record.isNode && record.contains(targetNode)) {
return false;
}
}
if (position === 'append' && targetNode.get('allowDrop') === false) {
return false;
}
else if (position != 'append' && targetNode.parentNode.get('allowDrop') === false) {
return false;
}
if (Ext.Array.contains(draggedRecords, targetNode)) {
return false;
}
return true;
},
onNodeOver : function(node, dragZone, e, data) {
var position = this.getPosition(e, node),
returnCls = this.dropNotAllowed,
view = this.view,
targetNode = view.getRecord(node),
indicator = this.getIndicator(),
indicatorX = 0,
indicatorY = 0;
this.cancelExpand();
if (position == 'append' && !this.expandProcId && !Ext.Array.contains(data.records, targetNode) && !targetNode.isLeaf() && !targetNode.isExpanded()) {
this.queueExpand(targetNode);
}
if (this.isValidDropPoint(node, position, dragZone, e, data)) {
this.valid = true;
this.currentPosition = position;
this.overRecord = targetNode;
indicator.setWidth(Ext.fly(node).getWidth());
indicatorY = Ext.fly(node).getY() - Ext.fly(view.el).getY() - 1;
if (position == 'before') {
returnCls = targetNode.isFirst() ? Ext.baseCSSPrefix + 'tree-drop-ok-above' : Ext.baseCSSPrefix + 'tree-drop-ok-between';
indicator.showAt(0, indicatorY);
dragZone.proxy.show();
} else if (position == 'after') {
returnCls = targetNode.isLast() ? Ext.baseCSSPrefix + 'tree-drop-ok-below' : Ext.baseCSSPrefix + 'tree-drop-ok-between';
indicatorY += Ext.fly(node).getHeight();
indicator.showAt(0, indicatorY);
dragZone.proxy.show();
} else {
returnCls = Ext.baseCSSPrefix + 'tree-drop-ok-append';
indicator.hide();
}
} else {
this.valid = false;
}
this.currentCls = returnCls;
return returnCls;
},
onContainerOver : function(dd, e, data) {
return e.getTarget('.' + this.indicatorCls) ? this.currentCls : this.dropNotAllowed;
},
notifyOut: function() {
this.callParent(arguments);
this.cancelExpand();
},
handleNodeDrop : function(data, targetNode, position) {
var me = this,
view = me.view,
parentNode = targetNode.parentNode,
store = view.getStore(),
recordDomNodes = [],
records, i, len,
insertionMethod, argList,
needTargetExpand,
transferData,
processDrop;
if (data.copy) {
records = data.records;
data.records = [];
for (i = 0, len = records.length; i < len; i++) {
data.records.push(Ext.apply({}, records[i].data));
}
}
me.cancelExpand();
if (position == 'before') {
insertionMethod = parentNode.insertBefore;
argList = [null, targetNode];
targetNode = parentNode;
}
else if (position == 'after') {
if (targetNode.nextSibling) {
insertionMethod = parentNode.insertBefore;
argList = [null, targetNode.nextSibling];
}
else {
insertionMethod = parentNode.appendChild;
argList = [null];
}
targetNode = parentNode;
}
else {
if (!targetNode.isExpanded()) {
needTargetExpand = true;
}
insertionMethod = targetNode.appendChild;
argList = [null];
}
transferData = function() {
var node;
for (i = 0, len = data.records.length; i < len; i++) {
argList[0] = data.records[i];
node = insertionMethod.apply(targetNode, argList);
if (Ext.enableFx && me.dropHighlight) {
recordDomNodes.push(view.getNode(node));
}
}
if (Ext.enableFx && me.dropHighlight) {
Ext.Array.forEach(recordDomNodes, function(n) {
if (n) {
Ext.fly(n.firstChild ? n.firstChild : n).highlight(me.dropHighlightColor);
}
});
}
};
if (needTargetExpand) {
targetNode.expand(false, transferData);
}
else {
transferData();
}
}
});
Ext.define('Ext.tree.plugin.TreeViewDragDrop', {
extend: 'Ext.AbstractPlugin',
alias: 'plugin.treeviewdragdrop',
uses: [
'Ext.tree.ViewDragZone',
'Ext.tree.ViewDropZone'
],
dragText : '{0} selected node{1}',
allowParentInserts: false,
allowContainerDrops: false,
appendOnly: false,
ddGroup : "TreeDD",
expandDelay : 1000,
enableDrop: true,
enableDrag: true,
nodeHighlightColor: 'c3daf9',
nodeHighlightOnDrop: Ext.enableFx,
nodeHighlightOnRepair: Ext.enableFx,
init : function(view) {
view.on('render', this.onViewRender, this, {single: true});
},
destroy: function() {
Ext.destroy(this.dragZone, this.dropZone);
},
onViewRender : function(view) {
var me = this;
if (me.enableDrag) {
me.dragZone = Ext.create('Ext.tree.ViewDragZone', {
view: view,
ddGroup: me.dragGroup || me.ddGroup,
dragText: me.dragText,
repairHighlightColor: me.nodeHighlightColor,
repairHighlight: me.nodeHighlightOnRepair
});
}
if (me.enableDrop) {
me.dropZone = Ext.create('Ext.tree.ViewDropZone', {
view: view,
ddGroup: me.dropGroup || me.ddGroup,
allowContainerDrops: me.allowContainerDrops,
appendOnly: me.appendOnly,
allowParentInserts: me.allowParentInserts,
expandDelay: me.expandDelay,
dropHighlightColor: me.nodeHighlightColor,
dropHighlight: me.nodeHighlightOnDrop
});
}
}
});
Ext.define('Ext.util.Cookies', {
singleton: true,
set : function(name, value){
var argv = arguments,
argc = arguments.length,
expires = (argc > 2) ? argv[2] : null,
path = (argc > 3) ? argv[3] : '/',
domain = (argc > 4) ? argv[4] : null,
secure = (argc > 5) ? argv[5] : false;
document.cookie = name + "=" + escape(value) + ((expires === null) ? "" : ("; expires=" + expires.toGMTString())) + ((path === null) ? "" : ("; path=" + path)) + ((domain === null) ? "" : ("; domain=" + domain)) + ((secure === true) ? "; secure" : "");
},
get : function(name){
var arg = name + "=",
alen = arg.length,
clen = document.cookie.length,
i = 0,
j = 0;
while(i < clen){
j = i + alen;
if(document.cookie.substring(i, j) == arg){
return this.getCookieVal(j);
}
i = document.cookie.indexOf(" ", i) + 1;
if(i === 0){
break;
}
}
return null;
},
clear : function(name, path){
if(this.get(name)){
path = path || '/';
document.cookie = name + '=' + '; expires=Thu, 01-Jan-70 00:00:01 GMT; path=' + path;
}
},
getCookieVal : function(offset){
var endstr = document.cookie.indexOf(";", offset);
if(endstr == -1){
endstr = document.cookie.length;
}
return unescape(document.cookie.substring(offset, endstr));
}
});
Ext.define('Ext.util.CSS', function() {
var rules = null;
var doc = document;
var camelRe = /(-[a-z])/gi;
var camelFn = function(m, a){ return a.charAt(1).toUpperCase(); };
return {
singleton: true,
constructor: function() {
this.rules = {};
this.initialized = false;
},
createStyleSheet : function(cssText, id) {
var ss,
head = doc.getElementsByTagName("head")[0],
styleEl = doc.createElement("style");
styleEl.setAttribute("type", "text/css");
if (id) {
styleEl.setAttribute("id", id);
}
if (Ext.isIE) {
head.appendChild(styleEl);
ss = styleEl.styleSheet;
ss.cssText = cssText;
} else {
try{
styleEl.appendChild(doc.createTextNode(cssText));
} catch(e) {
styleEl.cssText = cssText;
}
head.appendChild(styleEl);
ss = styleEl.styleSheet ? styleEl.styleSheet : (styleEl.sheet || doc.styleSheets[doc.styleSheets.length-1]);
}
this.cacheStyleSheet(ss);
return ss;
},
removeStyleSheet : function(id) {
var existing = document.getElementById(id);
if (existing) {
existing.parentNode.removeChild(existing);
}
},
swapStyleSheet : function(id, url) {
var doc = document;
this.removeStyleSheet(id);
var ss = doc.createElement("link");
ss.setAttribute("rel", "stylesheet");
ss.setAttribute("type", "text/css");
ss.setAttribute("id", id);
ss.setAttribute("href", url);
doc.getElementsByTagName("head")[0].appendChild(ss);
},
refreshCache : function() {
return this.getRules(true);
},
cacheStyleSheet : function(ss) {
if(!rules){
rules = {};
}
try {
var ssRules = ss.cssRules || ss.rules,
selectorText,
i = ssRules.length - 1,
j,
selectors;
for (; i >= 0; --i) {
selectorText = ssRules[i].selectorText;
if (selectorText) {
selectorText = selectorText.split(',');
selectors = selectorText.length;
for (j = 0; j < selectors; j++) {
rules[Ext.String.trim(selectorText[j]).toLowerCase()] = ssRules[i];
}
}
}
} catch(e) {}
},
getRules : function(refreshCache) {
if (rules === null || refreshCache) {
rules = {};
var ds = doc.styleSheets,
i = 0,
len = ds.length;
for (; i < len; i++) {
try {
if (!ds[i].disabled) {
this.cacheStyleSheet(ds[i]);
}
} catch(e) {}
}
}
return rules;
},
getRule: function(selector, refreshCache) {
var rs = this.getRules(refreshCache);
if (!Ext.isArray(selector)) {
return rs[selector.toLowerCase()];
}
for (var i = 0; i < selector.length; i++) {
if (rs[selector[i]]) {
return rs[selector[i].toLowerCase()];
}
}
return null;
},
updateRule : function(selector, property, value){
if (!Ext.isArray(selector)) {
var rule = this.getRule(selector);
if (rule) {
rule.style[property.replace(camelRe, camelFn)] = value;
return true;
}
} else {
for (var i = 0; i < selector.length; i++) {
if (this.updateRule(selector[i], property, value)) {
return true;
}
}
}
return false;
}
};
}());
Ext.define('Ext.util.History', {
singleton: true,
alternateClassName: 'Ext.History',
mixins: {
observable: 'Ext.util.Observable'
},
constructor: function() {
var me = this;
me.oldIEMode = Ext.isIE6 || Ext.isIE7 || !Ext.isStrict && Ext.isIE8;
me.iframe = null;
me.hiddenField = null;
me.ready = false;
me.currentToken = null;
},
getHash: function() {
var href = window.location.href,
i = href.indexOf("#");
return i >= 0 ? href.substr(i + 1) : null;
},
doSave: function() {
this.hiddenField.value = this.currentToken;
},
handleStateChange: function(token) {
this.currentToken = token;
this.fireEvent('change', token);
},
updateIFrame: function(token) {
var html = '' +
Ext.util.Format.htmlEncode(token) +
'
';
try {
var doc = this.iframe.contentWindow.document;
doc.open();
doc.write(html);
doc.close();
return true;
} catch (e) {
return false;
}
},
checkIFrame: function () {
var me = this,
contentWindow = me.iframe.contentWindow;
if (!contentWindow || !contentWindow.document) {
Ext.Function.defer(this.checkIFrame, 10, this);
return;
}
var doc = contentWindow.document,
elem = doc.getElementById("state"),
oldToken = elem ? elem.innerText : null,
oldHash = me.getHash();
Ext.TaskManager.start({
run: function () {
var doc = contentWindow.document,
elem = doc.getElementById("state"),
newToken = elem ? elem.innerText : null,
newHash = me.getHash();
if (newToken !== oldToken) {
oldToken = newToken;
me.handleStateChange(newToken);
window.top.location.hash = newToken;
oldHash = newToken;
me.doSave();
} else if (newHash !== oldHash) {
oldHash = newHash;
me.updateIFrame(newHash);
}
},
interval: 50,
scope: me
});
me.ready = true;
me.fireEvent('ready', me);
},
startUp: function () {
var me = this;
me.currentToken = me.hiddenField.value || this.getHash();
if (me.oldIEMode) {
me.checkIFrame();
} else {
var hash = me.getHash();
Ext.TaskManager.start({
run: function () {
var newHash = me.getHash();
if (newHash !== hash) {
hash = newHash;
me.handleStateChange(hash);
me.doSave();
}
},
interval: 50,
scope: me
});
me.ready = true;
me.fireEvent('ready', me);
}
},
fieldId: Ext.baseCSSPrefix + 'history-field',
iframeId: Ext.baseCSSPrefix + 'history-frame',
init: function (onReady, scope) {
var me = this;
if (me.ready) {
Ext.callback(onReady, scope, [me]);
return;
}
if (!Ext.isReady) {
Ext.onReady(function() {
me.init(onReady, scope);
});
return;
}
me.hiddenField = Ext.getDom(me.fieldId);
if (me.oldIEMode) {
me.iframe = Ext.getDom(me.iframeId);
}
me.addEvents(
'ready',
'change'
);
if (onReady) {
me.on('ready', onReady, scope, {single: true});
}
me.startUp();
},
add: function (token, preventDup) {
var me = this;
if (preventDup !== false) {
if (me.getToken() === token) {
return true;
}
}
if (me.oldIEMode) {
return me.updateIFrame(token);
} else {
window.top.location.hash = token;
return true;
}
},
back: function() {
window.history.go(-1);
},
forward: function(){
window.history.go(1);
},
getToken: function() {
return this.ready ? this.currentToken : this.getHash();
}
});
Ext.define('Ext.view.TableChunker', {
singleton: true,
requires: ['Ext.XTemplate'],
metaTableTpl: [
'{[this.openTableWrap()]}',
'',
'',
'',
'{[this.openRows()]}',
'{row}',
'',
'{[this.embedFeature(values, parent, xindex, xcount)]}',
' ',
'{[this.closeRows()]}',
' ',
'
',
'{[this.closeTableWrap()]}'
],
constructor: function() {
Ext.XTemplate.prototype.recurse = function(values, reference) {
return this.apply(reference ? values[reference] : values);
};
},
embedFeature: function(values, parent, x, xcount) {
var tpl = '';
if (!values.disabled) {
tpl = values.getFeatureTpl(values, parent, x, xcount);
}
return tpl;
},
embedFullWidth: function() {
return 'style="width: {fullWidth}px;"';
},
openRows: function() {
return '';
},
closeRows: function() {
return ' ';
},
metaRowTpl: [
'',
'',
'{{id}}
',
' '
],
firstOrLastCls: function(xindex, xcount) {
var cssCls = '';
if (xindex === 1) {
cssCls = Ext.baseCSSPrefix + 'grid-cell-first';
} else if (xindex === xcount) {
cssCls = Ext.baseCSSPrefix + 'grid-cell-last';
}
return cssCls;
},
embedRowCls: function() {
return '{rowCls}';
},
embedRowAttr: function() {
return '{rowAttr}';
},
openTableWrap: function() {
return '';
},
closeTableWrap: function() {
return '';
},
getTableTpl: function(cfg, textOnly) {
var tpl,
tableTplMemberFns = {
openRows: this.openRows,
closeRows: this.closeRows,
embedFeature: this.embedFeature,
embedFullWidth: this.embedFullWidth,
openTableWrap: this.openTableWrap,
closeTableWrap: this.closeTableWrap
},
tplMemberFns = {},
features = cfg.features || [],
ln = features.length,
i = 0,
memberFns = {
embedRowCls: this.embedRowCls,
embedRowAttr: this.embedRowAttr,
firstOrLastCls: this.firstOrLastCls
},
metaRowTpl = Array.prototype.slice.call(this.metaRowTpl, 0),
metaTableTpl;
for (; i < ln; i++) {
if (!features[i].disabled) {
features[i].mutateMetaRowTpl(metaRowTpl);
Ext.apply(memberFns, features[i].getMetaRowTplFragments());
Ext.apply(tplMemberFns, features[i].getFragmentTpl());
Ext.apply(tableTplMemberFns, features[i].getTableFragments());
}
}
metaRowTpl = Ext.create('Ext.XTemplate', metaRowTpl.join(''), memberFns);
cfg.row = metaRowTpl.applyTemplate(cfg);
metaTableTpl = Ext.create('Ext.XTemplate', this.metaTableTpl.join(''), tableTplMemberFns);
tpl = metaTableTpl.applyTemplate(cfg);
if (!textOnly) {
tpl = Ext.create('Ext.XTemplate', tpl, tplMemberFns);
}
return tpl;
}
});