Hello World
'; + handleSaveResults( + service.createMetadata( + new MetadataService.Metadata[] { homePageComponent })[0]); + + // Add component to Home Page Layout and Update + if(homePageLayout.wideComponents==null) + homePageLayout.wideComponents = new ListImportant Post Install Step:
+In order to utilise the features of this tool, you need to permit the tool access to the Salesforce Metadata API. This can be accomplished by adding a Remote Site Setting with this Salesforce Server URL https://{!Host}
+Click the Create Remote Site Setting button to have the tool perform this step for you.
+ +Overview: {!pageOverview}
+Link: {!pageOverviewLinkText}
+ +DEBUG USE ONLY: {!metadataApiException}
+
+
+
\ No newline at end of file
diff --git a/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js b/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js
new file mode 100644
index 0000000..2a76b93
--- /dev/null
+++ b/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js
@@ -0,0 +1,126 @@
+import { LightningElement, track, wire } from 'lwc';
+import retrieveDescribeMetadata from '@salesforce/apex/MetadataBrowserLwcController.retrieveDescribeMetadata';
+import retrieveListMetadata from '@salesforce/apex/MetadataBrowserLwcController.retrieveListMetadata';
+
+export default class MetadataBrowser extends LightningElement {
+ descMetaResult;
+ gridColumns = [
+ {
+ type: 'text',
+ fieldName: 'metadataType',
+ label: 'Metadata Type',
+ }
+ ];
+ @track gridData;
+ @track expandedRows = [];
+
+ get isMetadataListLoaded() {
+ return !(!this.gridColumns) && !(!this.gridData);
+ }
+
+ @wire(retrieveDescribeMetadata, {})
+ wiredDescribeMetadata({ error, data }) {
+ if (data) {
+ this.descMetaResult = JSON.parse(data);
+ console.log(`this.descMetaResult: ${JSON.stringify(this.descMetaResult, null, 4)}`);
+ this.populateGridData();
+ } else if (error) {
+ console.error(error);
+ }
+ }
+
+ populateGridData() {
+ const dataArray = [];
+ console.log('Populating dataArray');
+ this.descMetaResult.metadataObjects.forEach(metadataObj => {
+ dataArray.push({
+ metadataType: metadataObj.xmlName,
+ hasCalledApi: false,
+ inFolder: metadataObj.inFolder,
+ _children: []
+ });
+ });
+ dataArray.sort((itemA, itemB) => {
+ return itemA.metadataType.localeCompare(itemB.metadataType)
+ });
+ this.gridData = dataArray;
+ }
+
+ // connectedCallback() {
+ // console.log('This one has children!');
+ // }
+
+ renderedCallback() {
+ // console.log(`this.isMetadataListLoaded: ${this.isMetadataListLoaded}`);
+ }
+
+ handleToggle(event) {
+ console.log(`event.detail: ${JSON.stringify(event.detail, null, 4)}`);
+ const mdType = event.detail.name;
+ const treeGrid = this.template.querySelector('lightning-tree-grid');
+ const currentExpandedRows = treeGrid.getCurrentExpandedRows();
+ console.log(`currentExpandedRows: ${JSON.stringify(currentExpandedRows, null, 4)}`);
+
+ // event.detail:
+ // {
+ // "name": "ApexClass",
+ // "isExpanded": true,
+ // "hasChildrenContent": false,
+ // "row": {
+ // "metadataType": "ApexClass",
+ // "hasCalledApi": false,
+ // "_children": []
+ // }
+ // }
+ if(!event.detail.row.hasCalledApi) {
+ console.log(`I haven't called the Metadata API yet for this metadataType, I'm doin' it!!`);
+ console.log(`mdType: ${mdType}`);
+ retrieveListMetadata({ metadataTypeName: mdType })
+ .then(result => {
+ const listMetaResult = JSON.parse(result);
+ console.log(`List Metadata Result: ${JSON.stringify(listMetaResult, null, 4)}`);
+ // Find gridData node, set hasCalledApi to true, and populate it with children
+ const idxCurrentNode = this.gridData.findIndex(node => {
+ // console.log(`node: ${JSON.stringify(node, null, 4)}`);
+ return node.metadataType === mdType;
+ });
+ console.log(`idxCurrentNode: ${idxCurrentNode}`);
+ const updatedNode = { ...this.gridData[idxCurrentNode] };
+ updatedNode.hasCalledApi = true;
+ const childrenArray = listMetaResult.map(result => {
+ return {
+ metadataType: result.fullName,
+ hasCalledApi: true,
+ inFolder: false
+ };
+ });
+ console.log(`childrenArray: ${JSON.stringify(childrenArray, null, 4)}`);
+ updatedNode._children = childrenArray;
+ const updatedGridData = [...this.gridData];
+ console.log(`updatedNode: ${JSON.stringify(updatedNode, null, 4)}`);
+ updatedGridData[idxCurrentNode] = updatedNode;
+ console.log(`updatedGridData[idxCurrentNode]: ${JSON.stringify(updatedGridData[idxCurrentNode], null, 4)}`);
+ this.gridData = [...updatedGridData];
+
+ const setCurrentExpandedRows = new Set(currentExpandedRows);
+ if(setCurrentExpandedRows.has(mdType)) {
+ // If toggled node was already in expanded rows, remove
+ setCurrentExpandedRows.delete(mdType);
+ } else {
+ // If toggled node was not already in expanded rows, add
+ setCurrentExpandedRows.add(mdType);
+ }
+ this.expandedRows = Array.from(setCurrentExpandedRows);
+ })
+ .catch(error => {
+ console.error(`List Metadata Error: ${JSON.stringify(error, null, 4)}`);
+ });
+ }
+
+
+ }
+
+ handleRowSelection(event) {
+ console.log('Somebody selected something!');
+ }
+}
\ No newline at end of file
diff --git a/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js-meta.xml b/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js-meta.xml
new file mode 100644
index 0000000..b93f887
--- /dev/null
+++ b/sfdx-project/force-app/main/default/lwc/metadataBrowser/metadataBrowser.js-meta.xml
@@ -0,0 +1,9 @@
+
+{!file.content}'); + }, + + + capitalize: Ext.String.capitalize, + + + ellipsis: Ext.String.ellipsis, + + + format: Ext.String.format, + + + htmlDecode: Ext.String.htmlDecode, + + + htmlEncode: Ext.String.htmlEncode, + + + leftPad: Ext.String.leftPad, + + + trim : Ext.String.trim, + + + parseBox : function(box) { + box = Ext.isEmpty(box) ? '' : box; + if (Ext.isNumber(box)) { + box = box.toString(); + } + var parts = box.split(' '), + ln = parts.length; + + if (ln == 1) { + parts[1] = parts[2] = parts[3] = parts[0]; + } + else if (ln == 2) { + parts[2] = parts[0]; + parts[3] = parts[1]; + } + else if (ln == 3) { + parts[3] = parts[1]; + } + + return { + top :parseInt(parts[0], 10) || 0, + right :parseInt(parts[1], 10) || 0, + bottom:parseInt(parts[2], 10) || 0, + left :parseInt(parts[3], 10) || 0 + }; + }, + + + escapeRegex : function(s) { + return s.replace(/([\-.*+?\^${}()|\[\]\/\\])/g, "\\$1"); + } + }); +}()); + +//@tag extras,core + +//@require Format.js + +//@define Ext.util.TaskManager + +//@define Ext.TaskManager + + + +Ext.define('Ext.util.TaskRunner', { + + interval: 10, + + + timerId: null, + + constructor: function (interval) { + var me = this; + + if (typeof interval == 'number') { + me.interval = interval; + } else if (interval) { + Ext.apply(me, interval); + } + + me.tasks = []; + me.timerFn = Ext.Function.bind(me.onTick, me); + }, + + + newTask: function (config) { + var task = new Ext.util.TaskRunner.Task(config); + task.manager = this; + return task; + }, + + + start: function(task) { + var me = this, + now = new Date().getTime(); + + if (!task.pending) { + me.tasks.push(task); + task.pending = true; + } + + task.stopped = false; + task.taskStartTime = now; + task.taskRunTime = task.fireOnStart !== false ? 0 : task.taskStartTime; + task.taskRunCount = 0; + + if (!me.firing) { + if (task.fireOnStart !== false) { + me.startTimer(0, now); + } else { + me.startTimer(task.interval, now); + } + } + + return task; + }, + + + stop: function(task) { + + + + if (!task.stopped) { + task.stopped = true; + + if (task.onStop) { + task.onStop.call(task.scope || task, task); + } + } + + return task; + }, + + + stopAll: function() { + + Ext.each(this.tasks, this.stop, this); + }, + + + + firing: false, + + nextExpires: 1e99, + + + onTick: function () { + var me = this, + tasks = me.tasks, + now = new Date().getTime(), + nextExpires = 1e99, + len = tasks.length, + expires, newTasks, i, task, rt, remove; + + me.timerId = null; + me.firing = true; + + + + + + for (i = 0; i < len || i < (len = tasks.length); ++i) { + task = tasks[i]; + + if (!(remove = task.stopped)) { + expires = task.taskRunTime + task.interval; + + if (expires <= now) { + rt = 1; + try { + rt = task.run.apply(task.scope || task, task.args || [++task.taskRunCount]); + } catch (taskError) { + try { + if (task.onError) { + rt = task.onError.call(task.scope || task, task, taskError); + } + } catch (ignore) { } + } + task.taskRunTime = now; + if (rt === false || task.taskRunCount === task.repeat) { + me.stop(task); + remove = true; + } else { + remove = task.stopped; + expires = now + task.interval; + } + } + + if (!remove && task.duration && task.duration <= (now - task.taskStartTime)) { + me.stop(task); + remove = true; + } + } + + if (remove) { + task.pending = false; + + + + + + + if (!newTasks) { + newTasks = tasks.slice(0, i); + + + + } + } else { + if (newTasks) { + newTasks.push(task); + } + + if (nextExpires > expires) { + nextExpires = expires; + } + } + } + + if (newTasks) { + + + me.tasks = newTasks; + } + + me.firing = false; + + if (me.tasks.length) { + + + + me.startTimer(nextExpires - now, new Date().getTime()); + } + }, + + + startTimer: function (timeout, now) { + var me = this, + expires = now + timeout, + timerId = me.timerId; + + + + if (timerId && me.nextExpires - expires > me.interval) { + clearTimeout(timerId); + timerId = null; + } + + if (!timerId) { + if (timeout < me.interval) { + timeout = me.interval; + } + + me.timerId = setTimeout(me.timerFn, timeout); + me.nextExpires = expires; + } + } +}, +function () { + var me = this, + proto = me.prototype; + + + proto.destroy = proto.stopAll; + + + Ext.util.TaskManager = Ext.TaskManager = new me(); + + + me.Task = new Ext.Class({ + isTask: true, + + + stopped: true, + + + fireOnStart: false, + + constructor: function (config) { + Ext.apply(this, config); + }, + + + restart: function (interval) { + if (interval !== undefined) { + this.interval = interval; + } + + this.manager.start(this); + }, + + + start: function (interval) { + if (this.stopped) { + this.restart(interval); + } + }, + + + stop: function () { + this.manager.stop(this); + } + }); + + proto = me.Task.prototype; + + + proto.destroy = proto.stop; +}); + +//@tag extras,core + +//@require ../util/TaskManager.js + + + +Ext.define('Ext.perf.Accumulator', (function () { + var currentFrame = null, + khrome = Ext.global['chrome'], + formatTpl, + + + getTimestamp = function () { + + getTimestamp = function () { + return new Date().getTime(); + }; + + var interval, toolbox; + + + if (Ext.isChrome && khrome && khrome.Interval) { + interval = new khrome.Interval(); + interval.start(); + getTimestamp = function () { + return interval.microseconds() / 1000; + }; + } else if (window.ActiveXObject) { + try { + + toolbox = new ActiveXObject('SenchaToolbox.Toolbox'); + Ext.senchaToolbox = toolbox; + getTimestamp = function () { + return toolbox.milliseconds; + }; + } catch (e) { + + } + } else if (Date.now) { + getTimestamp = Date.now; + } + + Ext.perf.getTimestamp = Ext.perf.Accumulator.getTimestamp = getTimestamp; + return getTimestamp(); + }; + + function adjustSet (set, time) { + set.sum += time; + set.min = Math.min(set.min, time); + set.max = Math.max(set.max, time); + } + + function leaveFrame (time) { + var totalTime = time ? time : (getTimestamp() - this.time), + me = this, + accum = me.accum; + + ++accum.count; + if (! --accum.depth) { + adjustSet(accum.total, totalTime); + } + adjustSet(accum.pure, totalTime - me.childTime); + + currentFrame = me.parent; + if (currentFrame) { + ++currentFrame.accum.childCount; + currentFrame.childTime += totalTime; + } + } + + function makeSet () { + return { + min: Number.MAX_VALUE, + max: 0, + sum: 0 + }; + } + + function makeTap (me, fn) { + return function () { + var frame = me.enter(), + ret = fn.apply(this, arguments); + + frame.leave(); + return ret; + }; + } + + function round (x) { + return Math.round(x * 100) / 100; + } + + function setToJSON (count, childCount, calibration, set) { + var data = { + avg: 0, + min: set.min, + max: set.max, + sum: 0 + }; + + if (count) { + calibration = calibration || 0; + data.sum = set.sum - childCount * calibration; + data.avg = data.sum / count; + + + } + + return data; + } + + return { + constructor: function (name) { + var me = this; + + me.count = me.childCount = me.depth = me.maxDepth = 0; + me.pure = makeSet(); + me.total = makeSet(); + me.name = name; + }, + + statics: { + getTimestamp: getTimestamp + }, + + format: function (calibration) { + if (!formatTpl) { + formatTpl = new Ext.XTemplate([ + '{name} - {count} call(s)', + '
',
+ '',
+ '
',
+ '',
+ '',
+ '
',
+ '',
+ ''
+ ].join('');
+
+ doc.body.appendChild(div);
+ }
+
+ while (n--) {
+ test = tests[n];
+ if (div || test.early) {
+ me[test.identity] = test.fn.call(me, doc, div);
+ } else {
+ notRun.push(test);
+ }
+ }
+
+ if (div) {
+ doc.body.removeChild(div);
+ }
+
+ me.tests = notRun;
+ },
+
+
+ PointerEvents: 'pointerEvents' in document.documentElement.style,
+
+
+ CSS3BoxShadow: 'boxShadow' in document.documentElement.style || 'WebkitBoxShadow' in document.documentElement.style || 'MozBoxShadow' in document.documentElement.style,
+
+
+ ClassList: !!document.documentElement.classList,
+
+
+ OrientationChange: ((typeof window.orientation != 'undefined') && ('onorientationchange' in window)),
+
+
+ DeviceMotion: ('ondevicemotion' in window),
+
+
+
+
+ Touch: ('ontouchstart' in window) && (!Ext.is.Desktop),
+
+
+ TimeoutActualLateness: (function(){
+ setTimeout(function(){
+ Ext.supports.TimeoutActualLateness = arguments.length !== 0;
+ }, 0);
+ }()),
+
+ tests: [
+
+ {
+ identity: 'Transitions',
+ fn: function(doc, div) {
+ var prefix = [
+ 'webkit',
+ 'Moz',
+ 'o',
+ 'ms',
+ 'khtml'
+ ],
+ TE = 'TransitionEnd',
+ transitionEndName = [
+ prefix[0] + TE,
+ 'transitionend',
+ prefix[2] + TE,
+ prefix[3] + TE,
+ prefix[4] + TE
+ ],
+ ln = prefix.length,
+ i = 0,
+ out = false;
+
+ for (; i < ln; i++) {
+ if (getStyle(div, prefix[i] + "TransitionProperty")) {
+ Ext.supports.CSS3Prefix = prefix[i];
+ Ext.supports.CSS3TransitionEnd = transitionEndName[i];
+ out = true;
+ break;
+ }
+ }
+ return out;
+ }
+ },
+
+
+ {
+ identity: 'RightMargin',
+ fn: function(doc, div) {
+ var view = doc.defaultView;
+ return !(view && view.getComputedStyle(div.firstChild.firstChild, null).marginRight != '0px');
+ }
+ },
+
+
+ {
+ identity: 'DisplayChangeInputSelectionBug',
+ early: true,
+ fn: function() {
+ var webKitVersion = Ext.webKitVersion;
+
+ return 0 < webKitVersion && webKitVersion < 533;
+ }
+ },
+
+
+ {
+ identity: 'DisplayChangeTextAreaSelectionBug',
+ early: true,
+ fn: function() {
+ var webKitVersion = Ext.webKitVersion;
+
+
+ return 0 < webKitVersion && webKitVersion < 534.24;
+ }
+ },
+
+
+ {
+ identity: 'TransparentColor',
+ fn: function(doc, div, view) {
+ view = doc.defaultView;
+ return !(view && view.getComputedStyle(div.lastChild, null).backgroundColor != 'transparent');
+ }
+ },
+
+
+ {
+ identity: 'ComputedStyle',
+ fn: function(doc, div, view) {
+ view = doc.defaultView;
+ return view && view.getComputedStyle;
+ }
+ },
+
+
+ {
+ identity: 'Svg',
+ fn: function(doc) {
+ return !!doc.createElementNS && !!doc.createElementNS( "http:/" + "/www.w3.org/2000/svg", "svg").createSVGRect;
+ }
+ },
+
+
+ {
+ identity: 'Canvas',
+ fn: function(doc) {
+ return !!doc.createElement('canvas').getContext;
+ }
+ },
+
+
+ {
+ identity: 'Vml',
+ fn: function(doc) {
+ var d = doc.createElement("div");
+ d.innerHTML = "";
+ return (d.childNodes.length == 2);
+ }
+ },
+
+
+ {
+ identity: 'Float',
+ fn: function(doc, div) {
+ return !!div.lastChild.style.cssFloat;
+ }
+ },
+
+
+ {
+ identity: 'AudioTag',
+ fn: function(doc) {
+ return !!doc.createElement('audio').canPlayType;
+ }
+ },
+
+
+ {
+ identity: 'History',
+ fn: function() {
+ var history = window.history;
+ return !!(history && history.pushState);
+ }
+ },
+
+
+ {
+ identity: 'CSS3DTransform',
+ fn: function() {
+ return (typeof WebKitCSSMatrix != 'undefined' && new WebKitCSSMatrix().hasOwnProperty('m41'));
+ }
+ },
+
+
+ {
+ identity: 'CSS3LinearGradient',
+ fn: function(doc, div) {
+ var property = 'background-image:',
+ webkit = '-webkit-gradient(linear, left top, right bottom, from(black), to(white))',
+ w3c = 'linear-gradient(left top, black, white)',
+ moz = '-moz-' + w3c,
+ opera = '-o-' + w3c,
+ options = [property + webkit, property + w3c, property + moz, property + opera];
+
+ div.style.cssText = options.join(';');
+
+ return ("" + div.style.backgroundImage).indexOf('gradient') !== -1;
+ }
+ },
+
+
+ {
+ identity: 'CSS3BorderRadius',
+ fn: function(doc, div) {
+ var domPrefixes = ['borderRadius', 'BorderRadius', 'MozBorderRadius', 'WebkitBorderRadius', 'OBorderRadius', 'KhtmlBorderRadius'],
+ pass = false,
+ i;
+ for (i = 0; i < domPrefixes.length; i++) {
+ if (document.body.style[domPrefixes[i]] !== undefined) {
+ return true;
+ }
+ }
+ return pass;
+ }
+ },
+
+
+ {
+ identity: 'GeoLocation',
+ fn: function() {
+ return (typeof navigator != 'undefined' && typeof navigator.geolocation != 'undefined') || (typeof google != 'undefined' && typeof google.gears != 'undefined');
+ }
+ },
+
+ {
+ identity: 'MouseEnterLeave',
+ fn: function(doc, div){
+ return ('onmouseenter' in div && 'onmouseleave' in div);
+ }
+ },
+
+ {
+ identity: 'MouseWheel',
+ fn: function(doc, div) {
+ return ('onmousewheel' in div);
+ }
+ },
+
+ {
+ identity: 'Opacity',
+ fn: function(doc, div){
+
+ if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) {
+ return false;
+ }
+ div.firstChild.style.cssText = 'opacity:0.73';
+ return div.firstChild.style.opacity == '0.73';
+ }
+ },
+
+ {
+ identity: 'Placeholder',
+ fn: function(doc) {
+ return 'placeholder' in doc.createElement('input');
+ }
+ },
+
+
+ {
+ identity: 'Direct2DBug',
+ fn: function() {
+ return Ext.isString(document.body.style.msTransformOrigin);
+ }
+ },
+
+ {
+ identity: 'BoundingClientRect',
+ fn: function(doc, div) {
+ return Ext.isFunction(div.getBoundingClientRect);
+ }
+ },
+ {
+ identity: 'IncludePaddingInWidthCalculation',
+ fn: function(doc, div){
+ return div.childNodes[1].firstChild.offsetWidth == 210;
+ }
+ },
+ {
+ identity: 'IncludePaddingInHeightCalculation',
+ fn: function(doc, div){
+ return div.childNodes[1].firstChild.offsetHeight == 210;
+ }
+ },
+
+
+ {
+ identity: 'ArraySort',
+ fn: function() {
+ var a = [1,2,3,4,5].sort(function(){ return 0; });
+ return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
+ }
+ },
+
+ {
+ identity: 'Range',
+ fn: function() {
+ return !!document.createRange;
+ }
+ },
+
+ {
+ identity: 'CreateContextualFragment',
+ fn: function() {
+ var range = Ext.supports.Range ? document.createRange() : false;
+
+ return range && !!range.createContextualFragment;
+ }
+ },
+
+
+ {
+ identity: 'WindowOnError',
+ fn: function () {
+
+ return Ext.isIE || Ext.isGecko || Ext.webKitVersion >= 534.16;
+ }
+ },
+
+
+ {
+ identity: 'TextAreaMaxLength',
+ fn: function(){
+ var el = document.createElement('textarea');
+ return ('maxlength' in el);
+ }
+ },
+
+
+ {
+ identity: 'GetPositionPercentage',
+ fn: function(doc, div){
+ return getStyle(div.childNodes[2], 'left') == '10%';
+ }
+ }
+ ]
+};
+}());
+
+Ext.supports.init();
+
+//@tag dom,core
+
+//@require ../Support.js
+
+//@define Ext.util.DelayedTask
+
+
+
+Ext.util.DelayedTask = function(fn, scope, args) {
+ var me = this,
+ id,
+ call = function() {
+ clearInterval(id);
+ id = null;
+ fn.apply(scope, args || []);
+ };
+
+
+ this.delay = function(delay, newFn, newScope, newArgs) {
+ me.cancel();
+ fn = newFn || fn;
+ scope = newScope || scope;
+ args = newArgs || args;
+ id = setInterval(call, delay);
+ };
+
+
+ this.cancel = function(){
+ if (id) {
+ clearInterval(id);
+ id = null;
+ }
+ };
+};
+
+//@tag dom,core
+
+//@define Ext.util.Event
+
+//@require Ext.util.DelayedTask
+
+
+Ext.require('Ext.util.DelayedTask', function() {
+
+
+ Ext.util.Event = Ext.extend(Object, (function() {
+ var noOptions = {};
+
+ function createTargeted(handler, listener, o, scope){
+ return function(){
+ if (o.target === arguments[0]){
+ handler.apply(scope, arguments);
+ }
+ };
+ }
+
+ function createBuffered(handler, listener, o, scope) {
+ listener.task = new Ext.util.DelayedTask();
+ return function() {
+ listener.task.delay(o.buffer, handler, scope, Ext.Array.toArray(arguments));
+ };
+ }
+
+ function createDelayed(handler, listener, o, scope) {
+ return function() {
+ var task = new Ext.util.DelayedTask();
+ if (!listener.tasks) {
+ listener.tasks = [];
+ }
+ listener.tasks.push(task);
+ task.delay(o.delay || 10, handler, scope, Ext.Array.toArray(arguments));
+ };
+ }
+
+ function createSingle(handler, listener, o, scope) {
+ return function() {
+ var event = listener.ev;
+
+ if (event.removeListener(listener.fn, scope) && event.observable) {
+
+
+ event.observable.hasListeners[event.name]--;
+ }
+
+ return handler.apply(scope, arguments);
+ };
+ }
+
+ return {
+
+ isEvent: true,
+
+ constructor: function(observable, name) {
+ this.name = name;
+ this.observable = observable;
+ this.listeners = [];
+ },
+
+ addListener: function(fn, scope, options) {
+ var me = this,
+ listener;
+ scope = scope || me.observable;
+
+
+ if (!me.isListening(fn, scope)) {
+ listener = me.createListener(fn, scope, options);
+ if (me.firing) {
+
+ me.listeners = me.listeners.slice(0);
+ }
+ me.listeners.push(listener);
+ }
+ },
+
+ createListener: function(fn, scope, options) {
+ options = options || noOptions;
+ scope = scope || this.observable;
+
+ var listener = {
+ fn: fn,
+ scope: scope,
+ o: options,
+ ev: this
+ },
+ handler = fn;
+
+
+
+ if (options.single) {
+ handler = createSingle(handler, listener, options, scope);
+ }
+ if (options.target) {
+ handler = createTargeted(handler, listener, options, scope);
+ }
+ if (options.delay) {
+ handler = createDelayed(handler, listener, options, scope);
+ }
+ if (options.buffer) {
+ handler = createBuffered(handler, listener, options, scope);
+ }
+
+ listener.fireFn = handler;
+ return listener;
+ },
+
+ findListener: function(fn, scope) {
+ var listeners = this.listeners,
+ i = listeners.length,
+ listener,
+ s;
+
+ while (i--) {
+ listener = listeners[i];
+ if (listener) {
+ s = listener.scope;
+
+
+
+
+ if (listener.fn == fn && (s == (scope || this.observable))) {
+ return i;
+ }
+ }
+ }
+
+ return - 1;
+ },
+
+ isListening: function(fn, scope) {
+ return this.findListener(fn, scope) !== -1;
+ },
+
+ removeListener: function(fn, scope) {
+ var me = this,
+ index,
+ listener,
+ k;
+ index = me.findListener(fn, scope);
+ if (index != -1) {
+ listener = me.listeners[index];
+
+ if (me.firing) {
+ me.listeners = me.listeners.slice(0);
+ }
+
+
+ if (listener.task) {
+ listener.task.cancel();
+ delete listener.task;
+ }
+
+
+ k = listener.tasks && listener.tasks.length;
+ if (k) {
+ while (k--) {
+ listener.tasks[k].cancel();
+ }
+ delete listener.tasks;
+ }
+
+
+ Ext.Array.erase(me.listeners, index, 1);
+ return true;
+ }
+
+ return false;
+ },
+
+
+ clearListeners: function() {
+ var listeners = this.listeners,
+ i = listeners.length;
+
+ while (i--) {
+ this.removeListener(listeners[i].fn, listeners[i].scope);
+ }
+ },
+
+ fire: function() {
+ var me = this,
+ listeners = me.listeners,
+ count = listeners.length,
+ i,
+ args,
+ listener;
+
+ if (count > 0) {
+ me.firing = true;
+ for (i = 0; i < count; i++) {
+ listener = listeners[i];
+ args = arguments.length ? Array.prototype.slice.call(arguments, 0) : [];
+ if (listener.o) {
+ args.push(listener.o);
+ }
+ if (listener && listener.fireFn.apply(listener.scope || me.observable, args) === false) {
+ return (me.firing = false);
+ }
+ }
+ }
+ me.firing = false;
+ return true;
+ }
+ };
+ }()));
+});
+
+
+Ext.define('Ext.util.Observable', {
+
+
+
+ requires: ['Ext.util.Event'],
+
+ statics: {
+
+ releaseCapture: function(o) {
+ o.fireEvent = this.prototype.fireEvent;
+ },
+
+
+ capture: function(o, fn, scope) {
+ o.fireEvent = Ext.Function.createInterceptor(o.fireEvent, fn, scope);
+ },
+
+
+ observe: function(cls, listeners) {
+ if (cls) {
+ if (!cls.isObservable) {
+ Ext.applyIf(cls, new this());
+ this.capture(cls.prototype, cls.fireEvent, cls);
+ }
+ if (Ext.isObject(listeners)) {
+ cls.on(listeners);
+ }
+ }
+ return cls;
+ },
+
+
+ prepareClass: function (T, mixin) {
+
+
+
+
+
+
+ if (!T.HasListeners) {
+
+
+
+ var Observable = Ext.util.Observable,
+ HasListeners = function () {},
+ SuperHL = T.superclass.HasListeners || (mixin && mixin.HasListeners) ||
+ Observable.HasListeners;
+
+
+ T.prototype.HasListeners = T.HasListeners = HasListeners;
+
+
+
+ HasListeners.prototype = T.hasListeners = new SuperHL();
+ }
+ }
+ },
+
+
+
+
+
+
+ isObservable: true,
+
+
+ eventsSuspended: 0,
+
+
+
+ constructor: function(config) {
+ var me = this;
+
+ Ext.apply(me, config);
+
+
+ if (!me.hasListeners) {
+ me.hasListeners = new me.HasListeners();
+ }
+
+ me.events = me.events || {};
+ if (me.listeners) {
+ me.on(me.listeners);
+ me.listeners = null;
+ }
+
+ if (me.bubbleEvents) {
+ me.enableBubble(me.bubbleEvents);
+ }
+ },
+
+ onClassExtended: function (T) {
+ if (!T.HasListeners) {
+
+
+ Ext.util.Observable.prepareClass(T);
+ }
+ },
+
+
+ eventOptionsRe : /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|element|vertical|horizontal|freezeEvent)$/,
+
+
+ addManagedListener : function(item, ename, fn, scope, options) {
+ var me = this,
+ managedListeners = me.managedListeners = me.managedListeners || [],
+ config;
+
+ if (typeof ename !== 'string') {
+ options = ename;
+ for (ename in options) {
+ if (options.hasOwnProperty(ename)) {
+ config = options[ename];
+ if (!me.eventOptionsRe.test(ename)) {
+ me.addManagedListener(item, ename, config.fn || config, config.scope || options.scope, config.fn ? config : options);
+ }
+ }
+ }
+ }
+ else {
+ managedListeners.push({
+ item: item,
+ ename: ename,
+ fn: fn,
+ scope: scope,
+ options: options
+ });
+
+ item.on(ename, fn, scope, options);
+ }
+ },
+
+
+ removeManagedListener : function(item, ename, fn, scope) {
+ var me = this,
+ options,
+ config,
+ managedListeners,
+ length,
+ i;
+
+ if (typeof ename !== 'string') {
+ options = ename;
+ for (ename in options) {
+ if (options.hasOwnProperty(ename)) {
+ config = options[ename];
+ if (!me.eventOptionsRe.test(ename)) {
+ me.removeManagedListener(item, ename, config.fn || config, config.scope || options.scope);
+ }
+ }
+ }
+ }
+
+ managedListeners = me.managedListeners ? me.managedListeners.slice() : [];
+
+ for (i = 0, length = managedListeners.length; i < length; i++) {
+ me.removeManagedListenerItem(false, managedListeners[i], item, ename, fn, scope);
+ }
+ },
+
+
+ fireEvent: function(eventName) {
+ eventName = eventName.toLowerCase();
+ var me = this,
+ events = me.events,
+ event = events && events[eventName],
+ ret = true;
+
+
+
+ if (event && me.hasListeners[eventName]) {
+ ret = me.continueFireEvent(eventName, Ext.Array.slice(arguments, 1), event.bubble);
+ }
+ return ret;
+ },
+
+
+ continueFireEvent: function(eventName, args, bubbles) {
+ var target = this,
+ queue, event,
+ ret = true;
+
+ do {
+ if (target.eventsSuspended) {
+ if ((queue = target.eventQueue)) {
+ queue.push([eventName, args, bubbles]);
+ }
+ return ret;
+ } else {
+ event = target.events[eventName];
+
+
+ if (event && event != true) {
+ if ((ret = event.fire.apply(event, args)) === false) {
+ break;
+ }
+ }
+ }
+ } while (bubbles && (target = target.getBubbleParent()));
+ return ret;
+ },
+
+
+ getBubbleParent: function(){
+ var me = this, parent = me.getBubbleTarget && me.getBubbleTarget();
+ if (parent && parent.isObservable) {
+ return parent;
+ }
+ return null;
+ },
+
+
+ addListener: function(ename, fn, scope, options) {
+ var me = this,
+ config, event, hasListeners,
+ prevListenerCount = 0;
+
+ if (typeof ename !== 'string') {
+ options = ename;
+ for (ename in options) {
+ if (options.hasOwnProperty(ename)) {
+ config = options[ename];
+ if (!me.eventOptionsRe.test(ename)) {
+ me.addListener(ename, config.fn || config, config.scope || options.scope, config.fn ? config : options);
+ }
+ }
+ }
+ } else {
+ ename = ename.toLowerCase();
+ event = me.events[ename];
+ if (event && event.isEvent) {
+ prevListenerCount = event.listeners.length;
+ } else {
+ me.events[ename] = event = new Ext.util.Event(me, ename);
+ }
+
+
+ if (typeof fn === 'string') {
+ fn = scope[fn] || me[fn];
+ }
+ event.addListener(fn, scope, options);
+
+
+
+ if (event.listeners.length !== prevListenerCount) {
+ hasListeners = me.hasListeners;
+ if (hasListeners.hasOwnProperty(ename)) {
+
+ ++hasListeners[ename];
+ } else {
+
+
+ hasListeners[ename] = 1;
+ }
+ }
+ }
+ },
+
+
+ removeListener: function(ename, fn, scope) {
+ var me = this,
+ config,
+ event,
+ options;
+
+ if (typeof ename !== 'string') {
+ options = ename;
+ for (ename in options) {
+ if (options.hasOwnProperty(ename)) {
+ config = options[ename];
+ if (!me.eventOptionsRe.test(ename)) {
+ me.removeListener(ename, config.fn || config, config.scope || options.scope);
+ }
+ }
+ }
+ } else {
+ ename = ename.toLowerCase();
+ event = me.events[ename];
+ if (event && event.isEvent) {
+ if (event.removeListener(fn, scope) && !--me.hasListeners[ename]) {
+
+
+
+ delete me.hasListeners[ename];
+ }
+ }
+ }
+ },
+
+
+ clearListeners: function() {
+ var events = this.events,
+ event,
+ key;
+
+ for (key in events) {
+ if (events.hasOwnProperty(key)) {
+ event = events[key];
+ if (event.isEvent) {
+ event.clearListeners();
+ }
+ }
+ }
+
+ this.clearManagedListeners();
+ },
+
+
+
+ clearManagedListeners : function() {
+ var managedListeners = this.managedListeners || [],
+ i = 0,
+ len = managedListeners.length;
+
+ for (; i < len; i++) {
+ this.removeManagedListenerItem(true, managedListeners[i]);
+ }
+
+ this.managedListeners = [];
+ },
+
+
+ removeManagedListenerItem: function(isClear, managedListener, item, ename, fn, scope){
+ if (isClear || (managedListener.item === item && managedListener.ename === ename && (!fn || managedListener.fn === fn) && (!scope || managedListener.scope === scope))) {
+ managedListener.item.un(managedListener.ename, managedListener.fn, managedListener.scope);
+ if (!isClear) {
+ Ext.Array.remove(this.managedListeners, managedListener);
+ }
+ }
+ },
+
+
+
+ addEvents: function(o) {
+ var me = this,
+ events = me.events || (me.events = {}),
+ arg, args, i;
+
+ if (typeof o == 'string') {
+ for (args = arguments, i = args.length; i--; ) {
+ arg = args[i];
+ if (!events[arg]) {
+ events[arg] = true;
+ }
+ }
+ } else {
+ Ext.applyIf(me.events, o);
+ }
+ },
+
+
+ hasListener: function(ename) {
+ return !!this.hasListeners[ename.toLowerCase()];
+ },
+
+
+ suspendEvents: function(queueSuspended) {
+ this.eventsSuspended += 1;
+ if (queueSuspended && !this.eventQueue) {
+ this.eventQueue = [];
+ }
+ },
+
+
+ resumeEvents: function() {
+ var me = this,
+ queued = me.eventQueue,
+ qLen, q;
+
+ if (me.eventsSuspended && ! --me.eventsSuspended) {
+ delete me.eventQueue;
+
+ if (queued) {
+ qLen = queued.length;
+ for (q = 0; q < qLen; q++) {
+ me.continueFireEvent.apply(me, queued[q]);
+ }
+ }
+ }
+ },
+
+
+ relayEvents : function(origin, events, prefix) {
+ var me = this,
+ len = events.length,
+ i = 0,
+ oldName,
+ newName;
+
+ for (; i < len; i++) {
+ oldName = events[i];
+ newName = prefix ? prefix + oldName : oldName;
+
+
+ me.mon(origin, oldName, me.createRelayer(newName));
+ }
+ },
+
+
+ createRelayer: function(newName, beginEnd){
+ var me = this;
+ return function() {
+ return me.fireEvent.apply(me, [newName].concat(Array.prototype.slice.apply(arguments, beginEnd || [0, -1])));
+ };
+ },
+
+
+ enableBubble: function(eventNames) {
+ if (eventNames) {
+ var me = this,
+ names = (typeof eventNames == 'string') ? arguments : eventNames,
+ length = names.length,
+ events = me.events,
+ ename, event, i;
+
+ for (i = 0; i < length; ++i) {
+ ename = names[i].toLowerCase();
+ event = events[ename];
+
+ if (!event || typeof event == 'boolean') {
+ events[ename] = event = new Ext.util.Event(me, ename);
+ }
+
+
+ me.hasListeners[ename] = (me.hasListeners[ename]||0) + 1;
+
+ event.bubble = true;
+ }
+ }
+ }
+}, function() {
+ var Observable = this,
+ proto = Observable.prototype,
+ HasListeners = function () {},
+ prepareMixin = function (T) {
+ if (!T.HasListeners) {
+ var proto = T.prototype;
+
+
+ Observable.prepareClass(T, this);
+
+
+
+ T.onExtended(function (U) {
+ Observable.prepareClass(U);
+ });
+
+
+
+ if (proto.onClassMixedIn) {
+
+ Ext.override(T, {
+ onClassMixedIn: function (U) {
+ prepareMixin.call(this, U);
+ this.callParent(arguments);
+ }
+ });
+ } else {
+
+ proto.onClassMixedIn = function (U) {
+ prepareMixin.call(this, U);
+ };
+ }
+ }
+ };
+
+ HasListeners.prototype = {
+
+ };
+
+ proto.HasListeners = Observable.HasListeners = HasListeners;
+
+ Observable.createAlias({
+
+ on: 'addListener',
+
+ un: 'removeListener',
+
+ mon: 'addManagedListener',
+
+ mun: 'removeManagedListener'
+ });
+
+
+ Observable.observeClass = Observable.observe;
+
+
+
+
+ function getMethodEvent(method){
+ var e = (this.methodEvents = this.methodEvents || {})[method],
+ returnValue,
+ v,
+ cancel,
+ obj = this,
+ makeCall;
+
+ if (!e) {
+ this.methodEvents[method] = e = {};
+ e.originalFn = this[method];
+ e.methodName = method;
+ e.before = [];
+ e.after = [];
+
+ makeCall = function(fn, scope, args){
+ if((v = fn.apply(scope || obj, args)) !== undefined){
+ if (typeof v == 'object') {
+ if(v.returnValue !== undefined){
+ returnValue = v.returnValue;
+ }else{
+ returnValue = v;
+ }
+ cancel = !!v.cancel;
+ }
+ else
+ if (v === false) {
+ cancel = true;
+ }
+ else {
+ returnValue = v;
+ }
+ }
+ };
+
+ this[method] = function(){
+ var args = Array.prototype.slice.call(arguments, 0),
+ b, i, len;
+ returnValue = v = undefined;
+ cancel = false;
+
+ for(i = 0, len = e.before.length; i < len; i++){
+ b = e.before[i];
+ makeCall(b.fn, b.scope, args);
+ if (cancel) {
+ return returnValue;
+ }
+ }
+
+ if((v = e.originalFn.apply(obj, args)) !== undefined){
+ returnValue = v;
+ }
+
+ for(i = 0, len = e.after.length; i < len; i++){
+ b = e.after[i];
+ makeCall(b.fn, b.scope, args);
+ if (cancel) {
+ return returnValue;
+ }
+ }
+ return returnValue;
+ };
+ }
+ return e;
+ }
+
+ Ext.apply(proto, {
+ onClassMixedIn: prepareMixin,
+
+
+
+
+ beforeMethod : function(method, fn, scope){
+ getMethodEvent.call(this, method).before.push({
+ fn: fn,
+ scope: scope
+ });
+ },
+
+
+ afterMethod : function(method, fn, scope){
+ getMethodEvent.call(this, method).after.push({
+ fn: fn,
+ scope: scope
+ });
+ },
+
+ removeMethodListener: function(method, fn, scope){
+ var e = this.getMethodEvent(method),
+ i, len;
+ for(i = 0, len = e.before.length; i < len; i++){
+ if(e.before[i].fn == fn && e.before[i].scope == scope){
+ Ext.Array.erase(e.before, i, 1);
+ return;
+ }
+ }
+ for(i = 0, len = e.after.length; i < len; i++){
+ if(e.after[i].fn == fn && e.after[i].scope == scope){
+ Ext.Array.erase(e.after, i, 1);
+ return;
+ }
+ }
+ },
+
+ toggleEventLogging: function(toggle) {
+ Ext.util.Observable[toggle ? 'capture' : 'releaseCapture'](this, function(en) {
+ if (Ext.isDefined(Ext.global.console)) {
+ Ext.global.console.log(en, arguments);
+ }
+ });
+ }
+ });
+});
+
+
+Ext.define('Ext.util.HashMap', {
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
+
+
+
+
+ constructor: function(config) {
+ config = config || {};
+
+ var me = this,
+ keyFn = config.keyFn;
+
+ me.addEvents(
+
+ 'add',
+
+ 'clear',
+
+ 'remove',
+
+ 'replace'
+ );
+
+ me.mixins.observable.constructor.call(me, config);
+ me.clear(true);
+
+ if (keyFn) {
+ me.getKey = keyFn;
+ }
+ },
+
+
+ getCount: function() {
+ return this.length;
+ },
+
+
+ getData: function(key, value) {
+
+ if (value === undefined) {
+ value = key;
+ key = this.getKey(value);
+ }
+
+ return [key, value];
+ },
+
+
+ getKey: function(o) {
+ return o.id;
+ },
+
+
+ add: function(key, value) {
+ var me = this;
+
+ if (value === undefined) {
+ value = key;
+ key = me.getKey(value);
+ }
+
+ if (me.containsKey(key)) {
+ return me.replace(key, value);
+ }
+
+ me.map[key] = value;
+ ++me.length;
+ if (me.hasListeners.add) {
+ me.fireEvent('add', me, key, value);
+ }
+ return value;
+ },
+
+
+ replace: function(key, value) {
+ var me = this,
+ map = me.map,
+ old;
+
+ if (value === undefined) {
+ value = key;
+ key = me.getKey(value);
+ }
+
+ if (!me.containsKey(key)) {
+ me.add(key, value);
+ }
+ old = map[key];
+ map[key] = value;
+ if (me.hasListeners.replace) {
+ me.fireEvent('replace', me, key, value, old);
+ }
+ return value;
+ },
+
+
+ remove: function(o) {
+ var key = this.findKey(o);
+ if (key !== undefined) {
+ return this.removeAtKey(key);
+ }
+ return false;
+ },
+
+
+ removeAtKey: function(key) {
+ var me = this,
+ value;
+
+ if (me.containsKey(key)) {
+ value = me.map[key];
+ delete me.map[key];
+ --me.length;
+ if (me.hasListeners.remove) {
+ me.fireEvent('remove', me, key, value);
+ }
+ return true;
+ }
+ return false;
+ },
+
+
+ get: function(key) {
+ return this.map[key];
+ },
+
+
+ clear: function( initial) {
+ var me = this;
+ me.map = {};
+ me.length = 0;
+ if (initial !== true && me.hasListeners.clear) {
+ me.fireEvent('clear', me);
+ }
+ return me;
+ },
+
+
+ containsKey: function(key) {
+ return this.map[key] !== undefined;
+ },
+
+
+ contains: function(value) {
+ return this.containsKey(this.findKey(value));
+ },
+
+
+ getKeys: function() {
+ return this.getArray(true);
+ },
+
+
+ getValues: function() {
+ return this.getArray(false);
+ },
+
+
+ getArray: function(isKey) {
+ var arr = [],
+ key,
+ map = this.map;
+ for (key in map) {
+ if (map.hasOwnProperty(key)) {
+ arr.push(isKey ? key: map[key]);
+ }
+ }
+ return arr;
+ },
+
+
+ each: function(fn, scope) {
+
+ var items = Ext.apply({}, this.map),
+ key,
+ length = this.length;
+
+ scope = scope || this;
+ for (key in items) {
+ if (items.hasOwnProperty(key)) {
+ if (fn.call(scope, key, items[key], length) === false) {
+ break;
+ }
+ }
+ }
+ return this;
+ },
+
+
+ clone: function() {
+ var hash = new this.self(),
+ map = this.map,
+ key;
+
+ hash.suspendEvents();
+ for (key in map) {
+ if (map.hasOwnProperty(key)) {
+ hash.add(key, map[key]);
+ }
+ }
+ hash.resumeEvents();
+ return hash;
+ },
+
+
+ findKey: function(value) {
+ var key,
+ map = this.map;
+
+ for (key in map) {
+ if (map.hasOwnProperty(key) && map[key] === value) {
+ return key;
+ }
+ }
+ return undefined;
+ }
+});
+
+
+Ext.define('Ext.AbstractManager', {
+
+
+
+ requires: ['Ext.util.HashMap'],
+
+
+
+ typeName: 'type',
+
+ constructor: function(config) {
+ Ext.apply(this, config || {});
+
+
+ this.all = new Ext.util.HashMap();
+
+ this.types = {};
+ },
+
+
+ get : function(id) {
+ return this.all.get(id);
+ },
+
+
+ register: function(item) {
+ this.all.add(item);
+ },
+
+
+ unregister: function(item) {
+ this.all.remove(item);
+ },
+
+
+ registerType : function(type, cls) {
+ this.types[type] = cls;
+ cls[this.typeName] = type;
+ },
+
+
+ isRegistered : function(type){
+ return this.types[type] !== undefined;
+ },
+
+
+ create: function(config, defaultType) {
+ var type = config[this.typeName] || config.type || defaultType,
+ Constructor = this.types[type];
+
+
+ return new Constructor(config);
+ },
+
+
+ onAvailable : function(id, fn, scope){
+ var all = this.all,
+ item,
+ callback;
+
+ if (all.containsKey(id)) {
+ item = all.get(id);
+ fn.call(scope || item, item);
+ } else {
+ callback = function(map, key, item){
+ if (key == id) {
+ fn.call(scope || item, item);
+ all.un('add', callback);
+ }
+ };
+ all.on('add', callback);
+ }
+ },
+
+
+ each: function(fn, scope){
+ this.all.each(fn, scope || this);
+ },
+
+
+ getCount: function(){
+ return this.all.getCount();
+ }
+});
+
+
+Ext.define('Ext.ComponentManager', {
+ extend: 'Ext.AbstractManager',
+ alternateClassName: 'Ext.ComponentMgr',
+
+ singleton: true,
+
+ typeName: 'xtype',
+
+
+ create: function(component, defaultType){
+ if (typeof component == 'string') {
+ return Ext.widget(component);
+ }
+ if (component.isComponent) {
+ return component;
+ }
+ return Ext.widget(component.xtype || defaultType, component);
+ },
+
+ registerType: function(type, cls) {
+ this.types[type] = cls;
+ cls[this.typeName] = type;
+ cls.prototype[this.typeName] = type;
+ }
+});
+
+
+Ext.define('Ext.ComponentQuery', {
+ singleton: true,
+ requires: ['Ext.ComponentManager']
+}, function() {
+
+ var cq = this,
+
+
+
+ filterFnPattern = [
+ 'var r = [],',
+ 'i = 0,',
+ 'it = items,',
+ 'l = it.length,',
+ 'c;',
+ 'for (; i < l; i++) {',
+ 'c = it[i];',
+ 'if (c.{0}) {',
+ 'r.push(c);',
+ '}',
+ '}',
+ 'return r;'
+ ].join(''),
+
+ filterItems = function(items, operation) {
+
+
+
+ return operation.method.apply(this, [ items ].concat(operation.args));
+ },
+
+ getItems = function(items, mode) {
+ var result = [],
+ i = 0,
+ length = items.length,
+ candidate,
+ deep = mode !== '>';
+
+ for (; i < length; i++) {
+ candidate = items[i];
+ if (candidate.getRefItems) {
+ result = result.concat(candidate.getRefItems(deep));
+ }
+ }
+ return result;
+ },
+
+ getAncestors = function(items) {
+ var result = [],
+ i = 0,
+ length = items.length,
+ candidate;
+ for (; i < length; i++) {
+ candidate = items[i];
+ while (!!(candidate = (candidate.ownerCt || candidate.floatParent))) {
+ result.push(candidate);
+ }
+ }
+ return result;
+ },
+
+
+ filterByXType = function(items, xtype, shallow) {
+ if (xtype === '*') {
+ return items.slice();
+ }
+ else {
+ var result = [],
+ i = 0,
+ length = items.length,
+ candidate;
+ for (; i < length; i++) {
+ candidate = items[i];
+ if (candidate.isXType(xtype, shallow)) {
+ result.push(candidate);
+ }
+ }
+ return result;
+ }
+ },
+
+
+ filterByClassName = function(items, className) {
+ var EA = Ext.Array,
+ result = [],
+ i = 0,
+ length = items.length,
+ candidate;
+ for (; i < length; i++) {
+ candidate = items[i];
+ if (candidate.hasCls(className)) {
+ result.push(candidate);
+ }
+ }
+ return result;
+ },
+
+
+ filterByAttribute = function(items, property, operator, value) {
+ var result = [],
+ i = 0,
+ length = items.length,
+ candidate;
+ for (; i < length; i++) {
+ candidate = items[i];
+ if (!value ? !!candidate[property] : (String(candidate[property]) === value)) {
+ result.push(candidate);
+ }
+ }
+ return result;
+ },
+
+
+ filterById = function(items, id) {
+ var result = [],
+ i = 0,
+ length = items.length,
+ candidate;
+ for (; i < length; i++) {
+ candidate = items[i];
+ if (candidate.getItemId() === id) {
+ result.push(candidate);
+ }
+ }
+ return result;
+ },
+
+
+ filterByPseudo = function(items, name, value) {
+ return cq.pseudos[name](items, value);
+ },
+
+
+
+ modeRe = /^(\s?([>\^])\s?|\s|$)/,
+
+
+ tokenRe = /^(#)?([\w\-]+|\*)(?:\((true|false)\))?/,
+
+ matchers = [{
+
+ re: /^\.([\w\-]+)(?:\((true|false)\))?/,
+ method: filterByXType
+ },{
+
+ re: /^(?:[\[](?:@)?([\w\-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]])/,
+ method: filterByAttribute
+ }, {
+
+ re: /^#([\w\-]+)/,
+ method: filterById
+ }, {
+
+ re: /^\:([\w\-]+)(?:\(((?:\{[^\}]+\})|(?:(?!\{)[^\s>\/]*?(?!\})))\))?/,
+ method: filterByPseudo
+ }, {
+
+ re: /^(?:\{([^\}]+)\})/,
+ method: filterFnPattern
+ }];
+
+
+ cq.Query = Ext.extend(Object, {
+ constructor: function(cfg) {
+ cfg = cfg || {};
+ Ext.apply(this, cfg);
+ },
+
+
+
+
+
+
+
+
+
+ execute : function(root) {
+ var operations = this.operations,
+ i = 0,
+ length = operations.length,
+ operation,
+ workingItems;
+
+
+ if (!root) {
+ workingItems = Ext.ComponentManager.all.getArray();
+ }
+
+ else if (Ext.isArray(root)) {
+ workingItems = root;
+ }
+
+ else if (root.isMixedCollection) {
+ workingItems = root.items;
+ }
+
+
+
+ for (; i < length; i++) {
+ operation = operations[i];
+
+
+
+
+
+
+
+ if (operation.mode === '^') {
+ workingItems = getAncestors(workingItems || [root]);
+ }
+ else if (operation.mode) {
+ workingItems = getItems(workingItems || [root], operation.mode);
+ }
+ else {
+ workingItems = filterItems(workingItems || getItems([root]), operation);
+ }
+
+
+
+ if (i === length -1) {
+ return workingItems;
+ }
+ }
+ return [];
+ },
+
+ is: function(component) {
+ var operations = this.operations,
+ components = Ext.isArray(component) ? component : [component],
+ originalLength = components.length,
+ lastOperation = operations[operations.length-1],
+ ln, i;
+
+ components = filterItems(components, lastOperation);
+ if (components.length === originalLength) {
+ if (operations.length > 1) {
+ for (i = 0, ln = components.length; i < ln; i++) {
+ if (Ext.Array.indexOf(this.execute(), components[i]) === -1) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ return false;
+ }
+ });
+
+ Ext.apply(this, {
+
+
+ cache: {},
+
+
+ pseudos: {
+ not: function(components, selector){
+ var CQ = Ext.ComponentQuery,
+ i = 0,
+ length = components.length,
+ results = [],
+ index = -1,
+ component;
+
+ for(; i < length; ++i) {
+ component = components[i];
+ if (!CQ.is(component, selector)) {
+ results[++index] = component;
+ }
+ }
+ return results;
+ },
+ first: function(components) {
+ var ret = [];
+
+ if (components.length > 0) {
+ ret.push(components[0]);
+ }
+ return ret;
+ },
+ last: function(components) {
+ var len = components.length,
+ ret = [];
+
+ if (len > 0) {
+ ret.push(components[len - 1]);
+ }
+ return ret;
+ }
+ },
+
+
+ query: function(selector, root) {
+ var selectors = selector.split(','),
+ length = selectors.length,
+ i = 0,
+ results = [],
+ noDupResults = [],
+ dupMatcher = {},
+ query, resultsLn, cmp;
+
+ for (; i < length; i++) {
+ selector = Ext.String.trim(selectors[i]);
+ query = this.cache[selector] || (this.cache[selector] = this.parse(selector));
+ results = results.concat(query.execute(root));
+ }
+
+
+
+ if (length > 1) {
+ resultsLn = results.length;
+ for (i = 0; i < resultsLn; i++) {
+ cmp = results[i];
+ if (!dupMatcher[cmp.id]) {
+ noDupResults.push(cmp);
+ dupMatcher[cmp.id] = true;
+ }
+ }
+ results = noDupResults;
+ }
+ return results;
+ },
+
+
+ is: function(component, selector) {
+ if (!selector) {
+ return true;
+ }
+ var selectors = selector.split(','),
+ length = selectors.length,
+ i = 0,
+ query;
+
+ for (; i < length; i++) {
+ selector = Ext.String.trim(selectors[i]);
+ query = this.cache[selector] || (this.cache[selector] = this.parse(selector));
+ if (query.is(component)) {
+ return true;
+ }
+ }
+ return false;
+ },
+
+ parse: function(selector) {
+ var operations = [],
+ length = matchers.length,
+ lastSelector,
+ tokenMatch,
+ matchedChar,
+ modeMatch,
+ selectorMatch,
+ i, matcher, method;
+
+
+
+
+ while (selector && lastSelector !== selector) {
+ lastSelector = selector;
+
+
+ tokenMatch = selector.match(tokenRe);
+
+ if (tokenMatch) {
+ matchedChar = tokenMatch[1];
+
+
+ if (matchedChar === '#') {
+ operations.push({
+ method: filterById,
+ args: [Ext.String.trim(tokenMatch[2])]
+ });
+ }
+
+
+ else if (matchedChar === '.') {
+ operations.push({
+ method: filterByClassName,
+ args: [Ext.String.trim(tokenMatch[2])]
+ });
+ }
+
+
+ else {
+ operations.push({
+ method: filterByXType,
+ args: [Ext.String.trim(tokenMatch[2]), Boolean(tokenMatch[3])]
+ });
+ }
+
+
+ selector = selector.replace(tokenMatch[0], '');
+ }
+
+
+
+
+ while (!(modeMatch = selector.match(modeRe))) {
+
+
+ for (i = 0; selector && i < length; i++) {
+ matcher = matchers[i];
+ selectorMatch = selector.match(matcher.re);
+ method = matcher.method;
+
+
+
+
+ if (selectorMatch) {
+ operations.push({
+ method: Ext.isString(matcher.method)
+
+
+
+ ? Ext.functionFactory('items', Ext.String.format.apply(Ext.String, [method].concat(selectorMatch.slice(1))))
+ : matcher.method,
+ args: selectorMatch.slice(1)
+ });
+ selector = selector.replace(selectorMatch[0], '');
+ break;
+ }
+
+ if (i === (length - 1)) {
+ Ext.Error.raise('Invalid ComponentQuery selector: "' + arguments[0] + '"');
+ }
+ }
+ }
+
+
+
+
+
+ if (modeMatch[1]) {
+ operations.push({
+ mode: modeMatch[2]||modeMatch[1]
+ });
+ selector = selector.replace(modeMatch[0], '');
+ }
+ }
+
+
+
+ return new cq.Query({
+ operations: operations
+ });
+ }
+ });
+});
+
+
+
+
+Ext.define('Ext.util.ProtoElement', (function () {
+ var splitWords = Ext.String.splitWords,
+ toMap = Ext.Array.toMap;
+
+ return {
+
+ isProtoEl: true,
+
+
+ clsProp: 'cls',
+
+
+ styleProp: 'style',
+
+
+ removedProp: 'removed',
+
+
+ styleIsText: false,
+
+ constructor: function (config) {
+ var me = this;
+
+ Ext.apply(me, config);
+
+ me.classList = splitWords(me.cls);
+ me.classMap = toMap(me.classList);
+ delete me.cls;
+
+ if (Ext.isFunction(me.style)) {
+ me.styleFn = me.style;
+ delete me.style;
+ } else if (typeof me.style == 'string') {
+ me.style = Ext.Element.parseStyles(me.style);
+ } else if (me.style) {
+ me.style = Ext.apply({}, me.style);
+ }
+ },
+
+
+ flush: function(){
+ this.flushClassList = [];
+ this.removedClasses = {};
+
+ delete this.style;
+ },
+
+
+ addCls: function (cls) {
+ var me = this,
+ add = splitWords(cls),
+ length = add.length,
+ list = me.classList,
+ map = me.classMap,
+ flushList = me.flushClassList,
+ i = 0,
+ c;
+
+ for (; i < length; ++i) {
+ c = add[i];
+ if (!map[c]) {
+ map[c] = true;
+ list.push(c);
+ if (flushList) {
+ flushList.push(c);
+ delete me.removedClasses[c];
+ }
+ }
+ }
+
+ return me;
+ },
+
+
+ hasCls: function (cls) {
+ return cls in this.classMap;
+ },
+
+
+ removeCls: function (cls) {
+ var me = this,
+ list = me.classList,
+ newList = (me.classList = []),
+ remove = toMap(splitWords(cls)),
+ length = list.length,
+ map = me.classMap,
+ removedClasses = me.removedClasses,
+ i, c;
+
+ for (i = 0; i < length; ++i) {
+ c = list[i];
+ if (remove[c]) {
+ if (removedClasses) {
+ if (map[c]) {
+ removedClasses[c] = true;
+ Ext.Array.remove(me.flushClassList, c);
+ }
+ }
+ delete map[c];
+ } else {
+ newList.push(c);
+ }
+ }
+
+ return me;
+ },
+
+
+ setStyle: function (prop, value) {
+ var me = this,
+ style = me.style || (me.style = {});
+
+ if (typeof prop == 'string') {
+ if (arguments.length === 1) {
+ me.setStyle(Ext.Element.parseStyles(prop));
+ } else {
+ style[prop] = value;
+ }
+ } else {
+ Ext.apply(style, prop);
+ }
+
+ return me;
+ },
+
+
+ writeTo: function (to) {
+ var me = this,
+ classList = me.flushClassList || me.classList,
+ removedClasses = me.removedClasses,
+ style;
+
+ if (me.styleFn) {
+ style = Ext.apply({}, me.styleFn());
+ Ext.apply(style, me.style);
+ } else {
+ style = me.style;
+ }
+
+ to[me.clsProp] = classList.join(' ');
+
+ if (style) {
+ to[me.styleProp] = me.styleIsText ? Ext.DomHelper.generateStyles(style) : style;
+ }
+
+ if (removedClasses) {
+ removedClasses = Ext.Object.getKeys(removedClasses);
+ if (removedClasses.length) {
+ to[me.removedProp] = removedClasses.join(' ');
+ }
+ }
+
+ return to;
+ }
+ };
+}()));
+
+//@tag dom,core
+
+//@require util/Event.js
+
+//@define Ext.EventManager
+
+
+
+Ext.EventManager = new function() {
+ var EventManager = this,
+ doc = document,
+ win = window,
+ initExtCss = function() {
+
+ var bd = doc.body || doc.getElementsByTagName('body')[0],
+ baseCSSPrefix = Ext.baseCSSPrefix,
+ cls = [baseCSSPrefix + 'body'],
+ htmlCls = [],
+ supportsLG = Ext.supports.CSS3LinearGradient,
+ supportsBR = Ext.supports.CSS3BorderRadius,
+ resetCls = [],
+ html,
+ resetElementSpec;
+
+ if (!bd) {
+ return false;
+ }
+
+ html = bd.parentNode;
+
+ function add (c) {
+ cls.push(baseCSSPrefix + c);
+ }
+
+
+ if (Ext.isIE) {
+ add('ie');
+
+
+
+
+
+
+
+
+
+
+
+
+ if (Ext.isIE6) {
+ add('ie6');
+ } else {
+ add('ie7p');
+
+ if (Ext.isIE7) {
+ add('ie7');
+ } else {
+ add('ie8p');
+
+ if (Ext.isIE8) {
+ add('ie8');
+ } else {
+ add('ie9p');
+
+ if (Ext.isIE9) {
+ add('ie9');
+ }
+ }
+ }
+ }
+
+ if (Ext.isIE6 || Ext.isIE7) {
+ add('ie7m');
+ }
+ if (Ext.isIE6 || Ext.isIE7 || Ext.isIE8) {
+ add('ie8m');
+ }
+ if (Ext.isIE7 || Ext.isIE8) {
+ add('ie78');
+ }
+ }
+ if (Ext.isGecko) {
+ add('gecko');
+ if (Ext.isGecko3) {
+ add('gecko3');
+ }
+ if (Ext.isGecko4) {
+ add('gecko4');
+ }
+ if (Ext.isGecko5) {
+ add('gecko5');
+ }
+ }
+ if (Ext.isOpera) {
+ add('opera');
+ }
+ if (Ext.isWebKit) {
+ add('webkit');
+ }
+ if (Ext.isSafari) {
+ add('safari');
+ if (Ext.isSafari2) {
+ add('safari2');
+ }
+ if (Ext.isSafari3) {
+ add('safari3');
+ }
+ if (Ext.isSafari4) {
+ add('safari4');
+ }
+ if (Ext.isSafari5) {
+ add('safari5');
+ }
+ if (Ext.isSafari5_0) {
+ add('safari5_0')
+ }
+ }
+ if (Ext.isChrome) {
+ add('chrome');
+ }
+ if (Ext.isMac) {
+ add('mac');
+ }
+ if (Ext.isLinux) {
+ add('linux');
+ }
+ if (!supportsBR) {
+ add('nbr');
+ }
+ if (!supportsLG) {
+ add('nlg');
+ }
+
+
+
+
+ if (Ext.scopeResetCSS) {
+
+
+ resetElementSpec = Ext.resetElementSpec = {
+ cls: baseCSSPrefix + 'reset'
+ };
+
+ if (!supportsLG) {
+ resetCls.push(baseCSSPrefix + 'nlg');
+ }
+
+ if (!supportsBR) {
+ resetCls.push(baseCSSPrefix + 'nbr');
+ }
+
+ if (resetCls.length) {
+ resetElementSpec.cn = {
+ cls: resetCls.join(' ')
+ };
+ }
+
+ Ext.resetElement = Ext.getBody().createChild(resetElementSpec);
+ if (resetCls.length) {
+ Ext.resetElement = Ext.get(Ext.resetElement.dom.firstChild);
+ }
+ }
+
+ else {
+ Ext.resetElement = Ext.getBody();
+ add('reset');
+ }
+
+
+ if (html) {
+ if (Ext.isStrict && (Ext.isIE6 || Ext.isIE7)) {
+ Ext.isBorderBox = false;
+ }
+ else {
+ Ext.isBorderBox = true;
+ }
+
+ if(Ext.isBorderBox) {
+ htmlCls.push(baseCSSPrefix + 'border-box');
+ }
+ if (Ext.isStrict) {
+ htmlCls.push(baseCSSPrefix + 'strict');
+ } else {
+ htmlCls.push(baseCSSPrefix + 'quirks');
+ }
+ Ext.fly(html, '_internal').addCls(htmlCls);
+ }
+
+ Ext.fly(bd, '_internal').addCls(cls);
+ return true;
+ };
+
+ Ext.apply(EventManager, {
+
+ hasBoundOnReady: false,
+
+
+ hasFiredReady: false,
+
+
+ deferReadyEvent : 1,
+
+
+ onReadyChain : [],
+
+
+ readyEvent:
+ (function () {
+ var event = new Ext.util.Event();
+ event.fire = function () {
+ Ext._beforeReadyTime = Ext._beforeReadyTime || new Date().getTime();
+ event.self.prototype.fire.apply(event, arguments);
+ Ext._afterReadytime = new Date().getTime();
+ };
+ return event;
+ }()),
+
+
+ idleEvent: new Ext.util.Event(),
+
+
+ isReadyPaused: function(){
+ return (/[?&]ext-pauseReadyFire\b/i.test(location.search) && !Ext._continueFireReady);
+ },
+
+
+ bindReadyEvent: function() {
+ if (EventManager.hasBoundOnReady) {
+ return;
+ }
+
+
+ if ( doc.readyState == 'complete' ) {
+ EventManager.onReadyEvent({
+ type: doc.readyState || 'body'
+ });
+ } else {
+ document.addEventListener('DOMContentLoaded', EventManager.onReadyEvent, false);
+ window.addEventListener('load', EventManager.onReadyEvent, false);
+ EventManager.hasBoundOnReady = true;
+ }
+ },
+
+ onReadyEvent : function(e) {
+ if (e && e.type) {
+ EventManager.onReadyChain.push(e.type);
+ }
+
+ if (EventManager.hasBoundOnReady) {
+ document.removeEventListener('DOMContentLoaded', EventManager.onReadyEvent, false);
+ window.removeEventListener('load', EventManager.onReadyEvent, false);
+ }
+
+ if (!Ext.isReady) {
+ EventManager.fireDocReady();
+ }
+ },
+
+
+ fireDocReady: function() {
+ if (!Ext.isReady) {
+ Ext._readyTime = new Date().getTime();
+ Ext.isReady = true;
+
+ Ext.supports.init();
+ EventManager.onWindowUnload();
+ EventManager.readyEvent.onReadyChain = EventManager.onReadyChain;
+
+ if (Ext.isNumber(EventManager.deferReadyEvent)) {
+ Ext.Function.defer(EventManager.fireReadyEvent, EventManager.deferReadyEvent);
+ EventManager.hasDocReadyTimer = true;
+ } else {
+ EventManager.fireReadyEvent();
+ }
+ }
+ },
+
+
+ fireReadyEvent: function(){
+ var readyEvent = EventManager.readyEvent;
+
+
+
+ EventManager.hasDocReadyTimer = false;
+ EventManager.isFiring = true;
+
+
+
+
+ while (readyEvent.listeners.length && !EventManager.isReadyPaused()) {
+ readyEvent.fire();
+ }
+ EventManager.isFiring = false;
+ EventManager.hasFiredReady = true;
+ },
+
+
+ onDocumentReady: function(fn, scope, options) {
+ options = options || {};
+
+ options.single = true;
+ EventManager.readyEvent.addListener(fn, scope, options);
+
+
+
+ if (!(EventManager.isFiring || EventManager.hasDocReadyTimer)) {
+ if (Ext.isReady) {
+ EventManager.fireReadyEvent();
+ } else {
+ EventManager.bindReadyEvent();
+ }
+ }
+ },
+
+
+
+
+ stoppedMouseDownEvent: new Ext.util.Event(),
+
+
+ propRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|freezeEvent)$/,
+
+
+ getId : function(element) {
+ var id;
+
+ element = Ext.getDom(element);
+
+ if (element === doc || element === win) {
+ id = element === doc ? Ext.documentId : Ext.windowId;
+ }
+ else {
+ id = Ext.id(element);
+ }
+
+ if (!Ext.cache[id]) {
+ Ext.addCacheEntry(id, null, element);
+ }
+
+ return id;
+ },
+
+
+ prepareListenerConfig: function(element, config, isRemove) {
+ var propRe = EventManager.propRe,
+ key, value, args;
+
+
+ for (key in config) {
+ if (config.hasOwnProperty(key)) {
+
+ if (!propRe.test(key)) {
+ value = config[key];
+
+
+ if (typeof value == 'function') {
+
+ args = [element, key, value, config.scope, config];
+ } else {
+
+ args = [element, key, value.fn, value.scope, value];
+ }
+
+ if (isRemove) {
+ EventManager.removeListener.apply(EventManager, args);
+ } else {
+ EventManager.addListener.apply(EventManager, args);
+ }
+ }
+ }
+ }
+ },
+
+ mouseEnterLeaveRe: /mouseenter|mouseleave/,
+
+
+ normalizeEvent: function(eventName, fn) {
+ if (EventManager.mouseEnterLeaveRe.test(eventName) && !Ext.supports.MouseEnterLeave) {
+ if (fn) {
+ fn = Ext.Function.createInterceptor(fn, EventManager.contains);
+ }
+ eventName = eventName == 'mouseenter' ? 'mouseover' : 'mouseout';
+ } else if (eventName == 'mousewheel' && !Ext.supports.MouseWheel && !Ext.isOpera) {
+ eventName = 'DOMMouseScroll';
+ }
+ return {
+ eventName: eventName,
+ fn: fn
+ };
+ },
+
+
+ contains: function(event) {
+ var parent = event.browserEvent.currentTarget,
+ child = EventManager.getRelatedTarget(event);
+
+ if (parent && parent.firstChild) {
+ while (child) {
+ if (child === parent) {
+ return false;
+ }
+ child = child.parentNode;
+ if (child && (child.nodeType != 1)) {
+ child = null;
+ }
+ }
+ }
+ return true;
+ },
+
+
+ addListener: function(element, eventName, fn, scope, options) {
+
+ if (typeof eventName !== 'string') {
+ EventManager.prepareListenerConfig(element, eventName);
+ return;
+ }
+
+ var dom = element.dom || Ext.getDom(element),
+ bind, wrap;
+
+
+
+ options = options || {};
+
+ bind = EventManager.normalizeEvent(eventName, fn);
+ wrap = EventManager.createListenerWrap(dom, eventName, bind.fn, scope, options);
+
+ if (dom.attachEvent) {
+ dom.attachEvent('on' + bind.eventName, wrap);
+ } else {
+ dom.addEventListener(bind.eventName, wrap, options.capture || false);
+ }
+
+ if (dom == doc && eventName == 'mousedown') {
+ EventManager.stoppedMouseDownEvent.addListener(wrap);
+ }
+
+
+ EventManager.getEventListenerCache(element.dom ? element : dom, eventName).push({
+ fn: fn,
+ wrap: wrap,
+ scope: scope
+ });
+ },
+
+
+ removeListener : function(element, eventName, fn, scope) {
+
+ if (typeof eventName !== 'string') {
+ EventManager.prepareListenerConfig(element, eventName, true);
+ return;
+ }
+
+ var dom = Ext.getDom(element),
+ el = element.dom ? element : Ext.get(dom),
+ cache = EventManager.getEventListenerCache(el, eventName),
+ bindName = EventManager.normalizeEvent(eventName).eventName,
+ i = cache.length, j,
+ listener, wrap, tasks;
+
+
+ while (i--) {
+ listener = cache[i];
+
+ if (listener && (!fn || listener.fn == fn) && (!scope || listener.scope === scope)) {
+ wrap = listener.wrap;
+
+
+ if (wrap.task) {
+ clearTimeout(wrap.task);
+ delete wrap.task;
+ }
+
+
+ j = wrap.tasks && wrap.tasks.length;
+ if (j) {
+ while (j--) {
+ clearTimeout(wrap.tasks[j]);
+ }
+ delete wrap.tasks;
+ }
+
+ if (dom.detachEvent) {
+ dom.detachEvent('on' + bindName, wrap);
+ } else {
+ dom.removeEventListener(bindName, wrap, false);
+ }
+
+ if (wrap && dom == doc && eventName == 'mousedown') {
+ EventManager.stoppedMouseDownEvent.removeListener(wrap);
+ }
+
+
+ Ext.Array.erase(cache, i, 1);
+ }
+ }
+ },
+
+
+ removeAll : function(element) {
+ var el = element.dom ? element : Ext.get(element),
+ cache, events, eventName;
+
+ if (!el) {
+ return;
+ }
+ cache = (el.$cache || el.getCache());
+ events = cache.events;
+
+ for (eventName in events) {
+ if (events.hasOwnProperty(eventName)) {
+ EventManager.removeListener(el, eventName);
+ }
+ }
+ cache.events = {};
+ },
+
+
+ purgeElement : function(element, eventName) {
+ var dom = Ext.getDom(element),
+ i = 0, len;
+
+ if (eventName) {
+ EventManager.removeListener(element, eventName);
+ }
+ else {
+ EventManager.removeAll(element);
+ }
+
+ if (dom && dom.childNodes) {
+ for (len = element.childNodes.length; i < len; i++) {
+ EventManager.purgeElement(element.childNodes[i], eventName);
+ }
+ }
+ },
+
+
+ createListenerWrap : function(dom, ename, fn, scope, options) {
+ options = options || {};
+
+ var f, gen, escapeRx = /\\/g, wrap = function(e, args) {
+
+ if (!gen) {
+ f = ['if(!' + Ext.name + ') {return;}'];
+
+ if(options.buffer || options.delay || options.freezeEvent) {
+ f.push('e = new X.EventObjectImpl(e, ' + (options.freezeEvent ? 'true' : 'false' ) + ');');
+ } else {
+ f.push('e = X.EventObject.setEvent(e);');
+ }
+
+ if (options.delegate) {
+
+
+ f.push('var result, t = e.getTarget("' + (options.delegate + '').replace(escapeRx, '\\\\') + '", this);');
+ f.push('if(!t) {return;}');
+ } else {
+ f.push('var t = e.target, result;');
+ }
+
+ if (options.target) {
+ f.push('if(e.target !== options.target) {return;}');
+ }
+
+ if(options.stopEvent) {
+ f.push('e.stopEvent();');
+ } else {
+ if(options.preventDefault) {
+ f.push('e.preventDefault();');
+ }
+ if(options.stopPropagation) {
+ f.push('e.stopPropagation();');
+ }
+ }
+
+ if(options.normalized === false) {
+ f.push('e = e.browserEvent;');
+ }
+
+ if(options.buffer) {
+ f.push('(wrap.task && clearTimeout(wrap.task));');
+ f.push('wrap.task = setTimeout(function() {');
+ }
+
+ if(options.delay) {
+ f.push('wrap.tasks = wrap.tasks || [];');
+ f.push('wrap.tasks.push(setTimeout(function() {');
+ }
+
+
+ f.push('result = fn.call(scope || dom, e, t, options);');
+
+ if(options.single) {
+ f.push('evtMgr.removeListener(dom, ename, fn, scope);');
+ }
+
+
+
+ if (ename !== 'mousemove') {
+ f.push('if (evtMgr.idleEvent.listeners.length) {');
+ f.push('evtMgr.idleEvent.fire();');
+ f.push('}');
+ }
+
+ if(options.delay) {
+ f.push('}, ' + options.delay + '));');
+ }
+
+ if(options.buffer) {
+ f.push('}, ' + options.buffer + ');');
+ }
+ f.push('return result;')
+
+ gen = Ext.cacheableFunctionFactory('e', 'options', 'fn', 'scope', 'ename', 'dom', 'wrap', 'args', 'X', 'evtMgr', f.join('\n'));
+ }
+
+ return gen.call(dom, e, options, fn, scope, ename, dom, wrap, args, Ext, EventManager);
+ };
+ return wrap;
+ },
+
+
+ getEventListenerCache : function(element, eventName) {
+ var elementCache, eventCache;
+ if (!element) {
+ return [];
+ }
+
+ if (element.$cache) {
+ elementCache = element.$cache;
+ } else {
+
+ elementCache = Ext.cache[EventManager.getId(element)];
+ }
+ eventCache = elementCache.events || (elementCache.events = {});
+
+ return eventCache[eventName] || (eventCache[eventName] = []);
+ },
+
+
+ mouseLeaveRe: /(mouseout|mouseleave)/,
+ mouseEnterRe: /(mouseover|mouseenter)/,
+
+
+ stopEvent: function(event) {
+ EventManager.stopPropagation(event);
+ EventManager.preventDefault(event);
+ },
+
+
+ stopPropagation: function(event) {
+ event = event.browserEvent || event;
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ } else {
+ event.cancelBubble = true;
+ }
+ },
+
+
+ preventDefault: function(event) {
+ event = event.browserEvent || event;
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else {
+ event.returnValue = false;
+
+ try {
+
+ if (event.ctrlKey || event.keyCode > 111 && event.keyCode < 124) {
+ event.keyCode = -1;
+ }
+ } catch (e) {
+
+ }
+ }
+ },
+
+
+ getRelatedTarget: function(event) {
+ event = event.browserEvent || event;
+ var target = event.relatedTarget;
+ if (!target) {
+ if (EventManager.mouseLeaveRe.test(event.type)) {
+ target = event.toElement;
+ } else if (EventManager.mouseEnterRe.test(event.type)) {
+ target = event.fromElement;
+ }
+ }
+ return EventManager.resolveTextNode(target);
+ },
+
+
+ getPageX: function(event) {
+ return EventManager.getPageXY(event)[0];
+ },
+
+
+ getPageY: function(event) {
+ return EventManager.getPageXY(event)[1];
+ },
+
+
+ getPageXY: function(event) {
+ event = event.browserEvent || event;
+ var x = event.pageX,
+ y = event.pageY,
+ docEl = doc.documentElement,
+ body = doc.body;
+
+
+ if (!x && x !== 0) {
+ x = event.clientX + (docEl && docEl.scrollLeft || body && body.scrollLeft || 0) - (docEl && docEl.clientLeft || body && body.clientLeft || 0);
+ y = event.clientY + (docEl && docEl.scrollTop || body && body.scrollTop || 0) - (docEl && docEl.clientTop || body && body.clientTop || 0);
+ }
+ return [x, y];
+ },
+
+
+ getTarget: function(event) {
+ event = event.browserEvent || event;
+ return EventManager.resolveTextNode(event.target || event.srcElement);
+ },
+
+
+
+
+
+ resolveTextNode: Ext.isGecko ?
+ function(node) {
+ if (!node) {
+ return;
+ }
+
+ var s = HTMLElement.prototype.toString.call(node);
+ if (s == '[xpconnect wrapped native prototype]' || s == '[object XULElement]') {
+ return;
+ }
+ return node.nodeType == 3 ? node.parentNode: node;
+ }: function(node) {
+ return node && node.nodeType == 3 ? node.parentNode: node;
+ },
+
+
+
+
+ curWidth: 0,
+ curHeight: 0,
+
+
+ onWindowResize: function(fn, scope, options) {
+ var resize = EventManager.resizeEvent;
+
+ if (!resize) {
+ EventManager.resizeEvent = resize = new Ext.util.Event();
+ EventManager.on(win, 'resize', EventManager.fireResize, null, {buffer: 100});
+ }
+ resize.addListener(fn, scope, options);
+ },
+
+
+ fireResize: function() {
+ var w = Ext.Element.getViewWidth(),
+ h = Ext.Element.getViewHeight();
+
+
+ if (EventManager.curHeight != h || EventManager.curWidth != w) {
+ EventManager.curHeight = h;
+ EventManager.curWidth = w;
+ EventManager.resizeEvent.fire(w, h);
+ }
+ },
+
+
+ removeResizeListener: function(fn, scope) {
+ var resize = EventManager.resizeEvent;
+ if (resize) {
+ resize.removeListener(fn, scope);
+ }
+ },
+
+
+ onWindowUnload: function(fn, scope, options) {
+ var unload = EventManager.unloadEvent;
+
+ if (!unload) {
+ EventManager.unloadEvent = unload = new Ext.util.Event();
+ EventManager.addListener(win, 'unload', EventManager.fireUnload);
+ }
+ if (fn) {
+ unload.addListener(fn, scope, options);
+ }
+ },
+
+
+ fireUnload: function() {
+
+ try {
+
+ doc = win = undefined;
+
+ var gridviews, i, ln,
+ el, cache;
+
+ EventManager.unloadEvent.fire();
+
+ if (Ext.isGecko3) {
+ gridviews = Ext.ComponentQuery.query('gridview');
+ i = 0;
+ ln = gridviews.length;
+ for (; i < ln; i++) {
+ gridviews[i].scrollToTop();
+ }
+ }
+
+ cache = Ext.cache;
+
+ for (el in cache) {
+ if (cache.hasOwnProperty(el)) {
+ EventManager.removeAll(el);
+ }
+ }
+ } catch(e) {
+ }
+ },
+
+
+ removeUnloadListener: function(fn, scope) {
+ var unload = EventManager.unloadEvent;
+ if (unload) {
+ unload.removeListener(fn, scope);
+ }
+ },
+
+
+ useKeyDown: Ext.isWebKit ?
+ parseInt(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1], 10) >= 525 :
+ !((Ext.isGecko && !Ext.isWindows) || Ext.isOpera),
+
+
+ getKeyEvent: function() {
+ return EventManager.useKeyDown ? 'keydown' : 'keypress';
+ }
+ });
+
+
+ if(!('addEventListener' in document) && document.attachEvent) {
+ Ext.apply( EventManager, {
+
+
+
+ pollScroll : function() {
+ var scrollable = true;
+
+ try {
+ document.documentElement.doScroll('left');
+ } catch(e) {
+ scrollable = false;
+ }
+
+
+ if (scrollable && document.body) {
+ EventManager.onReadyEvent({
+ type:'doScroll'
+ });
+ } else {
+
+ EventManager.scrollTimeout = setTimeout(EventManager.pollScroll, 20);
+ }
+
+ return scrollable;
+ },
+
+
+ scrollTimeout: null,
+
+
+ readyStatesRe : /complete/i,
+
+
+ checkReadyState: function() {
+ var state = document.readyState;
+
+ if (EventManager.readyStatesRe.test(state)) {
+ EventManager.onReadyEvent({
+ type: state
+ });
+ }
+ },
+
+ bindReadyEvent: function() {
+ var topContext = true;
+
+ if (EventManager.hasBoundOnReady) {
+ return;
+ }
+
+
+ try {
+ topContext = window.frameElement === undefined;
+ } catch(e) {
+
+
+ topContext = false;
+ }
+
+ if (!topContext || !doc.documentElement.doScroll) {
+ EventManager.pollScroll = Ext.emptyFn;
+ }
+
+
+ if (EventManager.pollScroll() === true) {
+ return;
+ }
+
+
+ if (doc.readyState == 'complete' ) {
+ EventManager.onReadyEvent({type: 'already ' + (doc.readyState || 'body') });
+ } else {
+ doc.attachEvent('onreadystatechange', EventManager.checkReadyState);
+ window.attachEvent('onload', EventManager.onReadyEvent);
+ EventManager.hasBoundOnReady = true;
+ }
+ },
+
+ onReadyEvent : function(e) {
+ if (e && e.type) {
+ EventManager.onReadyChain.push(e.type);
+ }
+
+ if (EventManager.hasBoundOnReady) {
+ document.detachEvent('onreadystatechange', EventManager.checkReadyState);
+ window.detachEvent('onload', EventManager.onReadyEvent);
+ }
+
+ if (Ext.isNumber(EventManager.scrollTimeout)) {
+ clearTimeout(EventManager.scrollTimeout);
+ delete EventManager.scrollTimeout;
+ }
+
+ if (!Ext.isReady) {
+ EventManager.fireDocReady();
+ }
+ },
+
+
+ onReadyChain : []
+ });
+ }
+
+
+
+ Ext.onReady = function(fn, scope, options) {
+ Ext.Loader.onReady(fn, scope, true, options);
+ };
+
+
+ Ext.onDocumentReady = EventManager.onDocumentReady;
+
+
+ EventManager.on = EventManager.addListener;
+
+
+ EventManager.un = EventManager.removeListener;
+
+ Ext.onReady(initExtCss);
+};
+
+//@tag dom,core
+
+//@require EventManager.js
+
+//@define Ext.EventObject
+
+
+
+Ext.define('Ext.EventObjectImpl', {
+ uses: ['Ext.util.Point'],
+
+
+ BACKSPACE: 8,
+
+ TAB: 9,
+
+ NUM_CENTER: 12,
+
+ ENTER: 13,
+
+ RETURN: 13,
+
+ SHIFT: 16,
+
+ CTRL: 17,
+
+ ALT: 18,
+
+ PAUSE: 19,
+
+ CAPS_LOCK: 20,
+
+ ESC: 27,
+
+ SPACE: 32,
+
+ PAGE_UP: 33,
+
+ PAGE_DOWN: 34,
+
+ END: 35,
+
+ HOME: 36,
+
+ LEFT: 37,
+
+ UP: 38,
+
+ RIGHT: 39,
+
+ DOWN: 40,
+
+ PRINT_SCREEN: 44,
+
+ INSERT: 45,
+
+ DELETE: 46,
+
+ ZERO: 48,
+
+ ONE: 49,
+
+ TWO: 50,
+
+ THREE: 51,
+
+ FOUR: 52,
+
+ FIVE: 53,
+
+ SIX: 54,
+
+ SEVEN: 55,
+
+ EIGHT: 56,
+
+ NINE: 57,
+
+ A: 65,
+
+ B: 66,
+
+ C: 67,
+
+ D: 68,
+
+ E: 69,
+
+ F: 70,
+
+ G: 71,
+
+ H: 72,
+
+ I: 73,
+
+ J: 74,
+
+ K: 75,
+
+ L: 76,
+
+ M: 77,
+
+ N: 78,
+
+ O: 79,
+
+ P: 80,
+
+ Q: 81,
+
+ R: 82,
+
+ S: 83,
+
+ T: 84,
+
+ U: 85,
+
+ V: 86,
+
+ W: 87,
+
+ X: 88,
+
+ Y: 89,
+
+ Z: 90,
+
+ CONTEXT_MENU: 93,
+
+ NUM_ZERO: 96,
+
+ NUM_ONE: 97,
+
+ NUM_TWO: 98,
+
+ NUM_THREE: 99,
+
+ NUM_FOUR: 100,
+
+ NUM_FIVE: 101,
+
+ NUM_SIX: 102,
+
+ NUM_SEVEN: 103,
+
+ NUM_EIGHT: 104,
+
+ NUM_NINE: 105,
+
+ NUM_MULTIPLY: 106,
+
+ NUM_PLUS: 107,
+
+ NUM_MINUS: 109,
+
+ NUM_PERIOD: 110,
+
+ NUM_DIVISION: 111,
+
+ F1: 112,
+
+ F2: 113,
+
+ F3: 114,
+
+ F4: 115,
+
+ F5: 116,
+
+ F6: 117,
+
+ F7: 118,
+
+ F8: 119,
+
+ F9: 120,
+
+ F10: 121,
+
+ F11: 122,
+
+ F12: 123,
+
+ WHEEL_SCALE: (function () {
+ var scale;
+
+ if (Ext.isGecko) {
+
+ scale = 3;
+ } else if (Ext.isMac) {
+
+
+
+
+ if (Ext.isSafari && Ext.webKitVersion >= 532.0) {
+
+
+
+
+
+
+ scale = 120;
+ } else {
+
+
+ scale = 12;
+ }
+
+
+
+
+
+ scale *= 3;
+ } else {
+
+ scale = 120;
+ }
+
+ return scale;
+ }()),
+
+
+ clickRe: /(dbl)?click/,
+
+ safariKeys: {
+ 3: 13,
+ 63234: 37,
+ 63235: 39,
+ 63232: 38,
+ 63233: 40,
+ 63276: 33,
+ 63277: 34,
+ 63272: 46,
+ 63273: 36,
+ 63275: 35
+ },
+
+ btnMap: Ext.isIE ? {
+ 1: 0,
+ 4: 1,
+ 2: 2
+ } : {
+ 0: 0,
+ 1: 1,
+ 2: 2
+ },
+
+
+
+
+
+ constructor: function(event, freezeEvent){
+ if (event) {
+ this.setEvent(event.browserEvent || event, freezeEvent);
+ }
+ },
+
+ setEvent: function(event, freezeEvent){
+ var me = this, button, options;
+
+ if (event == me || (event && event.browserEvent)) {
+ return event;
+ }
+ me.browserEvent = event;
+ if (event) {
+
+ button = event.button ? me.btnMap[event.button] : (event.which ? event.which - 1 : -1);
+ if (me.clickRe.test(event.type) && button == -1) {
+ button = 0;
+ }
+ options = {
+ type: event.type,
+ button: button,
+ shiftKey: event.shiftKey,
+
+ ctrlKey: event.ctrlKey || event.metaKey || false,
+ altKey: event.altKey,
+
+ keyCode: event.keyCode,
+ charCode: event.charCode,
+
+ target: Ext.EventManager.getTarget(event),
+ relatedTarget: Ext.EventManager.getRelatedTarget(event),
+ currentTarget: event.currentTarget,
+ xy: (freezeEvent ? me.getXY() : null)
+ };
+ } else {
+ options = {
+ button: -1,
+ shiftKey: false,
+ ctrlKey: false,
+ altKey: false,
+ keyCode: 0,
+ charCode: 0,
+ target: null,
+ xy: [0, 0]
+ };
+ }
+ Ext.apply(me, options);
+ return me;
+ },
+
+
+ stopEvent: function(){
+ this.stopPropagation();
+ this.preventDefault();
+ },
+
+
+ preventDefault: function(){
+ if (this.browserEvent) {
+ Ext.EventManager.preventDefault(this.browserEvent);
+ }
+ },
+
+
+ stopPropagation: function(){
+ var browserEvent = this.browserEvent;
+
+ if (browserEvent) {
+ if (browserEvent.type == 'mousedown') {
+ Ext.EventManager.stoppedMouseDownEvent.fire(this);
+ }
+ Ext.EventManager.stopPropagation(browserEvent);
+ }
+ },
+
+
+ getCharCode: function(){
+ return this.charCode || this.keyCode;
+ },
+
+
+ getKey: function(){
+ return this.normalizeKey(this.keyCode || this.charCode);
+ },
+
+
+ normalizeKey: function(key){
+
+ return Ext.isWebKit ? (this.safariKeys[key] || key) : key;
+ },
+
+
+ getPageX: function(){
+ return this.getX();
+ },
+
+
+ getPageY: function(){
+ return this.getY();
+ },
+
+
+ getX: function() {
+ return this.getXY()[0];
+ },
+
+
+ getY: function() {
+ return this.getXY()[1];
+ },
+
+
+ getXY: function() {
+ if (!this.xy) {
+
+ this.xy = Ext.EventManager.getPageXY(this.browserEvent);
+ }
+ return this.xy;
+ },
+
+
+ getTarget : function(selector, maxDepth, returnEl){
+ if (selector) {
+ return Ext.fly(this.target).findParent(selector, maxDepth, returnEl);
+ }
+ return returnEl ? Ext.get(this.target) : this.target;
+ },
+
+
+ getRelatedTarget : function(selector, maxDepth, returnEl){
+ if (selector) {
+ return Ext.fly(this.relatedTarget).findParent(selector, maxDepth, returnEl);
+ }
+ return returnEl ? Ext.get(this.relatedTarget) : this.relatedTarget;
+ },
+
+
+ correctWheelDelta : function (delta) {
+ var scale = this.WHEEL_SCALE,
+ ret = Math.round(delta / scale);
+
+ if (!ret && delta) {
+ ret = (delta < 0) ? -1 : 1;
+ }
+
+ return ret;
+ },
+
+
+ getWheelDeltas : function () {
+ var me = this,
+ event = me.browserEvent,
+ dx = 0, dy = 0;
+
+ if (Ext.isDefined(event.wheelDeltaX)) {
+ dx = event.wheelDeltaX;
+ dy = event.wheelDeltaY;
+ } else if (event.wheelDelta) {
+ dy = event.wheelDelta;
+ } else if (event.detail) {
+ dy = -event.detail;
+
+
+
+ if (dy > 100) {
+ dy = 3;
+ } else if (dy < -100) {
+ dy = -3;
+ }
+
+
+
+ if (Ext.isDefined(event.axis) && event.axis === event.HORIZONTAL_AXIS) {
+ dx = dy;
+ dy = 0;
+ }
+ }
+
+ return {
+ x: me.correctWheelDelta(dx),
+ y: me.correctWheelDelta(dy)
+ };
+ },
+
+
+ getWheelDelta : function(){
+ var deltas = this.getWheelDeltas();
+
+ return deltas.y;
+ },
+
+
+ within : function(el, related, allowEl){
+ if(el){
+ var t = related ? this.getRelatedTarget() : this.getTarget(),
+ result;
+
+ if (t) {
+ result = Ext.fly(el).contains(t);
+ if (!result && allowEl) {
+ result = t == Ext.getDom(el);
+ }
+ return result;
+ }
+ }
+ return false;
+ },
+
+
+ isNavKeyPress : function(){
+ var me = this,
+ k = this.normalizeKey(me.keyCode);
+
+ return (k >= 33 && k <= 40) ||
+ k == me.RETURN ||
+ k == me.TAB ||
+ k == me.ESC;
+ },
+
+
+ isSpecialKey : function(){
+ var k = this.normalizeKey(this.keyCode);
+ return (this.type == 'keypress' && this.ctrlKey) ||
+ this.isNavKeyPress() ||
+ (k == this.BACKSPACE) ||
+ (k >= 16 && k <= 20) ||
+ (k >= 44 && k <= 46);
+ },
+
+
+ getPoint : function(){
+ var xy = this.getXY();
+ return new Ext.util.Point(xy[0], xy[1]);
+ },
+
+
+ hasModifier : function(){
+ return this.ctrlKey || this.altKey || this.shiftKey || this.metaKey;
+ },
+
+
+ injectEvent: (function () {
+ var API,
+ dispatchers = {},
+ crazyIEButtons;
+
+
+
+
+
+
+ if (!Ext.isIE && document.createEvent) {
+ API = {
+ createHtmlEvent: function (doc, type, bubbles, cancelable) {
+ var event = doc.createEvent('HTMLEvents');
+
+ event.initEvent(type, bubbles, cancelable);
+ return event;
+ },
+
+ createMouseEvent: function (doc, type, bubbles, cancelable, detail,
+ clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
+ button, relatedTarget) {
+ var event = doc.createEvent('MouseEvents'),
+ view = doc.defaultView || window;
+
+ if (event.initMouseEvent) {
+ event.initMouseEvent(type, bubbles, cancelable, view, detail,
+ clientX, clientY, clientX, clientY, ctrlKey, altKey,
+ shiftKey, metaKey, button, relatedTarget);
+ } else {
+ event = doc.createEvent('UIEvents');
+ event.initEvent(type, bubbles, cancelable);
+ event.view = view;
+ event.detail = detail;
+ event.screenX = clientX;
+ event.screenY = clientY;
+ event.clientX = clientX;
+ event.clientY = clientY;
+ event.ctrlKey = ctrlKey;
+ event.altKey = altKey;
+ event.metaKey = metaKey;
+ event.shiftKey = shiftKey;
+ event.button = button;
+ event.relatedTarget = relatedTarget;
+ }
+
+ return event;
+ },
+
+ createUIEvent: function (doc, type, bubbles, cancelable, detail) {
+ var event = doc.createEvent('UIEvents'),
+ view = doc.defaultView || window;
+
+ event.initUIEvent(type, bubbles, cancelable, view, detail);
+ return event;
+ },
+
+ fireEvent: function (target, type, event) {
+ target.dispatchEvent(event);
+ },
+
+ fixTarget: function (target) {
+
+ if (target == window && !target.dispatchEvent) {
+ return document;
+ }
+
+ return target;
+ }
+ };
+ } else if (document.createEventObject) {
+ crazyIEButtons = { 0: 1, 1: 4, 2: 2 };
+
+ API = {
+ createHtmlEvent: function (doc, type, bubbles, cancelable) {
+ var event = doc.createEventObject();
+ event.bubbles = bubbles;
+ event.cancelable = cancelable;
+ return event;
+ },
+
+ createMouseEvent: function (doc, type, bubbles, cancelable, detail,
+ clientX, clientY, ctrlKey, altKey, shiftKey, metaKey,
+ button, relatedTarget) {
+ var event = doc.createEventObject();
+ event.bubbles = bubbles;
+ event.cancelable = cancelable;
+ event.detail = detail;
+ event.screenX = clientX;
+ event.screenY = clientY;
+ event.clientX = clientX;
+ event.clientY = clientY;
+ event.ctrlKey = ctrlKey;
+ event.altKey = altKey;
+ event.shiftKey = shiftKey;
+ event.metaKey = metaKey;
+ event.button = crazyIEButtons[button] || button;
+ event.relatedTarget = relatedTarget;
+ return event;
+ },
+
+ createUIEvent: function (doc, type, bubbles, cancelable, detail) {
+ var event = doc.createEventObject();
+ event.bubbles = bubbles;
+ event.cancelable = cancelable;
+ return event;
+ },
+
+ fireEvent: function (target, type, event) {
+ target.fireEvent('on' + type, event);
+ },
+
+ fixTarget: function (target) {
+ if (target == document) {
+
+
+ return document.documentElement;
+ }
+
+ return target;
+ }
+ };
+ }
+
+
+
+
+ Ext.Object.each({
+ load: [false, false],
+ unload: [false, false],
+ select: [true, false],
+ change: [true, false],
+ submit: [true, true],
+ reset: [true, false],
+ resize: [true, false],
+ scroll: [true, false]
+ },
+ function (name, value) {
+ var bubbles = value[0], cancelable = value[1];
+ dispatchers[name] = function (targetEl, srcEvent) {
+ var e = API.createHtmlEvent(name, bubbles, cancelable);
+ API.fireEvent(targetEl, name, e);
+ };
+ });
+
+
+
+
+ function createMouseEventDispatcher (type, detail) {
+ var cancelable = (type != 'mousemove');
+ return function (targetEl, srcEvent) {
+ var xy = srcEvent.getXY(),
+ e = API.createMouseEvent(targetEl.ownerDocument, type, true, cancelable,
+ detail, xy[0], xy[1], srcEvent.ctrlKey, srcEvent.altKey,
+ srcEvent.shiftKey, srcEvent.metaKey, srcEvent.button,
+ srcEvent.relatedTarget);
+ API.fireEvent(targetEl, type, e);
+ };
+ }
+
+ Ext.each(['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mousemove', 'mouseout'],
+ function (eventName) {
+ dispatchers[eventName] = createMouseEventDispatcher(eventName, 1);
+ });
+
+
+
+
+ Ext.Object.each({
+ focusin: [true, false],
+ focusout: [true, false],
+ activate: [true, true],
+ focus: [false, false],
+ blur: [false, false]
+ },
+ function (name, value) {
+ var bubbles = value[0], cancelable = value[1];
+ dispatchers[name] = function (targetEl, srcEvent) {
+ var e = API.createUIEvent(targetEl.ownerDocument, name, bubbles, cancelable, 1);
+ API.fireEvent(targetEl, name, e);
+ };
+ });
+
+
+ if (!API) {
+
+
+ dispatchers = {};
+
+ API = {
+ fixTarget: function (t) {
+ return t;
+ }
+ };
+ }
+
+ function cannotInject (target, srcEvent) {
+ }
+
+ return function (target) {
+ var me = this,
+ dispatcher = dispatchers[me.type] || cannotInject,
+ t = target ? (target.dom || target) : me.getTarget();
+
+ t = API.fixTarget(t);
+ dispatcher(t, me);
+ };
+ }())
+
+}, function() {
+
+Ext.EventObject = new Ext.EventObjectImpl();
+
+});
+
+
+//@tag dom,core
+
+//@require ../EventObject.js
+
+
+
+Ext.define('Ext.dom.AbstractQuery', {
+
+ select: function(q, root) {
+ var results = [],
+ nodes,
+ i,
+ j,
+ qlen,
+ nlen;
+
+ root = root || document;
+
+ if (typeof root == 'string') {
+ root = document.getElementById(root);
+ }
+
+ q = q.split(",");
+
+ for (i = 0,qlen = q.length; i < qlen; i++) {
+ if (typeof q[i] == 'string') {
+
+
+ if (typeof q[i][0] == '@') {
+ nodes = root.getAttributeNode(q[i].substring(1));
+ results.push(nodes);
+ } else {
+ nodes = root.querySelectorAll(q[i]);
+
+ for (j = 0,nlen = nodes.length; j < nlen; j++) {
+ results.push(nodes[j]);
+ }
+ }
+ }
+ }
+
+ return results;
+ },
+
+
+ selectNode: function(q, root) {
+ return this.select(q, root)[0];
+ },
+
+
+ is: function(el, q) {
+ if (typeof el == "string") {
+ el = document.getElementById(el);
+ }
+ return this.select(q).indexOf(el) !== -1;
+ }
+
+});
+
+//@tag dom,core
+
+//@require AbstractQuery.js
+
+
+
+Ext.define('Ext.dom.AbstractHelper', {
+ emptyTags : /^(?:br|frame|hr|img|input|link|meta|range|spacer|wbr|area|param|col)$/i,
+ confRe : /(?:tag|children|cn|html|tpl|tplData)$/i,
+ endRe : /end/i,
+
+
+ attributeTransform: { cls : 'class', htmlFor : 'for' },
+
+ closeTags: {},
+
+ decamelizeName : (function () {
+ var camelCaseRe = /([a-z])([A-Z])/g,
+ cache = {};
+
+ function decamel (match, p1, p2) {
+ return p1 + '-' + p2.toLowerCase();
+ }
+
+ return function (s) {
+ return cache[s] || (cache[s] = s.replace(camelCaseRe, decamel));
+ };
+ }()),
+
+ generateMarkup: function(spec, buffer) {
+ var me = this,
+ attr, val, tag, i, closeTags;
+
+ if (typeof spec == "string") {
+ buffer.push(spec);
+ } else if (Ext.isArray(spec)) {
+ for (i = 0; i < spec.length; i++) {
+ if (spec[i]) {
+ me.generateMarkup(spec[i], buffer);
+ }
+ }
+ } else {
+ tag = spec.tag || 'div';
+ buffer.push('<', tag);
+
+ for (attr in spec) {
+ if (spec.hasOwnProperty(attr)) {
+ val = spec[attr];
+ if (!me.confRe.test(attr)) {
+ if (typeof val == "object") {
+ buffer.push(' ', attr, '="');
+ me.generateStyles(val, buffer).push('"');
+ } else {
+ buffer.push(' ', me.attributeTransform[attr] || attr, '="', val, '"');
+ }
+ }
+ }
+ }
+
+
+ if (me.emptyTags.test(tag)) {
+ buffer.push('/>');
+ } else {
+ buffer.push('>');
+
+
+ if ((val = spec.tpl)) {
+ val.applyOut(spec.tplData, buffer);
+ }
+ if ((val = spec.html)) {
+ buffer.push(val);
+ }
+ if ((val = spec.cn || spec.children)) {
+ me.generateMarkup(val, buffer);
+ }
+
+
+ closeTags = me.closeTags;
+ buffer.push(closeTags[tag] || (closeTags[tag] = ''));
+ }
+ }
+
+ return buffer;
+ },
+
+
+ generateStyles: function (styles, buffer) {
+ var a = buffer || [],
+ name;
+
+ for (name in styles) {
+ if (styles.hasOwnProperty(name)) {
+ a.push(this.decamelizeName(name), ':', styles[name], ';');
+ }
+ }
+
+ return buffer || a.join('');
+ },
+
+
+ markup: function(spec) {
+ if (typeof spec == "string") {
+ return spec;
+ }
+
+ var buf = this.generateMarkup(spec, []);
+ return buf.join('');
+ },
+
+
+ applyStyles: function(el, styles) {
+ if (styles) {
+ var i = 0,
+ len,
+ style;
+
+ el = Ext.fly(el);
+ if (typeof styles == 'function') {
+ styles = styles.call();
+ }
+ if (typeof styles == 'string'){
+ styles = Ext.util.Format.trim(styles).split(/\s*(?::|;)\s*/);
+ for(len = styles.length; i < len;){
+ el.setStyle(styles[i++], styles[i++]);
+ }
+ } else if (Ext.isObject(styles)) {
+ el.setStyle(styles);
+ }
+ }
+ },
+
+
+ insertHtml: function(where, el, html) {
+ var hash = {},
+ hashVal,
+ setStart,
+ range,
+ frag,
+ rangeEl,
+ rs;
+
+ where = where.toLowerCase();
+
+
+ hash['beforebegin'] = ['BeforeBegin', 'previousSibling'];
+ hash['afterend'] = ['AfterEnd', 'nextSibling'];
+
+ range = el.ownerDocument.createRange();
+ setStart = 'setStart' + (this.endRe.test(where) ? 'After' : 'Before');
+ if (hash[where]) {
+ range[setStart](el);
+ frag = range.createContextualFragment(html);
+ el.parentNode.insertBefore(frag, where == 'beforebegin' ? el : el.nextSibling);
+ return el[(where == 'beforebegin' ? 'previous' : 'next') + 'Sibling'];
+ }
+ else {
+ rangeEl = (where == 'afterbegin' ? 'first' : 'last') + 'Child';
+ if (el.firstChild) {
+ range[setStart](el[rangeEl]);
+ frag = range.createContextualFragment(html);
+ if (where == 'afterbegin') {
+ el.insertBefore(frag, el.firstChild);
+ }
+ else {
+ el.appendChild(frag);
+ }
+ }
+ else {
+ el.innerHTML = html;
+ }
+ return el[rangeEl];
+ }
+
+ throw 'Illegal insertion point -> "' + where + '"';
+ },
+
+
+ insertBefore: function(el, o, returnElement) {
+ return this.doInsert(el, o, returnElement, 'beforebegin');
+ },
+
+
+ insertAfter: function(el, o, returnElement) {
+ return this.doInsert(el, o, returnElement, 'afterend', 'nextSibling');
+ },
+
+
+ insertFirst: function(el, o, returnElement) {
+ return this.doInsert(el, o, returnElement, 'afterbegin', 'firstChild');
+ },
+
+
+ append: function(el, o, returnElement) {
+ return this.doInsert(el, o, returnElement, 'beforeend', '', true);
+ },
+
+
+ overwrite: function(el, o, returnElement) {
+ el = Ext.getDom(el);
+ el.innerHTML = this.markup(o);
+ return returnElement ? Ext.get(el.firstChild) : el.firstChild;
+ },
+
+ doInsert: function(el, o, returnElement, pos, sibling, append) {
+ var newNode = this.insertHtml(pos, Ext.getDom(el), this.markup(o));
+ return returnElement ? Ext.get(newNode, true) : newNode;
+ }
+
+});
+
+//@tag dom,core
+
+//@require AbstractHelper.js
+
+//@require Ext.Supports
+
+//@require Ext.EventManager
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function() {
+
+var document = window.document,
+ trimRe = /^\s+|\s+$/g,
+ whitespaceRe = /\s/;
+
+if (!Ext.cache){
+ Ext.cache = {};
+}
+
+Ext.define('Ext.dom.AbstractElement', {
+
+ inheritableStatics: {
+
+
+ get: function(el) {
+ var me = this,
+ El = Ext.dom.Element,
+ cacheItem,
+ extEl,
+ dom,
+ id;
+
+ if (!el) {
+ return null;
+ }
+
+ if (typeof el == "string") {
+ if (el == Ext.windowId) {
+ return El.get(window);
+ } else if (el == Ext.documentId) {
+ return El.get(document);
+ }
+
+ cacheItem = Ext.cache[el];
+
+
+
+
+ if (cacheItem && cacheItem.skipGarbageCollection) {
+ extEl = cacheItem.el;
+ return extEl;
+ }
+
+ if (!(dom = document.getElementById(el))) {
+ return null;
+ }
+
+ if (cacheItem && cacheItem.el) {
+ extEl = Ext.updateCacheEntry(cacheItem, dom).el;
+ } else {
+
+ extEl = new El(dom, !!cacheItem);
+ }
+ return extEl;
+ } else if (el.tagName) {
+ if (!(id = el.id)) {
+ id = Ext.id(el);
+ }
+ cacheItem = Ext.cache[id];
+ if (cacheItem && cacheItem.el) {
+ extEl = Ext.updateCacheEntry(cacheItem, el).el;
+ } else {
+
+ extEl = new El(el, !!cacheItem);
+ }
+ return extEl;
+ } else if (el instanceof me) {
+ if (el != me.docEl && el != me.winEl) {
+ id = el.id;
+
+
+ cacheItem = Ext.cache[id];
+ if (cacheItem) {
+ Ext.updateCacheEntry(cacheItem, document.getElementById(id) || el.dom);
+ }
+ }
+ return el;
+ } else if (el.isComposite) {
+ return el;
+ } else if (Ext.isArray(el)) {
+ return me.select(el);
+ } else if (el === document) {
+
+ if (!me.docEl) {
+ me.docEl = Ext.Object.chain(El.prototype);
+ me.docEl.dom = document;
+ me.docEl.id = Ext.id(document);
+ me.addToCache(me.docEl);
+ }
+ return me.docEl;
+ } else if (el === window) {
+ if (!me.winEl) {
+ me.winEl = Ext.Object.chain(El.prototype);
+ me.winEl.dom = window;
+ me.winEl.id = Ext.id(window);
+ me.addToCache(me.winEl);
+ }
+ return me.winEl;
+ }
+ return null;
+ },
+
+ addToCache: function(el, id) {
+ if (el) {
+ Ext.addCacheEntry(id, el);
+ }
+ return el;
+ },
+
+ addMethods: function() {
+ this.override.apply(this, arguments);
+ },
+
+
+ mergeClsList: function() {
+ var clsList, clsHash = {},
+ i, length, j, listLength, clsName, result = [],
+ changed = false;
+
+ for (i = 0, length = arguments.length; i < length; i++) {
+ clsList = arguments[i];
+ if (Ext.isString(clsList)) {
+ clsList = clsList.replace(trimRe, '').split(whitespaceRe);
+ }
+ if (clsList) {
+ for (j = 0, listLength = clsList.length; j < listLength; j++) {
+ clsName = clsList[j];
+ if (!clsHash[clsName]) {
+ if (i) {
+ changed = true;
+ }
+ clsHash[clsName] = true;
+ }
+ }
+ }
+ }
+
+ for (clsName in clsHash) {
+ result.push(clsName);
+ }
+ result.changed = changed;
+ return result;
+ },
+
+
+ removeCls: function(existingClsList, removeClsList) {
+ var clsHash = {},
+ i, length, clsName, result = [],
+ changed = false;
+
+ if (existingClsList) {
+ if (Ext.isString(existingClsList)) {
+ existingClsList = existingClsList.replace(trimRe, '').split(whitespaceRe);
+ }
+ for (i = 0, length = existingClsList.length; i < length; i++) {
+ clsHash[existingClsList[i]] = true;
+ }
+ }
+ if (removeClsList) {
+ if (Ext.isString(removeClsList)) {
+ removeClsList = removeClsList.split(whitespaceRe);
+ }
+ for (i = 0, length = removeClsList.length; i < length; i++) {
+ clsName = removeClsList[i];
+ if (clsHash[clsName]) {
+ changed = true;
+ delete clsHash[clsName];
+ }
+ }
+ }
+ for (clsName in clsHash) {
+ result.push(clsName);
+ }
+ result.changed = changed;
+ return result;
+ },
+
+
+ VISIBILITY: 1,
+
+
+ DISPLAY: 2,
+
+
+ OFFSETS: 3,
+
+
+ ASCLASS: 4
+ },
+
+ constructor: function(element, forceNew) {
+ var me = this,
+ dom = typeof element == 'string'
+ ? document.getElementById(element)
+ : element,
+ id;
+
+ if (!dom) {
+ return null;
+ }
+
+ id = dom.id;
+ if (!forceNew && id && Ext.cache[id]) {
+
+ return Ext.cache[id].el;
+ }
+
+
+ me.dom = dom;
+
+
+ me.id = id || Ext.id(dom);
+
+ me.self.addToCache(me);
+ },
+
+
+ set: function(o, useSet) {
+ var el = this.dom,
+ attr,
+ value;
+
+ for (attr in o) {
+ if (o.hasOwnProperty(attr)) {
+ value = o[attr];
+ if (attr == 'style') {
+ this.applyStyles(value);
+ }
+ else if (attr == 'cls') {
+ el.className = value;
+ }
+ else if (useSet !== false) {
+ if (value === undefined) {
+ el.removeAttribute(attr);
+ } else {
+ el.setAttribute(attr, value);
+ }
+ }
+ else {
+ el[attr] = value;
+ }
+ }
+ }
+ return this;
+ },
+
+
+ defaultUnit: "px",
+
+
+ is: function(simpleSelector) {
+ return Ext.DomQuery.is(this.dom, simpleSelector);
+ },
+
+
+ getValue: function(asNumber) {
+ var val = this.dom.value;
+ return asNumber ? parseInt(val, 10) : val;
+ },
+
+
+ remove: function() {
+ var me = this,
+ dom = me.dom;
+
+ if (dom) {
+ Ext.removeNode(dom);
+ delete me.dom;
+ }
+ },
+
+
+ contains: function(el) {
+ if (!el) {
+ return false;
+ }
+
+ var me = this,
+ dom = el.dom || el;
+
+
+ return (dom === me.dom) || Ext.dom.AbstractElement.isAncestor(me.dom, dom);
+ },
+
+
+ getAttribute: function(name, ns) {
+ var dom = this.dom;
+ return dom.getAttributeNS(ns, name) || dom.getAttribute(ns + ":" + name) || dom.getAttribute(name) || dom[name];
+ },
+
+
+ update: function(html) {
+ if (this.dom) {
+ this.dom.innerHTML = html;
+ }
+ return this;
+ },
+
+
+
+ setHTML: function(html) {
+ if(this.dom) {
+ this.dom.innerHTML = html;
+ }
+ return this;
+ },
+
+
+ getHTML: function() {
+ return this.dom ? this.dom.innerHTML : '';
+ },
+
+
+ hide: function() {
+ this.setVisible(false);
+ return this;
+ },
+
+
+ show: function() {
+ this.setVisible(true);
+ return this;
+ },
+
+
+ setVisible: function(visible, animate) {
+ var me = this,
+ statics = me.self,
+ mode = me.getVisibilityMode(),
+ prefix = Ext.baseCSSPrefix;
+
+ switch (mode) {
+ case statics.VISIBILITY:
+ me.removeCls([prefix + 'hidden-display', prefix + 'hidden-offsets']);
+ me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-visibility');
+ break;
+
+ case statics.DISPLAY:
+ me.removeCls([prefix + 'hidden-visibility', prefix + 'hidden-offsets']);
+ me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-display');
+ break;
+
+ case statics.OFFSETS:
+ me.removeCls([prefix + 'hidden-visibility', prefix + 'hidden-display']);
+ me[visible ? 'removeCls' : 'addCls'](prefix + 'hidden-offsets');
+ break;
+ }
+
+ return me;
+ },
+
+ getVisibilityMode: function() {
+
+
+
+ var data = (this.$cache || this.getCache()).data,
+ visMode = data.visibilityMode;
+
+ if (visMode === undefined) {
+ data.visibilityMode = visMode = this.self.DISPLAY;
+ }
+
+ return visMode;
+ },
+
+
+ setVisibilityMode: function(mode) {
+ (this.$cache || this.getCache()).data.visibilityMode = mode;
+ return this;
+ },
+
+ getCache: function() {
+ var me = this,
+ id = me.dom.id || Ext.id(me.dom);
+
+
+
+
+ me.$cache = Ext.cache[id] || Ext.addCacheEntry(id, null, me.dom);
+
+ return me.$cache;
+ }
+
+}, function() {
+ var AbstractElement = this;
+
+
+ Ext.getDetachedBody = function () {
+ var detachedEl = AbstractElement.detachedBodyEl;
+
+ if (!detachedEl) {
+ detachedEl = document.createElement('div');
+ AbstractElement.detachedBodyEl = detachedEl = new AbstractElement.Fly(detachedEl);
+ detachedEl.isDetachedBody = true;
+ }
+
+ return detachedEl;
+ };
+
+
+ Ext.getElementById = function (id) {
+ var el = document.getElementById(id),
+ detachedBodyEl;
+
+ if (!el && (detachedBodyEl = AbstractElement.detachedBodyEl)) {
+ el = detachedBodyEl.dom.querySelector('#' + Ext.escapeId(id));
+ }
+
+ return el;
+ };
+
+
+ Ext.get = function(el) {
+ return Ext.dom.Element.get(el);
+ };
+
+ this.addStatics({
+
+ Fly: new Ext.Class({
+ extend: AbstractElement,
+
+
+ isFly: true,
+
+ constructor: function(dom) {
+ this.dom = dom;
+ },
+
+
+ attach: function (dom) {
+
+
+ this.dom = dom;
+
+
+ this.$cache = dom.id ? Ext.cache[dom.id] : null;
+ return this;
+ }
+ }),
+
+ _flyweights: {},
+
+
+ fly: function(dom, named) {
+ var fly = null,
+ _flyweights = AbstractElement._flyweights;
+
+ named = named || '_global';
+
+ dom = Ext.getDom(dom);
+
+ if (dom) {
+ fly = _flyweights[named] || (_flyweights[named] = new AbstractElement.Fly());
+
+
+
+ fly.dom = dom;
+
+
+ fly.$cache = dom.id ? Ext.cache[dom.id] : null;
+ }
+ return fly;
+ }
+ });
+
+
+ Ext.fly = function() {
+ return AbstractElement.fly.apply(AbstractElement, arguments);
+ };
+
+ (function (proto) {
+
+ proto.destroy = proto.remove;
+
+
+ if (document.querySelector) {
+ proto.getById = function (id, asDom) {
+
+
+ var dom = document.getElementById(id) ||
+ this.dom.querySelector('#'+Ext.escapeId(id));
+ return asDom ? dom : (dom ? Ext.get(dom) : null);
+ };
+ } else {
+ proto.getById = function (id, asDom) {
+ var dom = document.getElementById(id);
+ return asDom ? dom : (dom ? Ext.get(dom) : null);
+ };
+ }
+ }(this.prototype));
+});
+
+}());
+
+//@tag dom,core
+
+//@require AbstractElement.js
+
+//@define Ext.dom.AbstractElement-static
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.addInheritableStatics({
+ unitRe: /\d+(px|em|%|en|ex|pt|in|cm|mm|pc)$/i,
+ camelRe: /(-[a-z])/gi,
+ cssRe: /([a-z0-9\-]+)\s*:\s*([^;\s]+(?:\s*[^;\s]+)*);?/gi,
+ opacityRe: /alpha\(opacity=(.*)\)/i,
+ propertyCache: {},
+ defaultUnit : "px",
+ borders: {l: 'border-left-width', r: 'border-right-width', t: 'border-top-width', b: 'border-bottom-width'},
+ paddings: {l: 'padding-left', r: 'padding-right', t: 'padding-top', b: 'padding-bottom'},
+ margins: {l: 'margin-left', r: 'margin-right', t: 'margin-top', b: 'margin-bottom'},
+
+ addUnits: function(size, units) {
+
+ if (typeof size == 'number') {
+ return size + (units || this.defaultUnit || 'px');
+ }
+
+
+ if (size === "" || size == "auto" || size === undefined || size === null) {
+ return size || '';
+ }
+
+
+ if (!this.unitRe.test(size)) {
+ return size || '';
+ }
+
+ return size;
+ },
+
+
+ isAncestor: function(p, c) {
+ var ret = false;
+
+ p = Ext.getDom(p);
+ c = Ext.getDom(c);
+ if (p && c) {
+ if (p.contains) {
+ return p.contains(c);
+ } else if (p.compareDocumentPosition) {
+ return !!(p.compareDocumentPosition(c) & 16);
+ } else {
+ while ((c = c.parentNode)) {
+ ret = c == p || ret;
+ }
+ }
+ }
+ return ret;
+ },
+
+
+ parseBox: function(box) {
+ if (typeof box != 'string') {
+ box = box.toString();
+ }
+ var parts = box.split(' '),
+ ln = parts.length;
+
+ if (ln == 1) {
+ parts[1] = parts[2] = parts[3] = parts[0];
+ }
+ else if (ln == 2) {
+ parts[2] = parts[0];
+ parts[3] = parts[1];
+ }
+ else if (ln == 3) {
+ parts[3] = parts[1];
+ }
+
+ return {
+ top :parseFloat(parts[0]) || 0,
+ right :parseFloat(parts[1]) || 0,
+ bottom:parseFloat(parts[2]) || 0,
+ left :parseFloat(parts[3]) || 0
+ };
+ },
+
+
+ unitizeBox: function(box, units) {
+ var a = this.addUnits,
+ b = this.parseBox(box);
+
+ return a(b.top, units) + ' ' +
+ a(b.right, units) + ' ' +
+ a(b.bottom, units) + ' ' +
+ a(b.left, units);
+
+ },
+
+
+ camelReplaceFn: function(m, a) {
+ return a.charAt(1).toUpperCase();
+ },
+
+
+ normalize: function(prop) {
+
+ if (prop == 'float') {
+ prop = Ext.supports.Float ? 'cssFloat' : 'styleFloat';
+ }
+ return this.propertyCache[prop] || (this.propertyCache[prop] = prop.replace(this.camelRe, this.camelReplaceFn));
+ },
+
+
+ getDocumentHeight: function() {
+ return Math.max(!Ext.isStrict ? document.body.scrollHeight : document.documentElement.scrollHeight, this.getViewportHeight());
+ },
+
+
+ getDocumentWidth: function() {
+ return Math.max(!Ext.isStrict ? document.body.scrollWidth : document.documentElement.scrollWidth, this.getViewportWidth());
+ },
+
+
+ getViewportHeight: function(){
+ return window.innerHeight;
+ },
+
+
+ getViewportWidth: function() {
+ return window.innerWidth;
+ },
+
+
+ getViewSize: function() {
+ return {
+ width: window.innerWidth,
+ height: window.innerHeight
+ };
+ },
+
+
+ getOrientation: function() {
+ if (Ext.supports.OrientationChange) {
+ return (window.orientation == 0) ? 'portrait' : 'landscape';
+ }
+
+ return (window.innerHeight > window.innerWidth) ? 'portrait' : 'landscape';
+ },
+
+
+ fromPoint: function(x, y) {
+ return Ext.get(document.elementFromPoint(x, y));
+ },
+
+
+ parseStyles: function(styles){
+ var out = {},
+ cssRe = this.cssRe,
+ matches;
+
+ if (styles) {
+
+
+
+
+ cssRe.lastIndex = 0;
+ while ((matches = cssRe.exec(styles))) {
+ out[matches[1]] = matches[2];
+ }
+ }
+ return out;
+ }
+});
+
+
+(function(){
+ var doc = document,
+ AbstractElement = Ext.dom.AbstractElement,
+ activeElement = null,
+ isCSS1 = doc.compatMode == "CSS1Compat",
+ flyInstance,
+ fly = function (el) {
+ if (!flyInstance) {
+ flyInstance = new AbstractElement.Fly();
+ }
+ flyInstance.attach(el);
+ return flyInstance;
+ };
+
+
+
+
+ if (!('activeElement' in doc) && doc.addEventListener) {
+ doc.addEventListener('focus',
+ function (ev) {
+ if (ev && ev.target) {
+ activeElement = (ev.target == doc) ? null : ev.target;
+ }
+ }, true);
+ }
+
+
+ function makeSelectionRestoreFn (activeEl, start, end) {
+ return function () {
+ activeEl.selectionStart = start;
+ activeEl.selectionEnd = end;
+ };
+ }
+
+ AbstractElement.addInheritableStatics({
+
+ getActiveElement: function () {
+ return doc.activeElement || activeElement;
+ },
+
+
+ getRightMarginFixCleaner: function (target) {
+ var supports = Ext.supports,
+ hasInputBug = supports.DisplayChangeInputSelectionBug,
+ hasTextAreaBug = supports.DisplayChangeTextAreaSelectionBug,
+ activeEl,
+ tag,
+ start,
+ end;
+
+ if (hasInputBug || hasTextAreaBug) {
+ activeEl = doc.activeElement || activeElement;
+ tag = activeEl && activeEl.tagName;
+
+ if ((hasTextAreaBug && tag == 'TEXTAREA') ||
+ (hasInputBug && tag == 'INPUT' && activeEl.type == 'text')) {
+ if (Ext.dom.Element.isAncestor(target, activeEl)) {
+ start = activeEl.selectionStart;
+ end = activeEl.selectionEnd;
+
+ if (Ext.isNumber(start) && Ext.isNumber(end)) {
+
+
+
+
+ return makeSelectionRestoreFn(activeEl, start, end);
+ }
+ }
+ }
+ }
+
+ return Ext.emptyFn;
+ },
+
+ getViewWidth: function(full) {
+ return full ? Ext.dom.Element.getDocumentWidth() : Ext.dom.Element.getViewportWidth();
+ },
+
+ getViewHeight: function(full) {
+ return full ? Ext.dom.Element.getDocumentHeight() : Ext.dom.Element.getViewportHeight();
+ },
+
+ getDocumentHeight: function() {
+ return Math.max(!isCSS1 ? doc.body.scrollHeight : doc.documentElement.scrollHeight, Ext.dom.Element.getViewportHeight());
+ },
+
+ getDocumentWidth: function() {
+ return Math.max(!isCSS1 ? doc.body.scrollWidth : doc.documentElement.scrollWidth, Ext.dom.Element.getViewportWidth());
+ },
+
+ getViewportHeight: function(){
+ return Ext.isIE ?
+ (Ext.isStrict ? doc.documentElement.clientHeight : doc.body.clientHeight) :
+ self.innerHeight;
+ },
+
+ getViewportWidth: function() {
+ return (!Ext.isStrict && !Ext.isOpera) ? doc.body.clientWidth :
+ Ext.isIE ? doc.documentElement.clientWidth : self.innerWidth;
+ },
+
+ getY: function(el) {
+ return Ext.dom.Element.getXY(el)[1];
+ },
+
+ getX: function(el) {
+ return Ext.dom.Element.getXY(el)[0];
+ },
+
+ getXY: function(el) {
+ var bd = doc.body,
+ docEl = doc.documentElement,
+ leftBorder = 0,
+ topBorder = 0,
+ ret = [0,0],
+ round = Math.round,
+ box,
+ scroll;
+
+ el = Ext.getDom(el);
+
+ if(el != doc && el != bd){
+
+
+ if (Ext.isIE) {
+ try {
+ box = el.getBoundingClientRect();
+
+ topBorder = docEl.clientTop || bd.clientTop;
+ leftBorder = docEl.clientLeft || bd.clientLeft;
+ } catch (ex) {
+ box = { left: 0, top: 0 };
+ }
+ } else {
+ box = el.getBoundingClientRect();
+ }
+
+ scroll = fly(document).getScroll();
+ ret = [round(box.left + scroll.left - leftBorder), round(box.top + scroll.top - topBorder)];
+ }
+ return ret;
+ },
+
+ setXY: function(el, xy) {
+ (el = Ext.fly(el, '_setXY')).position();
+
+ var pts = el.translatePoints(xy),
+ style = el.dom.style,
+ pos;
+
+ for (pos in pts) {
+ if (!isNaN(pts[pos])) {
+ style[pos] = pts[pos] + "px";
+ }
+ }
+ },
+
+ setX: function(el, x) {
+ Ext.dom.Element.setXY(el, [x, false]);
+ },
+
+ setY: function(el, y) {
+ Ext.dom.Element.setXY(el, [false, y]);
+ },
+
+
+ serializeForm: function(form) {
+ var fElements = form.elements || (document.forms[form] || Ext.getDom(form)).elements,
+ hasSubmit = false,
+ encoder = encodeURIComponent,
+ data = '',
+ eLen = fElements.length,
+ element, name, type, options, hasValue, e,
+ o, oLen, opt;
+
+ for (e = 0; e < eLen; e++) {
+ element = fElements[e];
+ name = element.name;
+ type = element.type;
+ options = element.options;
+
+ if (!element.disabled && name) {
+ if (/select-(one|multiple)/i.test(type)) {
+ oLen = options.length;
+ for (o = 0; o < oLen; o++) {
+ opt = options[o];
+ if (opt.selected) {
+ hasValue = opt.hasAttribute ? opt.hasAttribute('value') : opt.getAttributeNode('value').specified;
+ data += Ext.String.format("{0}={1}&", encoder(name), encoder(hasValue ? opt.value : opt.text));
+ }
+ }
+ } else if (!(/file|undefined|reset|button/i.test(type))) {
+ if (!(/radio|checkbox/i.test(type) && !element.checked) && !(type == 'submit' && hasSubmit)) {
+ data += encoder(name) + '=' + encoder(element.value) + '&';
+ hasSubmit = /submit/i.test(type);
+ }
+ }
+ }
+ }
+ return data.substr(0, data.length - 1);
+ }
+ });
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-static
+
+//@define Ext.dom.AbstractElement-alignment
+
+
+
+Ext.dom.AbstractElement.override({
+
+
+ getAnchorXY: function(anchor, local, size) {
+
+
+ anchor = (anchor || "tl").toLowerCase();
+ size = size || {};
+
+ var me = this,
+ vp = me.dom == document.body || me.dom == document,
+ width = size.width || vp ? window.innerWidth: me.getWidth(),
+ height = size.height || vp ? window.innerHeight: me.getHeight(),
+ xy,
+ rnd = Math.round,
+ myXY = me.getXY(),
+ extraX = vp ? 0: !local ? myXY[0] : 0,
+ extraY = vp ? 0: !local ? myXY[1] : 0,
+ hash = {
+ c: [rnd(width * 0.5), rnd(height * 0.5)],
+ t: [rnd(width * 0.5), 0],
+ l: [0, rnd(height * 0.5)],
+ r: [width, rnd(height * 0.5)],
+ b: [rnd(width * 0.5), height],
+ tl: [0, 0],
+ bl: [0, height],
+ br: [width, height],
+ tr: [width, 0]
+ };
+
+ xy = hash[anchor];
+ return [xy[0] + extraX, xy[1] + extraY];
+ },
+
+ alignToRe: /^([a-z]+)-([a-z]+)(\?)?$/,
+
+
+ getAlignToXY: function(el, position, offsets, local) {
+ local = !!local;
+ el = Ext.get(el);
+
+ offsets = offsets || [0, 0];
+
+ if (!position || position == '?') {
+ position = 'tl-bl?';
+ }
+ else if (! (/-/).test(position) && position !== "") {
+ position = 'tl-' + position;
+ }
+ position = position.toLowerCase();
+
+ var me = this,
+ matches = position.match(this.alignToRe),
+ dw = window.innerWidth,
+ dh = window.innerHeight,
+ p1 = "",
+ p2 = "",
+ a1,
+ a2,
+ x,
+ y,
+ swapX,
+ swapY,
+ p1x,
+ p1y,
+ p2x,
+ p2y,
+ width,
+ height,
+ region,
+ constrain;
+
+ if (!matches) {
+ throw "Element.alignTo with an invalid alignment " + position;
+ }
+
+ p1 = matches[1];
+ p2 = matches[2];
+ constrain = !!matches[3];
+
+
+
+ a1 = me.getAnchorXY(p1, true);
+ a2 = el.getAnchorXY(p2, local);
+
+ x = a2[0] - a1[0] + offsets[0];
+ y = a2[1] - a1[1] + offsets[1];
+
+ if (constrain) {
+ width = me.getWidth();
+ height = me.getHeight();
+
+ region = el.getPageBox();
+
+
+
+
+ p1y = p1.charAt(0);
+ p1x = p1.charAt(p1.length - 1);
+ p2y = p2.charAt(0);
+ p2x = p2.charAt(p2.length - 1);
+
+ swapY = ((p1y == "t" && p2y == "b") || (p1y == "b" && p2y == "t"));
+ swapX = ((p1x == "r" && p2x == "l") || (p1x == "l" && p2x == "r"));
+
+ if (x + width > dw) {
+ x = swapX ? region.left - width: dw - width;
+ }
+ if (x < 0) {
+ x = swapX ? region.right: 0;
+ }
+ if (y + height > dh) {
+ y = swapY ? region.top - height: dh - height;
+ }
+ if (y < 0) {
+ y = swapY ? region.bottom: 0;
+ }
+ }
+
+ return [x, y];
+ },
+
+
+ getAnchor: function(){
+ var data = (this.$cache || this.getCache()).data,
+ anchor;
+
+ if (!this.dom) {
+ return;
+ }
+ anchor = data._anchor;
+
+ if(!anchor){
+ anchor = data._anchor = {};
+ }
+ return anchor;
+ },
+
+
+ adjustForConstraints: function(xy, parent) {
+ var vector = this.getConstrainVector(parent, xy);
+ if (vector) {
+ xy[0] += vector[0];
+ xy[1] += vector[1];
+ }
+ return xy;
+ }
+
+});
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-alignment
+
+//@define Ext.dom.AbstractElement-insertion
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.addMethods({
+
+ appendChild: function(el) {
+ return Ext.get(el).appendTo(this);
+ },
+
+
+ appendTo: function(el) {
+ Ext.getDom(el).appendChild(this.dom);
+ return this;
+ },
+
+
+ insertBefore: function(el) {
+ el = Ext.getDom(el);
+ el.parentNode.insertBefore(this.dom, el);
+ return this;
+ },
+
+
+ insertAfter: function(el) {
+ el = Ext.getDom(el);
+ el.parentNode.insertBefore(this.dom, el.nextSibling);
+ return this;
+ },
+
+
+ insertFirst: function(el, returnDom) {
+ el = el || {};
+ if (el.nodeType || el.dom || typeof el == 'string') {
+ el = Ext.getDom(el);
+ this.dom.insertBefore(el, this.dom.firstChild);
+ return !returnDom ? Ext.get(el) : el;
+ }
+ else {
+ return this.createChild(el, this.dom.firstChild, returnDom);
+ }
+ },
+
+
+ insertSibling: function(el, where, returnDom){
+ var me = this,
+ isAfter = (where || 'before').toLowerCase() == 'after',
+ rt, insertEl, eLen, e;
+
+ if (Ext.isArray(el)) {
+ insertEl = me;
+ eLen = el.length;
+
+ for (e = 0; e < eLen; e++) {
+ rt = Ext.fly(insertEl, '_internal').insertSibling(el[e], where, returnDom);
+
+ if (isAfter) {
+ insertEl = rt;
+ }
+ }
+
+ return rt;
+ }
+
+ el = el || {};
+
+ if(el.nodeType || el.dom){
+ rt = me.dom.parentNode.insertBefore(Ext.getDom(el), isAfter ? me.dom.nextSibling : me.dom);
+ if (!returnDom) {
+ rt = Ext.get(rt);
+ }
+ }else{
+ if (isAfter && !me.dom.nextSibling) {
+ rt = Ext.core.DomHelper.append(me.dom.parentNode, el, !returnDom);
+ } else {
+ rt = Ext.core.DomHelper[isAfter ? 'insertAfter' : 'insertBefore'](me.dom, el, !returnDom);
+ }
+ }
+ return rt;
+ },
+
+
+ replace: function(el) {
+ el = Ext.get(el);
+ this.insertBefore(el);
+ el.remove();
+ return this;
+ },
+
+
+ replaceWith: function(el){
+ var me = this;
+
+ if(el.nodeType || el.dom || typeof el == 'string'){
+ el = Ext.get(el);
+ me.dom.parentNode.insertBefore(el, me.dom);
+ }else{
+ el = Ext.core.DomHelper.insertBefore(me.dom, el);
+ }
+
+ delete Ext.cache[me.id];
+ Ext.removeNode(me.dom);
+ me.id = Ext.id(me.dom = el);
+ Ext.dom.AbstractElement.addToCache(me.isFlyweight ? new Ext.dom.AbstractElement(me.dom) : me);
+ return me;
+ },
+
+
+ createChild: function(config, insertBefore, returnDom) {
+ config = config || {tag:'div'};
+ if (insertBefore) {
+ return Ext.core.DomHelper.insertBefore(insertBefore, config, returnDom !== true);
+ }
+ else {
+ return Ext.core.DomHelper[!this.dom.firstChild ? 'insertFirst' : 'append'](this.dom, config, returnDom !== true);
+ }
+ },
+
+
+ wrap: function(config, returnDom, selector) {
+ var newEl = Ext.core.DomHelper.insertBefore(this.dom, config || {tag: "div"}, true),
+ target = newEl;
+
+ if (selector) {
+ target = Ext.DomQuery.selectNode(selector, newEl.dom);
+ }
+
+ target.appendChild(this.dom);
+ return returnDom ? newEl.dom : newEl;
+ },
+
+
+ insertHtml: function(where, html, returnEl) {
+ var el = Ext.core.DomHelper.insertHtml(where, this.dom, html);
+ return returnEl ? Ext.get(el) : el;
+ }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-insertion
+
+//@define Ext.dom.AbstractElement-position
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function(){
+
+var Element = Ext.dom.AbstractElement;
+
+Element.override({
+
+
+ getX: function(el) {
+ return this.getXY(el)[0];
+ },
+
+
+ getY: function(el) {
+ return this.getXY(el)[1];
+ },
+
+
+ getXY: function() {
+
+ var point = window.webkitConvertPointFromNodeToPage(this.dom, new WebKitPoint(0, 0));
+ return [point.x, point.y];
+ },
+
+
+ getOffsetsTo: function(el){
+ var o = this.getXY(),
+ e = Ext.fly(el, '_internal').getXY();
+ return [o[0]-e[0],o[1]-e[1]];
+ },
+
+
+ setX: function(x){
+ return this.setXY([x, this.getY()]);
+ },
+
+
+ setY: function(y) {
+ return this.setXY([this.getX(), y]);
+ },
+
+
+ setLeft: function(left) {
+ this.setStyle('left', Element.addUnits(left));
+ return this;
+ },
+
+
+ setTop: function(top) {
+ this.setStyle('top', Element.addUnits(top));
+ return this;
+ },
+
+
+ setRight: function(right) {
+ this.setStyle('right', Element.addUnits(right));
+ return this;
+ },
+
+
+ setBottom: function(bottom) {
+ this.setStyle('bottom', Element.addUnits(bottom));
+ return this;
+ },
+
+
+ setXY: function(pos) {
+ var me = this,
+ pts,
+ style,
+ pt;
+
+ if (arguments.length > 1) {
+ pos = [pos, arguments[1]];
+ }
+
+
+ pts = me.translatePoints(pos);
+ style = me.dom.style;
+
+ for (pt in pts) {
+ if (!pts.hasOwnProperty(pt)) {
+ continue;
+ }
+ if (!isNaN(pts[pt])) {
+ style[pt] = pts[pt] + "px";
+ }
+ }
+ return me;
+ },
+
+
+ getLeft: function(local) {
+ return parseInt(this.getStyle('left'), 10) || 0;
+ },
+
+
+ getRight: function(local) {
+ return parseInt(this.getStyle('right'), 10) || 0;
+ },
+
+
+ getTop: function(local) {
+ return parseInt(this.getStyle('top'), 10) || 0;
+ },
+
+
+ getBottom: function(local) {
+ return parseInt(this.getStyle('bottom'), 10) || 0;
+ },
+
+
+ translatePoints: function(x, y) {
+ y = isNaN(x[1]) ? y : x[1];
+ x = isNaN(x[0]) ? x : x[0];
+ var me = this,
+ relative = me.isStyle('position', 'relative'),
+ o = me.getXY(),
+ l = parseInt(me.getStyle('left'), 10),
+ t = parseInt(me.getStyle('top'), 10);
+
+ l = !isNaN(l) ? l : (relative ? 0 : me.dom.offsetLeft);
+ t = !isNaN(t) ? t : (relative ? 0 : me.dom.offsetTop);
+
+ return {left: (x - o[0] + l), top: (y - o[1] + t)};
+ },
+
+
+ setBox: function(box) {
+ var me = this,
+ width = box.width,
+ height = box.height,
+ top = box.top,
+ left = box.left;
+
+ if (left !== undefined) {
+ me.setLeft(left);
+ }
+ if (top !== undefined) {
+ me.setTop(top);
+ }
+ if (width !== undefined) {
+ me.setWidth(width);
+ }
+ if (height !== undefined) {
+ me.setHeight(height);
+ }
+
+ return this;
+ },
+
+
+ getBox: function(contentBox, local) {
+ var me = this,
+ dom = me.dom,
+ width = dom.offsetWidth,
+ height = dom.offsetHeight,
+ xy, box, l, r, t, b;
+
+ if (!local) {
+ xy = me.getXY();
+ }
+ else if (contentBox) {
+ xy = [0,0];
+ }
+ else {
+ xy = [parseInt(me.getStyle("left"), 10) || 0, parseInt(me.getStyle("top"), 10) || 0];
+ }
+
+ if (!contentBox) {
+ box = {
+ x: xy[0],
+ y: xy[1],
+ 0: xy[0],
+ 1: xy[1],
+ width: width,
+ height: height
+ };
+ }
+ else {
+ l = me.getBorderWidth.call(me, "l") + me.getPadding.call(me, "l");
+ r = me.getBorderWidth.call(me, "r") + me.getPadding.call(me, "r");
+ t = me.getBorderWidth.call(me, "t") + me.getPadding.call(me, "t");
+ b = me.getBorderWidth.call(me, "b") + me.getPadding.call(me, "b");
+ box = {
+ x: xy[0] + l,
+ y: xy[1] + t,
+ 0: xy[0] + l,
+ 1: xy[1] + t,
+ width: width - (l + r),
+ height: height - (t + b)
+ };
+ }
+
+ box.left = box.x;
+ box.top = box.y;
+ box.right = box.x + box.width;
+ box.bottom = box.y + box.height;
+
+ return box;
+ },
+
+
+ getPageBox: function(getRegion) {
+ var me = this,
+ el = me.dom,
+ w = el.offsetWidth,
+ h = el.offsetHeight,
+ xy = me.getXY(),
+ t = xy[1],
+ r = xy[0] + w,
+ b = xy[1] + h,
+ l = xy[0];
+
+ if (!el) {
+ return new Ext.util.Region();
+ }
+
+ if (getRegion) {
+ return new Ext.util.Region(t, r, b, l);
+ }
+ else {
+ return {
+ left: l,
+ top: t,
+ width: w,
+ height: h,
+ right: r,
+ bottom: b
+ };
+ }
+ }
+});
+
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-position
+
+//@define Ext.dom.AbstractElement-style
+
+//@define Ext.dom.AbstractElement
+
+
+
+(function(){
+
+ var Element = Ext.dom.AbstractElement,
+ view = document.defaultView,
+ array = Ext.Array,
+ trimRe = /^\s+|\s+$/g,
+ wordsRe = /\w/g,
+ spacesRe = /\s+/,
+ transparentRe = /^(?:transparent|(?:rgba[(](?:\s*\d+\s*[,]){3}\s*0\s*[)]))$/i,
+ hasClassList = Ext.supports.ClassList,
+ PADDING = 'padding',
+ MARGIN = 'margin',
+ BORDER = 'border',
+ LEFT_SUFFIX = '-left',
+ RIGHT_SUFFIX = '-right',
+ TOP_SUFFIX = '-top',
+ BOTTOM_SUFFIX = '-bottom',
+ WIDTH = '-width',
+
+ borders = {l: BORDER + LEFT_SUFFIX + WIDTH, r: BORDER + RIGHT_SUFFIX + WIDTH, t: BORDER + TOP_SUFFIX + WIDTH, b: BORDER + BOTTOM_SUFFIX + WIDTH},
+ paddings = {l: PADDING + LEFT_SUFFIX, r: PADDING + RIGHT_SUFFIX, t: PADDING + TOP_SUFFIX, b: PADDING + BOTTOM_SUFFIX},
+ margins = {l: MARGIN + LEFT_SUFFIX, r: MARGIN + RIGHT_SUFFIX, t: MARGIN + TOP_SUFFIX, b: MARGIN + BOTTOM_SUFFIX};
+
+
+ Element.override({
+
+
+ styleHooks: {},
+
+
+ addStyles : function(sides, styles){
+ var totalSize = 0,
+ sidesArr = (sides || '').match(wordsRe),
+ i,
+ len = sidesArr.length,
+ side,
+ styleSides = [];
+
+ if (len == 1) {
+ totalSize = Math.abs(parseFloat(this.getStyle(styles[sidesArr[0]])) || 0);
+ } else if (len) {
+ for (i = 0; i < len; i++) {
+ side = sidesArr[i];
+ styleSides.push(styles[side]);
+ }
+
+ styleSides = this.getStyle(styleSides);
+
+ for (i=0; i < len; i++) {
+ side = sidesArr[i];
+ totalSize += Math.abs(parseFloat(styleSides[styles[side]]) || 0);
+ }
+ }
+
+ return totalSize;
+ },
+
+
+ addCls: hasClassList ?
+ function (className) {
+ var me = this,
+ dom = me.dom,
+ classList,
+ newCls,
+ i,
+ len,
+ cls;
+
+ if (typeof(className) == 'string') {
+
+ className = className.replace(trimRe, '').split(spacesRe);
+ }
+
+
+
+ if (dom && className && !!(len = className.length)) {
+ if (!dom.className) {
+ dom.className = className.join(' ');
+ } else {
+ classList = dom.classList;
+ for (i = 0; i < len; ++i) {
+ cls = className[i];
+ if (cls) {
+ if (!classList.contains(cls)) {
+ if (newCls) {
+ newCls.push(cls);
+ } else {
+ newCls = dom.className.replace(trimRe, '');
+ newCls = newCls ? [newCls, cls] : [cls];
+ }
+ }
+ }
+ }
+
+ if (newCls) {
+ dom.className = newCls.join(' ');
+ }
+ }
+ }
+ return me;
+ } :
+ function(className) {
+ var me = this,
+ dom = me.dom,
+ changed,
+ elClasses;
+
+ if (dom && className && className.length) {
+ elClasses = Ext.Element.mergeClsList(dom.className, className);
+ if (elClasses.changed) {
+ dom.className = elClasses.join(' ');
+ }
+ }
+ return me;
+ },
+
+
+
+ removeCls: function(className) {
+ var me = this,
+ dom = me.dom,
+ len,
+ elClasses;
+
+ if (typeof(className) == 'string') {
+
+ className = className.replace(trimRe, '').split(spacesRe);
+ }
+
+ if (dom && dom.className && className && !!(len = className.length)) {
+ if (len == 1 && hasClassList) {
+ if (className[0]) {
+ dom.classList.remove(className[0]);
+ }
+ } else {
+ elClasses = Ext.Element.removeCls(dom.className, className);
+ if (elClasses.changed) {
+ dom.className = elClasses.join(' ');
+ }
+ }
+ }
+ return me;
+ },
+
+
+ radioCls: function(className) {
+ var cn = this.dom.parentNode.childNodes,
+ v,
+ i, len;
+ className = Ext.isArray(className) ? className: [className];
+ for (i = 0, len = cn.length; i < len; i++) {
+ v = cn[i];
+ if (v && v.nodeType == 1) {
+ Ext.fly(v, '_internal').removeCls(className);
+ }
+ }
+ return this.addCls(className);
+ },
+
+
+ toggleCls: hasClassList ?
+ function (className) {
+ var me = this,
+ dom = me.dom;
+
+ if (dom) {
+ className = className.replace(trimRe, '');
+ if (className) {
+ dom.classList.toggle(className);
+ }
+ }
+
+ return me;
+ } :
+ function(className) {
+ var me = this;
+ return me.hasCls(className) ? me.removeCls(className) : me.addCls(className);
+ },
+
+
+ hasCls: hasClassList ?
+ function (className) {
+ var dom = this.dom;
+ return (dom && className) ? dom.classList.contains(className) : false;
+ } :
+ function(className) {
+ var dom = this.dom;
+ return dom ? className && (' '+dom.className+' ').indexOf(' '+className+' ') != -1 : false;
+ },
+
+
+ replaceCls: function(oldClassName, newClassName){
+ return this.removeCls(oldClassName).addCls(newClassName);
+ },
+
+
+ isStyle: function(style, val) {
+ return this.getStyle(style) == val;
+ },
+
+
+ getStyle: function (property, inline) {
+ var me = this,
+ dom = me.dom,
+ multiple = typeof property != 'string',
+ hooks = me.styleHooks,
+ prop = property,
+ props = prop,
+ len = 1,
+ domStyle, camel, values, hook, out, style, i;
+
+ if (multiple) {
+ values = {};
+ prop = props[0];
+ i = 0;
+ if (!(len = props.length)) {
+ return values;
+ }
+ }
+
+ if (!dom || dom.documentElement) {
+ return values || '';
+ }
+
+ domStyle = dom.style;
+
+ if (inline) {
+ style = domStyle;
+ } else {
+
+
+
+
+ style = dom.ownerDocument.defaultView.getComputedStyle(dom, null);
+
+
+ if (!style) {
+ inline = true;
+ style = domStyle;
+ }
+ }
+
+ do {
+ hook = hooks[prop];
+
+ if (!hook) {
+ hooks[prop] = hook = { name: Element.normalize(prop) };
+ }
+
+ if (hook.get) {
+ out = hook.get(dom, me, inline, style);
+ } else {
+ camel = hook.name;
+ out = style[camel];
+ }
+
+ if (!multiple) {
+ return out;
+ }
+
+ values[prop] = out;
+ prop = props[++i];
+ } while (i < len);
+
+ return values;
+ },
+
+ getStyles: function () {
+ var props = Ext.Array.slice(arguments),
+ len = props.length,
+ inline;
+
+ if (len && typeof props[len-1] == 'boolean') {
+ inline = props.pop();
+ }
+
+ return this.getStyle(props, inline);
+ },
+
+
+ isTransparent: function (prop) {
+ var value = this.getStyle(prop);
+ return value ? transparentRe.test(value) : false;
+ },
+
+
+ setStyle: function(prop, value) {
+ var me = this,
+ dom = me.dom,
+ hooks = me.styleHooks,
+ style = dom.style,
+ name = prop,
+ hook;
+
+
+ if (typeof name == 'string') {
+ hook = hooks[name];
+ if (!hook) {
+ hooks[name] = hook = { name: Element.normalize(name) };
+ }
+ value = (value == null) ? '' : value;
+ if (hook.set) {
+ hook.set(dom, value, me);
+ } else {
+ style[hook.name] = value;
+ }
+ if (hook.afterSet) {
+ hook.afterSet(dom, value, me);
+ }
+ } else {
+ for (name in prop) {
+ if (prop.hasOwnProperty(name)) {
+ hook = hooks[name];
+ if (!hook) {
+ hooks[name] = hook = { name: Element.normalize(name) };
+ }
+ value = prop[name];
+ value = (value == null) ? '' : value;
+ if (hook.set) {
+ hook.set(dom, value, me);
+ } else {
+ style[hook.name] = value;
+ }
+ if (hook.afterSet) {
+ hook.afterSet(dom, value, me);
+ }
+ }
+ }
+ }
+
+ return me;
+ },
+
+
+ getHeight: function(contentHeight) {
+ var dom = this.dom,
+ height = contentHeight ? (dom.clientHeight - this.getPadding("tb")) : dom.offsetHeight;
+ return height > 0 ? height: 0;
+ },
+
+
+ getWidth: function(contentWidth) {
+ var dom = this.dom,
+ width = contentWidth ? (dom.clientWidth - this.getPadding("lr")) : dom.offsetWidth;
+ return width > 0 ? width: 0;
+ },
+
+
+ setWidth: function(width) {
+ var me = this;
+ me.dom.style.width = Element.addUnits(width);
+ return me;
+ },
+
+
+ setHeight: function(height) {
+ var me = this;
+ me.dom.style.height = Element.addUnits(height);
+ return me;
+ },
+
+
+ getBorderWidth: function(side){
+ return this.addStyles(side, borders);
+ },
+
+
+ getPadding: function(side){
+ return this.addStyles(side, paddings);
+ },
+
+ margins : margins,
+
+
+ applyStyles: function(styles) {
+ if (styles) {
+ var i,
+ len,
+ dom = this.dom;
+
+ if (typeof styles == 'function') {
+ styles = styles.call();
+ }
+ if (typeof styles == 'string') {
+ styles = Ext.util.Format.trim(styles).split(/\s*(?::|;)\s*/);
+ for (i = 0, len = styles.length; i < len;) {
+ dom.style[Element.normalize(styles[i++])] = styles[i++];
+ }
+ }
+ else if (typeof styles == 'object') {
+ this.setStyle(styles);
+ }
+ }
+ },
+
+
+ setSize: function(width, height) {
+ var me = this,
+ style = me.dom.style;
+
+ if (Ext.isObject(width)) {
+
+ height = width.height;
+ width = width.width;
+ }
+
+ style.width = Element.addUnits(width);
+ style.height = Element.addUnits(height);
+ return me;
+ },
+
+
+ getViewSize: function() {
+ var doc = document,
+ dom = this.dom;
+
+ if (dom == doc || dom == doc.body) {
+ return {
+ width: Element.getViewportWidth(),
+ height: Element.getViewportHeight()
+ };
+ }
+ else {
+ return {
+ width: dom.clientWidth,
+ height: dom.clientHeight
+ };
+ }
+ },
+
+
+ getSize: function(contentSize) {
+ var dom = this.dom;
+ return {
+ width: Math.max(0, contentSize ? (dom.clientWidth - this.getPadding("lr")) : dom.offsetWidth),
+ height: Math.max(0, contentSize ? (dom.clientHeight - this.getPadding("tb")) : dom.offsetHeight)
+ };
+ },
+
+
+ repaint: function(){
+ var dom = this.dom;
+ this.addCls(Ext.baseCSSPrefix + 'repaint');
+ setTimeout(function(){
+ Ext.fly(dom).removeCls(Ext.baseCSSPrefix + 'repaint');
+ }, 1);
+ return this;
+ },
+
+
+ getMargin: function(side){
+ var me = this,
+ hash = {t:"top", l:"left", r:"right", b: "bottom"},
+ key,
+ o,
+ margins;
+
+ if (!side) {
+ margins = [];
+ for (key in me.margins) {
+ if(me.margins.hasOwnProperty(key)) {
+ margins.push(me.margins[key]);
+ }
+ }
+ o = me.getStyle(margins);
+ if(o && typeof o == 'object') {
+
+ for (key in me.margins) {
+ if(me.margins.hasOwnProperty(key)) {
+ o[hash[key]] = parseFloat(o[me.margins[key]]) || 0;
+ }
+ }
+ }
+
+ return o;
+ } else {
+ return me.addStyles.call(me, side, me.margins);
+ }
+ },
+
+
+ mask: function(msg, msgCls, transparent) {
+ var me = this,
+ dom = me.dom,
+ data = (me.$cache || me.getCache()).data,
+ el = data.mask,
+ mask,
+ size,
+ cls = '',
+ prefix = Ext.baseCSSPrefix;
+
+ me.addCls(prefix + 'masked');
+ if (me.getStyle("position") == "static") {
+ me.addCls(prefix + 'masked-relative');
+ }
+ if (el) {
+ el.remove();
+ }
+ if (msgCls && typeof msgCls == 'string' ) {
+ cls = ' ' + msgCls;
+ }
+ else {
+ cls = ' ' + prefix + 'mask-gray';
+ }
+
+ mask = me.createChild({
+ cls: prefix + 'mask' + ((transparent !== false) ? '' : (' ' + prefix + 'mask-gray')),
+ html: msg ? ('') : ''
+ });
+
+ size = me.getSize();
+
+ data.mask = mask;
+
+ if (dom === document.body) {
+ size.height = window.innerHeight;
+ if (me.orientationHandler) {
+ Ext.EventManager.unOrientationChange(me.orientationHandler, me);
+ }
+
+ me.orientationHandler = function() {
+ size = me.getSize();
+ size.height = window.innerHeight;
+ mask.setSize(size);
+ };
+
+ Ext.EventManager.onOrientationChange(me.orientationHandler, me);
+ }
+ mask.setSize(size);
+ if (Ext.is.iPad) {
+ Ext.repaint();
+ }
+ },
+
+
+ unmask: function() {
+ var me = this,
+ data = (me.$cache || me.getCache()).data,
+ mask = data.mask,
+ prefix = Ext.baseCSSPrefix;
+
+ if (mask) {
+ mask.remove();
+ delete data.mask;
+ }
+ me.removeCls([prefix + 'masked', prefix + 'masked-relative']);
+
+ if (me.dom === document.body) {
+ Ext.EventManager.unOrientationChange(me.orientationHandler, me);
+ delete me.orientationHandler;
+ }
+ }
+ });
+
+
+ Element.populateStyleMap = function (map, order) {
+ var baseStyles = ['margin-', 'padding-', 'border-width-'],
+ beforeAfter = ['before', 'after'],
+ index, style, name, i;
+
+ for (index = baseStyles.length; index--; ) {
+ for (i = 2; i--; ) {
+ style = baseStyles[index] + beforeAfter[i];
+
+ map[Element.normalize(style)] = map[style] = {
+ name: Element.normalize(baseStyles[index] + order[i])
+ };
+ }
+ }
+ };
+
+ Ext.onReady(function () {
+ var supports = Ext.supports,
+ styleHooks,
+ colorStyles, i, name, camel;
+
+ function fixTransparent (dom, el, inline, style) {
+ var value = style[this.name] || '';
+ return transparentRe.test(value) ? 'transparent' : value;
+ }
+
+ function fixRightMargin (dom, el, inline, style) {
+ var result = style.marginRight,
+ domStyle, display;
+
+
+
+ if (result != '0px') {
+ domStyle = dom.style;
+ display = domStyle.display;
+ domStyle.display = 'inline-block';
+ result = (inline ? style : dom.ownerDocument.defaultView.getComputedStyle(dom, null)).marginRight;
+ domStyle.display = display;
+ }
+
+ return result;
+ }
+
+ function fixRightMarginAndInputFocus (dom, el, inline, style) {
+ var result = style.marginRight,
+ domStyle, cleaner, display;
+
+ if (result != '0px') {
+ domStyle = dom.style;
+ cleaner = Element.getRightMarginFixCleaner(dom);
+ display = domStyle.display;
+ domStyle.display = 'inline-block';
+ result = (inline ? style : dom.ownerDocument.defaultView.getComputedStyle(dom, '')).marginRight;
+ domStyle.display = display;
+ cleaner();
+ }
+
+ return result;
+ }
+
+ styleHooks = Element.prototype.styleHooks;
+
+
+ Element.populateStyleMap(styleHooks, ['left', 'right']);
+
+
+
+ if (supports.init) {
+ supports.init();
+ }
+
+
+ if (!supports.RightMargin) {
+ styleHooks.marginRight = styleHooks['margin-right'] = {
+ name: 'marginRight',
+
+
+ get: (supports.DisplayChangeInputSelectionBug || supports.DisplayChangeTextAreaSelectionBug) ?
+ fixRightMarginAndInputFocus : fixRightMargin
+ };
+ }
+
+ if (!supports.TransparentColor) {
+ colorStyles = ['background-color', 'border-color', 'color', 'outline-color'];
+ for (i = colorStyles.length; i--; ) {
+ name = colorStyles[i];
+ camel = Element.normalize(name);
+
+ styleHooks[name] = styleHooks[camel] = {
+ name: camel,
+ get: fixTransparent
+ };
+ }
+ }
+ });
+}());
+
+//@tag dom,core
+
+//@require Ext.dom.AbstractElement-style
+
+//@define Ext.dom.AbstractElement-traversal
+
+//@define Ext.dom.AbstractElement
+
+
+
+Ext.dom.AbstractElement.override({
+
+ findParent: function(simpleSelector, limit, returnEl) {
+ var target = this.dom,
+ topmost = document.documentElement,
+ depth = 0,
+ stopEl;
+
+ limit = limit || 50;
+ if (isNaN(limit)) {
+ stopEl = Ext.getDom(limit);
+ limit = Number.MAX_VALUE;
+ }
+ while (target && target.nodeType == 1 && depth < limit && target != topmost && target != stopEl) {
+ if (Ext.DomQuery.is(target, simpleSelector)) {
+ return returnEl ? Ext.get(target) : target;
+ }
+ depth++;
+ target = target.parentNode;
+ }
+ return null;
+ },
+
+
+ findParentNode: function(simpleSelector, limit, returnEl) {
+ var p = Ext.fly(this.dom.parentNode, '_internal');
+ return p ? p.findParent(simpleSelector, limit, returnEl) : null;
+ },
+
+
+ up: function(simpleSelector, limit) {
+ return this.findParentNode(simpleSelector, limit, true);
+ },
+
+
+ select: function(selector, composite) {
+ return Ext.dom.Element.select(selector, this.dom, composite);
+ },
+
+
+ query: function(selector) {
+ return Ext.DomQuery.select(selector, this.dom);
+ },
+
+
+ down: function(selector, returnDom) {
+ var n = Ext.DomQuery.selectNode(selector, this.dom);
+ return returnDom ? n : Ext.get(n);
+ },
+
+
+ child: function(selector, returnDom) {
+ var node,
+ me = this,
+ id;
+
+
+
+ id = Ext.id(me.dom);
+
+ id = Ext.escapeId(id);
+ node = Ext.DomQuery.selectNode('#' + id + " > " + selector, me.dom);
+ return returnDom ? node : Ext.get(node);
+ },
+
+
+ parent: function(selector, returnDom) {
+ return this.matchNode('parentNode', 'parentNode', selector, returnDom);
+ },
+
+
+ next: function(selector, returnDom) {
+ return this.matchNode('nextSibling', 'nextSibling', selector, returnDom);
+ },
+
+
+ prev: function(selector, returnDom) {
+ return this.matchNode('previousSibling', 'previousSibling', selector, returnDom);
+ },
+
+
+
+ first: function(selector, returnDom) {
+ return this.matchNode('nextSibling', 'firstChild', selector, returnDom);
+ },
+
+
+ last: function(selector, returnDom) {
+ return this.matchNode('previousSibling', 'lastChild', selector, returnDom);
+ },
+
+ matchNode: function(dir, start, selector, returnDom) {
+ if (!this.dom) {
+ return null;
+ }
+
+ var n = this.dom[start];
+ while (n) {
+ if (n.nodeType == 1 && (!selector || Ext.DomQuery.is(n, selector))) {
+ return !returnDom ? Ext.get(n) : n;
+ }
+ n = n[dir];
+ }
+ return null;
+ },
+
+ isAncestor: function(element) {
+ return this.self.isAncestor.call(this.self, this.dom, element);
+ }
+});
+
+//@tag dom,core
+
+//@define Ext.DomHelper
+
+//@define Ext.core.DomHelper
+
+//@require Ext.dom.AbstractElement-traversal
+
+
+
+(function() {
+
+
+var afterbegin = 'afterbegin',
+ afterend = 'afterend',
+ beforebegin = 'beforebegin',
+ beforeend = 'beforeend',
+ ts = '" + Ext.String.format(Element.boxMarkup, cls) + "
"));
+ Ext.DomQuery.selectNode('.' + cls + '-mc', el.dom).appendChild(this.dom);
+ return el;
+ },
+
+
+ getComputedHeight : function() {
+ var me = this,
+ h = Math.max(me.dom.offsetHeight, me.dom.clientHeight);
+ if (!h) {
+ h = parseFloat(me.getStyle(HEIGHT)) || 0;
+ if (!me.isBorderBox()) {
+ h += me.getFrameWidth('tb');
+ }
+ }
+ return h;
+ },
+
+
+ getComputedWidth : function() {
+ var me = this,
+ w = Math.max(me.dom.offsetWidth, me.dom.clientWidth);
+
+ if (!w) {
+ w = parseFloat(me.getStyle(WIDTH)) || 0;
+ if (!me.isBorderBox()) {
+ w += me.getFrameWidth('lr');
+ }
+ }
+ return w;
+ },
+
+
+ getFrameWidth : function(sides, onlyContentBox) {
+ return (onlyContentBox && this.isBorderBox()) ? 0 : (this.getPadding(sides) + this.getBorderWidth(sides));
+ },
+
+
+ addClsOnOver : function(className, testFn, scope) {
+ var me = this,
+ dom = me.dom,
+ hasTest = Ext.isFunction(testFn);
+
+ me.hover(
+ function() {
+ if (hasTest && testFn.call(scope || me, me) === false) {
+ return;
+ }
+ Ext.fly(dom, INTERNAL).addCls(className);
+ },
+ function() {
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ }
+ );
+ return me;
+ },
+
+
+ addClsOnFocus : function(className, testFn, scope) {
+ var me = this,
+ dom = me.dom,
+ hasTest = Ext.isFunction(testFn);
+
+ me.on("focus", function() {
+ if (hasTest && testFn.call(scope || me, me) === false) {
+ return false;
+ }
+ Ext.fly(dom, INTERNAL).addCls(className);
+ });
+ me.on("blur", function() {
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ });
+ return me;
+ },
+
+
+ addClsOnClick : function(className, testFn, scope) {
+ var me = this,
+ dom = me.dom,
+ hasTest = Ext.isFunction(testFn);
+
+ me.on("mousedown", function() {
+ if (hasTest && testFn.call(scope || me, me) === false) {
+ return false;
+ }
+ Ext.fly(dom, INTERNAL).addCls(className);
+ var d = Ext.getDoc(),
+ fn = function() {
+ Ext.fly(dom, INTERNAL).removeCls(className);
+ d.removeListener("mouseup", fn);
+ };
+ d.on("mouseup", fn);
+ });
+ return me;
+ },
+
+
+ getStyleSize : function() {
+ var me = this,
+ d = this.dom,
+ isDoc = DOCORBODYRE.test(d.nodeName),
+ s ,
+ w, h;
+
+
+ if (isDoc) {
+ return {
+ width : Element.getViewWidth(),
+ height : Element.getViewHeight()
+ };
+ }
+
+ s = me.getStyle([HEIGHT, WIDTH], true);
+
+ if (s.width && s.width != 'auto') {
+ w = parseFloat(s.width);
+ if (me.isBorderBox()) {
+ w -= me.getFrameWidth('lr');
+ }
+ }
+
+ if (s.height && s.height != 'auto') {
+ h = parseFloat(s.height);
+ if (me.isBorderBox()) {
+ h -= me.getFrameWidth('tb');
+ }
+ }
+
+ return {width: w || me.getWidth(true), height: h || me.getHeight(true)};
+ },
+
+
+ selectable : function() {
+ var me = this;
+ me.dom.unselectable = "off";
+
+ me.on('selectstart', function (e) {
+ e.stopPropagation();
+ return true;
+ });
+ me.applyStyles("-moz-user-select: text; -khtml-user-select: text;");
+ me.removeCls(Ext.baseCSSPrefix + 'unselectable');
+ return me;
+ },
+
+
+ unselectable : function() {
+ var me = this;
+ me.dom.unselectable = "on";
+
+ me.swallowEvent("selectstart", true);
+ me.applyStyles("-moz-user-select:-moz-none;-khtml-user-select:none;");
+ me.addCls(Ext.baseCSSPrefix + 'unselectable');
+
+ return me;
+ }
+});
+
+Element.prototype.styleHooks = styleHooks = Ext.dom.AbstractElement.prototype.styleHooks;
+
+if (Ext.isIE6 || Ext.isIE7) {
+ styleHooks.fontSize = styleHooks['font-size'] = {
+ name: 'fontSize',
+ canThrow: true
+ };
+
+ styleHooks.fontStyle = styleHooks['font-style'] = {
+ name: 'fontStyle',
+ canThrow: true
+ };
+
+ styleHooks.fontFamily = styleHooks['font-family'] = {
+ name: 'fontFamily',
+ canThrow: true
+ };
+}
+
+
+if (Ext.isIEQuirks || Ext.isIE && Ext.ieVersion <= 8) {
+ function getBorderWidth (dom, el, inline, style) {
+ if (style[this.styleName] == 'none') {
+ return '0px';
+ }
+ return style[this.name];
+ }
+
+ edges = ['Top','Right','Bottom','Left'];
+ k = edges.length;
+
+ while (k--) {
+ edge = edges[k];
+ borderWidth = 'border' + edge + 'Width';
+
+ styleHooks['border-'+edge.toLowerCase()+'-width'] = styleHooks[borderWidth] = {
+ name: borderWidth,
+ styleName: 'border' + edge + 'Style',
+ get: getBorderWidth
+ };
+ }
+}
+
+}());
+
+Ext.onReady(function () {
+ var opacityRe = /alpha\(opacity=(.*)\)/i,
+ trimRe = /^\s+|\s+$/g,
+ hooks = Ext.dom.Element.prototype.styleHooks;
+
+
+ hooks.opacity = {
+ name: 'opacity',
+ afterSet: function(dom, value, el) {
+ if (el.isLayer) {
+ el.onOpacitySet(value);
+ }
+ }
+ };
+ if (!Ext.supports.Opacity && Ext.isIE) {
+ Ext.apply(hooks.opacity, {
+ get: function (dom) {
+ var filter = dom.style.filter,
+ match, opacity;
+ if (filter.match) {
+ match = filter.match(opacityRe);
+ if (match) {
+ opacity = parseFloat(match[1]);
+ if (!isNaN(opacity)) {
+ return opacity ? opacity / 100 : 0;
+ }
+ }
+ }
+ return 1;
+ },
+ set: function (dom, value) {
+ var style = dom.style,
+ val = style.filter.replace(opacityRe, '').replace(trimRe, '');
+
+ style.zoom = 1;
+
+
+ if (typeof(value) == 'number' && value >= 0 && value < 1) {
+ value *= 100;
+ style.filter = val + (val.length ? ' ' : '') + 'alpha(opacity='+value+')';
+ } else {
+ style.filter = val;
+ }
+ }
+ });
+ }
+
+
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-style
+
+//@define Ext.dom.Element-traversal
+
+//@define Ext.dom.Element
+
+
+
+Ext.dom.Element.override({
+ select: function(selector) {
+ return Ext.dom.Element.select(selector, false, this.dom);
+ }
+});
+
+//@tag dom,core
+
+//@require Ext.dom.Element-traversal
+
+
+
+Ext.define('Ext.dom.CompositeElementLite', {
+ alternateClassName: 'Ext.CompositeElementLite',
+
+ requires: ['Ext.dom.Element', 'Ext.dom.Query'],
+
+ statics: {
+
+ importElementMethods: function() {
+ var name,
+ elementPrototype = Ext.dom.Element.prototype,
+ prototype = this.prototype;
+
+ for (name in elementPrototype) {
+ if (typeof elementPrototype[name] == 'function'){
+ (function(key) {
+ prototype[key] = prototype[key] || function() {
+ return this.invoke(key, arguments);
+ };
+ }).call(prototype, name);
+
+ }
+ }
+ }
+ },
+
+ constructor: function(elements, root) {
+
+ this.elements = [];
+ this.add(elements, root);
+ this.el = new Ext.dom.AbstractElement.Fly();
+ },
+
+
+ isComposite: true,
+
+
+ getElement: function(el) {
+
+ return this.el.attach(el);
+ },
+
+
+ transformElement: function(el) {
+ return Ext.getDom(el);
+ },
+
+
+ getCount: function() {
+ return this.elements.length;
+ },
+
+
+ add: function(els, root) {
+ var elements = this.elements,
+ i, ln;
+
+ if (!els) {
+ return this;
+ }
+
+ if (typeof els == "string") {
+ els = Ext.dom.Element.selectorFunction(els, root);
+ }
+ else if (els.isComposite) {
+ els = els.elements;
+ }
+ else if (!Ext.isIterable(els)) {
+ els = [els];
+ }
+
+ for (i = 0, ln = els.length; i < ln; ++i) {
+ elements.push(this.transformElement(els[i]));
+ }
+
+ return this;
+ },
+
+ invoke: function(fn, args) {
+ var elements = this.elements,
+ ln = elements.length,
+ element,
+ i;
+
+ fn = Ext.dom.Element.prototype[fn];
+ for (i = 0; i < ln; i++) {
+ element = elements[i];
+
+ if (element) {
+ fn.apply(this.getElement(element), args);
+ }
+ }
+ return this;
+ },
+
+
+ item: function(index) {
+ var el = this.elements[index],
+ out = null;
+
+ if (el) {
+ out = this.getElement(el);
+ }
+
+ return out;
+ },
+
+
+ addListener: function(eventName, handler, scope, opt) {
+ var els = this.elements,
+ len = els.length,
+ i, e;
+
+ for (i = 0; i < len; i++) {
+ e = els[i];
+ if (e) {
+ Ext.EventManager.on(e, eventName, handler, scope || e, opt);
+ }
+ }
+ return this;
+ },
+
+ each: function(fn, scope) {
+ var me = this,
+ els = me.elements,
+ len = els.length,
+ i, e;
+
+ for (i = 0; i < len; i++) {
+ e = els[i];
+ if (e) {
+ e = this.getElement(e);
+ if (fn.call(scope || e, e, me, i) === false) {
+ break;
+ }
+ }
+ }
+ return me;
+ },
+
+
+ fill: function(els) {
+ var me = this;
+ me.elements = [];
+ me.add(els);
+ return me;
+ },
+
+
+ filter: function(selector) {
+ var me = this,
+ els = me.elements,
+ len = els.length,
+ out = [],
+ i = 0,
+ isFunc = typeof selector == 'function',
+ add,
+ el;
+
+ for (; i < len; i++) {
+ el = els[i];
+ add = false;
+ if (el) {
+ el = me.getElement(el);
+
+ if (isFunc) {
+ add = selector.call(el, el, me, i) !== false;
+ } else {
+ add = el.is(selector);
+ }
+
+ if (add) {
+ out.push(me.transformElement(el));
+ }
+ }
+ }
+
+ me.elements = out;
+ return me;
+ },
+
+
+ indexOf: function(el) {
+ return Ext.Array.indexOf(this.elements, this.transformElement(el));
+ },
+
+
+ replaceElement: function(el, replacement, domReplace) {
+ var index = !isNaN(el) ? el : this.indexOf(el),
+ d;
+ if (index > -1) {
+ replacement = Ext.getDom(replacement);
+ if (domReplace) {
+ d = this.elements[index];
+ d.parentNode.insertBefore(replacement, d);
+ Ext.removeNode(d);
+ }
+ Ext.Array.splice(this.elements, index, 1, replacement);
+ }
+ return this;
+ },
+
+
+ clear: function() {
+ this.elements = [];
+ },
+
+ addElements: function(els, root) {
+ if (!els) {
+ return this;
+ }
+
+ if (typeof els == "string") {
+ els = Ext.dom.Element.selectorFunction(els, root);
+ }
+
+ var yels = this.elements,
+ eLen = els.length,
+ e;
+
+ for (e = 0; e < eLen; e++) {
+ yels.push(Ext.get(els[e]));
+ }
+
+ return this;
+ },
+
+
+ first: function() {
+ return this.item(0);
+ },
+
+
+ last: function() {
+ return this.item(this.getCount() - 1);
+ },
+
+
+ contains: function(el) {
+ return this.indexOf(el) != -1;
+ },
+
+
+ removeElement: function(keys, removeDom) {
+ keys = [].concat(keys);
+
+ var me = this,
+ elements = me.elements,
+ kLen = keys.length,
+ val, el, k;
+
+ for (k = 0; k < kLen; k++) {
+ val = keys[k];
+
+ if ((el = (elements[val] || elements[val = me.indexOf(val)]))) {
+ if (removeDom) {
+ if (el.dom) {
+ el.remove();
+ } else {
+ Ext.removeNode(el);
+ }
+ }
+ Ext.Array.erase(elements, val, 1);
+ }
+ }
+
+ return me;
+ }
+
+}, function() {
+ this.importElementMethods();
+
+ this.prototype.on = this.prototype.addListener;
+
+ if (Ext.DomQuery){
+ Ext.dom.Element.selectorFunction = Ext.DomQuery.select;
+ }
+
+
+ Ext.dom.Element.select = function(selector, root) {
+ var elements;
+
+ if (typeof selector == "string") {
+ elements = Ext.dom.Element.selectorFunction(selector, root);
+ }
+ else if (selector.length !== undefined) {
+ elements = selector;
+ }
+ else {
+ }
+
+ return new Ext.CompositeElementLite(elements);
+ };
+
+
+ Ext.select = function() {
+ return Ext.dom.Element.select.apply(Ext.dom.Element, arguments);
+ };
+});
+
+
+Ext.define('Ext.util.Animate', {
+ requires: ['Ext.Element', 'Ext.CompositeElementLite'],
+ uses: ['Ext.fx.Manager', 'Ext.fx.Anim'],
+
+
+ animate: function(animObj) {
+ var me = this;
+ if (Ext.fx.Manager.hasFxBlock(me.id)) {
+ return me;
+ }
+ Ext.fx.Manager.queueFx(new Ext.fx.Anim(me.anim(animObj)));
+ return this;
+ },
+
+
+ anim: function(config) {
+ if (!Ext.isObject(config)) {
+ return (config) ? {} : false;
+ }
+
+ var me = this;
+
+ if (config.stopAnimation) {
+ me.stopAnimation();
+ }
+
+ Ext.applyIf(config, Ext.fx.Manager.getFxDefaults(me.id));
+
+ return Ext.apply({
+ target: me,
+ paused: true
+ }, config);
+ },
+
+
+ stopFx: Ext.Function.alias(Ext.util.Animate, 'stopAnimation'),
+
+
+ stopAnimation: function() {
+ Ext.fx.Manager.stopAnimation(this.id);
+ return this;
+ },
+
+
+ syncFx: function() {
+ Ext.fx.Manager.setFxDefaults(this.id, {
+ concurrent: true
+ });
+ return this;
+ },
+
+
+ sequenceFx: function() {
+ Ext.fx.Manager.setFxDefaults(this.id, {
+ concurrent: false
+ });
+ return this;
+ },
+
+
+ hasActiveFx: Ext.Function.alias(Ext.util.Animate, 'getActiveAnimation'),
+
+
+ getActiveAnimation: function() {
+ return Ext.fx.Manager.getActiveAnimation(this.id);
+ }
+}, function(){
+
+ Ext.applyIf(Ext.Element.prototype, this.prototype);
+
+ Ext.CompositeElementLite.importElementMethods();
+});
+
+
+Ext.define('Ext.util.ElementContainer', {
+
+ childEls: [
+
+
+
+
+ ],
+
+ constructor: function () {
+ var me = this,
+ childEls;
+
+
+
+ if (me.hasOwnProperty('childEls')) {
+ childEls = me.childEls;
+ delete me.childEls;
+
+ me.addChildEls.apply(me, childEls);
+ }
+ },
+
+ destroy: function () {
+ var me = this,
+ childEls = me.getChildEls(),
+ child, childName, i, k;
+
+ for (i = childEls.length; i--; ) {
+ childName = childEls[i];
+ if (typeof childName != 'string') {
+ childName = childName.name;
+ }
+
+ child = me[childName];
+ if (child) {
+ me[childName] = null;
+ child.remove();
+ }
+ }
+ },
+
+
+ addChildEls: function () {
+ var me = this,
+ args = arguments;
+
+ if (me.hasOwnProperty('childEls')) {
+ me.childEls.push.apply(me.childEls, args);
+ } else {
+ me.childEls = me.getChildEls().concat(Array.prototype.slice.call(args));
+ }
+
+ me.prune(me.childEls, false);
+ },
+
+
+ applyChildEls: function(el, id) {
+ var me = this,
+ childEls = me.getChildEls(),
+ baseId, childName, i, selector, value;
+
+ baseId = (id || me.id) + '-';
+ for (i = childEls.length; i--; ) {
+ childName = childEls[i];
+
+ if (typeof childName == 'string') {
+
+
+ value = el.getById(baseId + childName);
+ } else {
+ if ((selector = childName.select)) {
+ value = Ext.select(selector, true, el.dom);
+ } else if ((selector = childName.selectNode)) {
+ value = Ext.get(Ext.DomQuery.selectNode(selector, el.dom));
+ } else {
+
+ value = el.getById(childName.id || (baseId + childName.itemId));
+ }
+
+ childName = childName.name;
+ }
+
+ me[childName] = value;
+ }
+ },
+
+ getChildEls: function () {
+ var me = this,
+ self;
+
+
+ if (me.hasOwnProperty('childEls')) {
+ return me.childEls;
+ }
+
+
+
+ self = me.self;
+ return self.$childEls || me.getClassChildEls(self);
+ },
+
+ getClassChildEls: function (cls) {
+ var me = this,
+ result = cls.$childEls,
+ childEls, i, length, forked, mixin, mixins, name, parts, proto, supr, superMixins;
+
+ if (!result) {
+
+
+
+
+ supr = cls.superclass;
+ if (supr) {
+ supr = supr.self;
+ parts = [supr.$childEls || me.getClassChildEls(supr)];
+ superMixins = supr.prototype.mixins || {};
+ } else {
+ parts = [];
+ superMixins = {};
+ }
+
+ proto = cls.prototype;
+ mixins = proto.mixins;
+ for (name in mixins) {
+ if (mixins.hasOwnProperty(name) && !superMixins.hasOwnProperty(name)) {
+ mixin = mixins[name].self;
+ parts.push(mixin.$childEls || me.getClassChildEls(mixin));
+ }
+ }
+
+ parts.push(proto.hasOwnProperty('childEls') && proto.childEls);
+
+ for (i = 0, length = parts.length; i < length; ++i) {
+ childEls = parts[i];
+ if (childEls && childEls.length) {
+ if (!result) {
+ result = childEls;
+ } else {
+ if (!forked) {
+ forked = true;
+ result = result.slice(0);
+ }
+ result.push.apply(result, childEls);
+ }
+ }
+ }
+
+ cls.$childEls = result = (result ? me.prune(result, !forked) : []);
+ }
+
+ return result;
+ },
+
+ prune: function (childEls, shared) {
+ var index = childEls.length,
+ map = {},
+ name;
+
+ while (index--) {
+ name = childEls[index];
+ if (typeof name != 'string') {
+ name = name.name;
+ }
+
+ if (!map[name]) {
+ map[name] = 1;
+ } else {
+ if (shared) {
+ shared = false;
+ childEls = childEls.slice(0);
+ }
+ Ext.Array.erase(childEls, index, 1);
+ }
+ }
+
+ return childEls;
+ },
+
+
+ removeChildEls: function (testFn) {
+ var me = this,
+ old = me.getChildEls(),
+ keepers = (me.childEls = []),
+ n, i, cel;
+
+ for (i = 0, n = old.length; i < n; ++i) {
+ cel = old[i];
+ if (!testFn(cel)) {
+ keepers.push(cel);
+ }
+ }
+ }
+});
+
+
+Ext.define('Ext.util.Renderable', {
+ requires: [
+ 'Ext.dom.Element'
+ ],
+
+ frameCls: Ext.baseCSSPrefix + 'frame',
+
+ frameIdRegex: /[\-]frame\d+[TMB][LCR]$/,
+
+ frameElementCls: {
+ tl: [],
+ tc: [],
+ tr: [],
+ ml: [],
+ mc: [],
+ mr: [],
+ bl: [],
+ bc: [],
+ br: []
+ },
+
+ frameElNames: ['TL','TC','TR','ML','MC','MR','BL','BC','BR'],
+
+ frameTpl: [
+ '{%this.renderDockedItems(out,values,0);%}',
+ ' {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">',
+ '{%this.applyRenderTpl(out, values)%}',
+ '
',
+ ' {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">
',
+ '| {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">', + '{%this.applyRenderTpl(out, values)%}', + ' | ', + '{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"> |
Kids: ',
+ * ' {#}. {name}
Name: {name}
', + * 'Title: {title}
', + * 'Company: {company}
', + * 'Kids: ',
+ * ' {name}
{name}\'s favorite beverages:
', + * ' - {.}
',
+ * 'Name: {name}
', + * 'Kids: ',
+ * ' {name} Dad: {parent.name}
Name: {name}
', + * 'Kids: ',
+ * ' {name}
Name: {name}
', + * 'Kids: ',
+ * ' {name} is a ',
+ * ' teenager kid baby Name: {name} Kids: ',
+ * ' {name} is a ',
+ * ' girl boy Name: {name} Kids: ',
+ * ' {#}: {name} In 5 Years: {age+5} Dad: {parent.name} Name: {name} Company: {[values.company.toUpperCase() + ", " + values.title]} Kids: ',
+ * ' Name: {name} Company: {[values.company.toUpperCase() + ", " + values.title]} Kids: ',
+ * ' Name: {name} Kids: ',
+ * ' Girl: {name} - {age} Boy: {name} - {age} {name} is a baby!',
+ * '{name}',
+ * '',
+ * '{text}',
+ '
',
+ '{%this.renderBody(out, values)%}',
+ '
',
+ '',
+ '{%if (oh.getSuffixConfig!==Ext.emptyFn) {',
+ 'if(oc=oh.getSuffixConfig())dh.generateMarkup(oc, out)',
+ '}%}',
+ {
+ disableFormats: true,
+ definitions: 'var dh=Ext.DomHelper;'
+ }
+ ],
+
+ constructor: function(config) {
+ var me = this,
+ type;
+
+ me.callParent(arguments);
+
+
+ me.flexSortFn = Ext.Function.bind(me.flexSort, me);
+
+ me.initOverflowHandler();
+
+ type = typeof me.padding;
+ if (type == 'string' || type == 'number') {
+ me.padding = Ext.util.Format.parseBox(me.padding);
+ me.padding.height = me.padding.top + me.padding.bottom;
+ me.padding.width = me.padding.left + me.padding.right;
+ }
+ },
+
+ getNames: function () {
+ return this.names;
+ },
+
+
+
+ _percentageRe: /^\s*(\d+(?:\.\d*)?)\s*[%]\s*$/,
+
+ getItemSizePolicy: function (item, ownerSizeModel) {
+ var me = this,
+ policy = me.sizePolicy,
+ align = me.align,
+ flex = item.flex,
+ key = align,
+ names = me.names,
+ width = item[names.width],
+ height = item[names.height],
+ percentageRe = me._percentageRe,
+ percentageWidth = percentageRe.test(width),
+ isStretch = (align == 'stretch');
+
+ if ((isStretch || flex || percentageWidth) && !ownerSizeModel) {
+ ownerSizeModel = me.owner.getSizeModel();
+ }
+
+ if (isStretch) {
+
+
+ if (!percentageRe.test(height) && ownerSizeModel[names.height].shrinkWrap) {
+ key = 'stretchmax';
+
+
+
+ }
+ } else if (align != 'stretchmax') {
+ if (percentageRe.test(height)) {
+
+
+ key = 'stretch';
+ } else {
+ key = '';
+ }
+ }
+
+ if (flex || percentageWidth) {
+
+
+ if (!ownerSizeModel[names.width].shrinkWrap) {
+ policy = policy.flex;
+ }
+ }
+
+ return policy[key];
+ },
+
+ flexSort: function (a, b) {
+ var maxWidthName = this.getNames().maxWidth,
+ infiniteValue = Infinity;
+
+ a = a.target[maxWidthName] || infiniteValue;
+ b = b.target[maxWidthName] || infiniteValue;
+
+
+ if (!isFinite(a) && !isFinite(b)) {
+ return 0;
+ }
+
+ return a - b;
+ },
+
+ isItemBoxParent: function (itemContext) {
+ return true;
+ },
+
+ isItemShrinkWrap: function (item) {
+ return true;
+ },
+
+
+ minSizeSortFn: function(a, b) {
+ return b.available - a.available;
+ },
+
+ roundFlex: function(width) {
+ return Math.ceil(width);
+ },
+
+
+ beginCollapse: function(child) {
+ var me = this;
+
+ if (me.direction === 'vertical' && child.collapsedVertical()) {
+ child.collapseMemento.capture(['flex']);
+ delete child.flex;
+ } else if (me.direction === 'horizontal' && child.collapsedHorizontal()) {
+ child.collapseMemento.capture(['flex']);
+ delete child.flex;
+ }
+ },
+
+
+ beginExpand: function(child) {
+
+
+ child.collapseMemento.restore(['flex']);
+ },
+
+ beginLayout: function (ownerContext) {
+ var me = this,
+ smp = me.owner.stretchMaxPartner,
+ style = me.innerCt.dom.style,
+ names = me.getNames();
+
+ ownerContext.boxNames = names;
+
+
+
+ me.overflowHandler.beginLayout(ownerContext);
+
+
+ if (typeof smp === 'string') {
+ smp = Ext.getCmp(smp) || me.owner.query(smp)[0];
+ }
+
+ ownerContext.stretchMaxPartner = smp && ownerContext.context.getCmp(smp);
+
+ me.callParent(arguments);
+
+ ownerContext.innerCtContext = ownerContext.getEl('innerCt', me);
+
+
+ me.scrollParallel = !!(me.owner.autoScroll || me.owner[names.overflowX]);
+
+
+ me.scrollPerpendicular = !!(me.owner.autoScroll || me.owner[names.overflowY]);
+
+
+ if (me.scrollParallel) {
+ me.scrollPos = me.owner.getTargetEl().dom[names.scrollLeft];
+ }
+
+
+ style.width = '';
+ style.height = '';
+ },
+
+ beginLayoutCycle: function (ownerContext, firstCycle) {
+ var me = this,
+ align = me.align,
+ names = ownerContext.boxNames,
+ pack = me.pack,
+ heightModelName = names.heightModel;
+
+
+
+ me.overflowHandler.beginLayoutCycle(ownerContext, firstCycle);
+
+ me.callParent(arguments);
+
+
+
+
+ ownerContext.parallelSizeModel = ownerContext[names.widthModel];
+ ownerContext.perpendicularSizeModel = ownerContext[heightModelName];
+
+ ownerContext.boxOptions = {
+ align: align = {
+ stretch: align == 'stretch',
+ stretchmax: align == 'stretchmax',
+ center: align == names.center
+ },
+ pack: pack = {
+ center: pack == 'center',
+ end: pack == 'end'
+ }
+ };
+
+
+
+
+
+
+
+ if (align.stretch && ownerContext.perpendicularSizeModel.shrinkWrap) {
+ align.stretchmax = true;
+ align.stretch = false;
+ }
+
+
+ align.nostretch = !(align.stretch || align.stretchmax);
+
+
+
+
+
+ if (ownerContext.parallelSizeModel.shrinkWrap) {
+ pack.center = pack.end = false;
+ }
+
+ me.cacheFlexes(ownerContext);
+
+
+
+
+ if (Ext.isWebKit) {
+ me.targetEl.setWidth(20000);
+ }
+ },
+
+
+ cacheFlexes: function (ownerContext) {
+ var me = this,
+ names = ownerContext.boxNames,
+ widthModelName = names.widthModel,
+ heightModelName = names.heightModel,
+ nostretch = ownerContext.boxOptions.align.nostretch,
+ totalFlex = 0,
+ childItems = ownerContext.childItems,
+ i = childItems.length,
+ flexedItems = [],
+ minWidth = 0,
+ minWidthName = names.minWidth,
+ percentageRe = me._percentageRe,
+ percentageWidths = 0,
+ percentageHeights = 0,
+ child, childContext, flex, match;
+
+ while (i--) {
+ childContext = childItems[i];
+ child = childContext.target;
+
+
+
+
+ if (childContext[widthModelName].calculated) {
+ childContext.flex = flex = child.flex;
+ if (flex) {
+ totalFlex += flex;
+ flexedItems.push(childContext);
+ minWidth += child[minWidthName] || 0;
+ } else {
+ match = percentageRe.exec(child[names.width]);
+ childContext.percentageParallel = parseFloat(match[1]) / 100;
+ ++percentageWidths;
+ }
+ }
+
+
+
+ if (nostretch && childContext[heightModelName].calculated) {
+
+
+ match = percentageRe.exec(child[names.height]);
+ childContext.percentagePerpendicular = parseFloat(match[1]) / 100;
+ ++percentageHeights;
+ }
+ }
+
+ ownerContext.flexedItems = flexedItems;
+ ownerContext.flexedMinSize = minWidth;
+ ownerContext.totalFlex = totalFlex;
+ ownerContext.percentageWidths = percentageWidths;
+ ownerContext.percentageHeights = percentageHeights;
+
+
+
+
+ Ext.Array.sort(flexedItems, me.flexSortFn);
+ },
+
+ calculate: function(ownerContext) {
+ var me = this,
+ targetSize = me.getContainerSize(ownerContext),
+ names = ownerContext.boxNames,
+ state = ownerContext.state,
+ plan = state.boxPlan || (state.boxPlan = {});
+
+ plan.targetSize = targetSize;
+
+
+ if (!ownerContext.parallelSizeModel.shrinkWrap && !targetSize[names.gotWidth]) {
+ me.done = false;
+ return;
+ }
+
+ if (!state.parallelDone) {
+ state.parallelDone = me.calculateParallel(ownerContext, names, plan);
+ }
+
+ if (!state.perpendicularDone) {
+ state.perpendicularDone = me.calculatePerpendicular(ownerContext, names, plan);
+ }
+
+ if (state.parallelDone && state.perpendicularDone) {
+
+
+
+
+ if (me.owner.dock && (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) && !me.owner.width && !me.horizontal) {
+ plan.isIEVerticalDock = true;
+ plan.calculatedWidth = plan.maxSize + ownerContext.getPaddingInfo().width + ownerContext.getFrameInfo().width;
+ }
+
+ me.publishInnerCtSize(ownerContext, me.reserveOffset ? me.availableSpaceOffset : 0);
+
+
+ if (me.done && ownerContext.childItems.length > 1 && ownerContext.boxOptions.align.stretchmax && !state.stretchMaxDone) {
+ me.calculateStretchMax(ownerContext, names, plan);
+ state.stretchMaxDone = true;
+ }
+ } else {
+ me.done = false;
+ }
+ },
+
+ calculateParallel: function(ownerContext, names, plan) {
+ var me = this,
+ widthName = names.width,
+ childItems = ownerContext.childItems,
+ leftName = names.left,
+ rightName = names.right,
+ setWidthName = names.setWidth,
+ childItemsLength = childItems.length,
+ flexedItems = ownerContext.flexedItems,
+ flexedItemsLength = flexedItems.length,
+ pack = ownerContext.boxOptions.pack,
+ padding = me.padding,
+ containerWidth = plan.targetSize[widthName],
+ totalMargin = 0,
+ left = padding[leftName],
+ nonFlexWidth = left + padding[rightName] + me.scrollOffset +
+ (me.reserveOffset ? me.availableSpaceOffset : 0),
+ scrollbarWidth = Ext.getScrollbarSize()[names.width],
+ i, childMargins, remainingWidth, remainingFlex, childContext, flex, flexedWidth,
+ contentWidth, mayNeedScrollbarAdjust, childWidth, percentageSpace;
+
+
+
+
+
+
+
+ if (scrollbarWidth &&
+ me.scrollPerpendicular &&
+ ownerContext.parallelSizeModel.shrinkWrap &&
+ !ownerContext.boxOptions.align.stretch &&
+ !ownerContext.perpendicularSizeModel.shrinkWrap) {
+
+
+
+
+ if (!ownerContext.state.perpendicularDone) {
+ return false;
+ }
+ mayNeedScrollbarAdjust = true;
+ }
+
+
+ for (i = 0; i < childItemsLength; ++i) {
+ childContext = childItems[i];
+ childMargins = childContext.marginInfo || childContext.getMarginInfo();
+
+ totalMargin += childMargins[widthName];
+
+ if (!childContext[names.widthModel].calculated) {
+ childWidth = childContext.getProp(widthName);
+ nonFlexWidth += childWidth;
+ if (isNaN(nonFlexWidth)) {
+ return false;
+ }
+ }
+ }
+
+ nonFlexWidth += totalMargin;
+ if (ownerContext.percentageWidths) {
+ percentageSpace = containerWidth - totalMargin;
+ if (isNaN(percentageSpace)) {
+ return false;
+ }
+
+ for (i = 0; i < childItemsLength; ++i) {
+ childContext = childItems[i];
+ if (childContext.percentageParallel) {
+ childWidth = Math.ceil(percentageSpace * childContext.percentageParallel);
+ childWidth = childContext.setWidth(childWidth);
+ nonFlexWidth += childWidth;
+ }
+ }
+ }
+
+
+
+ if (ownerContext.parallelSizeModel.shrinkWrap) {
+ plan.availableSpace = 0;
+ plan.tooNarrow = false;
+ } else {
+ plan.availableSpace = containerWidth - nonFlexWidth;
+
+
+ plan.tooNarrow = plan.availableSpace < ownerContext.flexedMinSize;
+ if (plan.tooNarrow && Ext.getScrollbarSize()[names.height] && me.scrollParallel && ownerContext.state.perpendicularDone) {
+ ownerContext.state.perpendicularDone = false;
+ for (i = 0; i < childItemsLength; ++i) {
+ childItems[i].invalidate();
+ }
+ }
+ }
+
+ contentWidth = nonFlexWidth;
+ remainingWidth = plan.availableSpace;
+ remainingFlex = ownerContext.totalFlex;
+
+
+ for (i = 0; i < flexedItemsLength; i++) {
+ childContext = flexedItems[i];
+ flex = childContext.flex;
+ flexedWidth = me.roundFlex((flex / remainingFlex) * remainingWidth);
+ flexedWidth = childContext[setWidthName](flexedWidth);
+
+
+
+ contentWidth += flexedWidth;
+
+ remainingWidth = Math.max(0, remainingWidth - flexedWidth);
+ remainingFlex -= flex;
+ }
+
+ if (pack.center) {
+ left += remainingWidth / 2;
+
+
+ if (left < 0) {
+ left = 0;
+ }
+ } else if (pack.end) {
+ left += remainingWidth;
+ }
+
+
+ for (i = 0; i < childItemsLength; ++i) {
+ childContext = childItems[i];
+ childMargins = childContext.marginInfo;
+
+ left += childMargins[leftName];
+
+ childContext.setProp(names.x, left);
+
+
+
+
+
+ left += childMargins[rightName] + childContext.props[widthName];
+ }
+
+ contentWidth += ownerContext.targetContext.getPaddingInfo()[widthName];
+
+
+ ownerContext.state.contentWidth = contentWidth;
+
+
+
+ if (mayNeedScrollbarAdjust &&
+ (ownerContext.peek(names.contentHeight) > plan.targetSize[names.height])) {
+ contentWidth += scrollbarWidth;
+ ownerContext[names.hasOverflowY] = true;
+
+
+ ownerContext.target.componentLayout[names.setWidthInDom] = true;
+
+
+
+
+
+ ownerContext[names.invalidateScrollY] = (Ext.isStrict && Ext.isIE8);
+ }
+ ownerContext[names.setContentWidth](contentWidth);
+
+ return true;
+ },
+
+ calculatePerpendicular: function(ownerContext, names, plan) {
+ var me = this,
+ heightShrinkWrap = ownerContext.perpendicularSizeModel.shrinkWrap,
+ targetSize = plan.targetSize,
+ childItems = ownerContext.childItems,
+ childItemsLength = childItems.length,
+ mmax = Math.max,
+ heightName = names.height,
+ setHeightName = names.setHeight,
+ topName = names.top,
+ topPositionName = names.y,
+ padding = me.padding,
+ top = padding[topName],
+ availHeight = targetSize[heightName] - top - padding[names.bottom],
+ align = ownerContext.boxOptions.align,
+ isStretch = align.stretch,
+ isStretchMax = align.stretchmax,
+ isCenter = align.center,
+ maxHeight = 0,
+ hasPercentageSizes = 0,
+ scrollbarHeight = Ext.getScrollbarSize().height,
+ childTop, i, childHeight, childMargins, diff, height, childContext,
+ stretchMaxPartner, stretchMaxChildren, shrinkWrapParallelOverflow,
+ percentagePerpendicular;
+
+ if (isStretch || (isCenter && !heightShrinkWrap)) {
+ if (isNaN(availHeight)) {
+ return false;
+ }
+ }
+
+
+
+
+
+
+
+ if (me.scrollParallel && plan.tooNarrow) {
+ if (heightShrinkWrap) {
+ shrinkWrapParallelOverflow = true;
+ } else {
+ availHeight -= scrollbarHeight;
+ plan.targetSize[heightName] -= scrollbarHeight;
+ }
+ }
+
+ if (isStretch) {
+ height = availHeight;
+ } else {
+ for (i = 0; i < childItemsLength; i++) {
+ childContext = childItems[i];
+ childMargins = (childContext.marginInfo || childContext.getMarginInfo())[heightName];
+
+ if (!(percentagePerpendicular = childContext.percentagePerpendicular)) {
+ childHeight = childContext.getProp(heightName);
+ } else {
+ ++hasPercentageSizes;
+ if (heightShrinkWrap) {
+
+
+ continue;
+ } else {
+ childHeight = percentagePerpendicular * availHeight - childMargins;
+ childHeight = childContext[names.setHeight](childHeight);
+ }
+ }
+
+
+ if (isNaN(maxHeight = mmax(maxHeight, childHeight + childMargins,
+ childContext.target[names.minHeight] || 0))) {
+ return false;
+ }
+ }
+
+
+
+ if (shrinkWrapParallelOverflow) {
+ maxHeight += scrollbarHeight;
+ ownerContext[names.hasOverflowX] = true;
+
+
+ ownerContext.target.componentLayout[names.setHeightInDom] = true;
+
+
+
+
+
+ ownerContext[names.invalidateScrollX] = (Ext.isStrict && Ext.isIE8);
+ }
+
+
+
+ stretchMaxPartner = ownerContext.stretchMaxPartner;
+ if (stretchMaxPartner) {
+
+ ownerContext.setProp('maxChildHeight', maxHeight);
+ stretchMaxChildren = stretchMaxPartner.childItems;
+
+ if (stretchMaxChildren && stretchMaxChildren.length) {
+ maxHeight = mmax(maxHeight, stretchMaxPartner.getProp('maxChildHeight'));
+ if (isNaN(maxHeight)) {
+ return false;
+ }
+ }
+ }
+
+ ownerContext[names.setContentHeight](maxHeight + me.padding[heightName] +
+ ownerContext.targetContext.getPaddingInfo()[heightName]);
+
+
+
+
+ if (shrinkWrapParallelOverflow) {
+ maxHeight -= scrollbarHeight;
+ }
+ plan.maxSize = maxHeight;
+
+ if (isStretchMax) {
+ height = maxHeight;
+ } else if (isCenter || hasPercentageSizes) {
+ height = heightShrinkWrap ? maxHeight : mmax(availHeight, maxHeight);
+
+
+
+
+
+ height -= ownerContext.innerCtContext.getBorderInfo()[heightName];
+ }
+ }
+
+ for (i = 0; i < childItemsLength; i++) {
+ childContext = childItems[i];
+ childMargins = childContext.marginInfo || childContext.getMarginInfo();
+
+ childTop = top + childMargins[topName];
+
+ if (isStretch) {
+ childContext[setHeightName](height - childMargins[heightName]);
+ } else {
+ percentagePerpendicular = childContext.percentagePerpendicular;
+ if (heightShrinkWrap && percentagePerpendicular) {
+ childMargins = childContext.marginInfo || childContext.getMarginInfo();
+ childHeight = percentagePerpendicular * height - childMargins[heightName];
+ childHeight = childContext.setHeight(childHeight);
+ }
+
+ if (isCenter) {
+ diff = height - childContext.props[heightName];
+ if (diff > 0) {
+ childTop = top + Math.round(diff / 2);
+ }
+ }
+ }
+
+ childContext.setProp(topPositionName, childTop);
+ }
+
+ return true;
+ },
+
+ calculateStretchMax: function (ownerContext, names, plan) {
+ var me = this,
+ heightName = names.height,
+ widthName = names.width,
+ childItems = ownerContext.childItems,
+ length = childItems.length,
+ height = plan.maxSize,
+ onBeforeInvalidateChild = me.onBeforeInvalidateChild,
+ onAfterInvalidateChild = me.onAfterInvalidateChild,
+ childContext, props, i, childHeight;
+
+ for (i = 0; i < length; ++i) {
+ childContext = childItems[i];
+
+ props = childContext.props;
+ childHeight = height - childContext.getMarginInfo()[heightName];
+
+ if (childHeight != props[heightName] ||
+ childContext[names.heightModel].constrained) {
+
+
+
+
+
+
+
+ childContext.invalidate({
+ before: onBeforeInvalidateChild,
+ after: onAfterInvalidateChild,
+ layout: me,
+
+ childWidth: props[widthName],
+
+ childHeight: childHeight,
+ childX: props.x,
+ childY: props.y,
+ names: names
+ });
+ }
+ }
+ },
+
+ completeLayout: function(ownerContext) {
+ var me = this,
+ names = ownerContext.boxNames,
+ invalidateScrollX = ownerContext.invalidateScrollX,
+ invalidateScrollY = ownerContext.invalidateScrollY,
+ dom, el, overflowX, overflowY, styles;
+
+ me.overflowHandler.completeLayout(ownerContext);
+
+ if (invalidateScrollX || invalidateScrollY) {
+ el = me.getTarget();
+ dom = el.dom;
+ styles = dom.style;
+
+ if (invalidateScrollX) {
+
+ overflowX = el.getStyle('overflowX');
+ if (overflowX == 'auto') {
+
+ overflowX = styles.overflowX;
+ styles.overflowX = 'scroll';
+ } else {
+ invalidateScrollX = false;
+ }
+ }
+
+ if (invalidateScrollY) {
+
+ overflowY = el.getStyle('overflowY');
+ if (overflowY == 'auto') {
+
+ overflowY = styles.overflowY;
+ styles.overflowY = 'scroll';
+ } else {
+ invalidateScrollY = false;
+ }
+ }
+
+ if (invalidateScrollX || invalidateScrollY) {
+
+ dom.scrollWidth;
+
+ if (invalidateScrollX) {
+ styles.overflowX = overflowX;
+ }
+ if (invalidateScrollY) {
+ styles.overflowY = overflowY;
+ }
+ }
+ }
+
+
+ if (me.scrollParallel) {
+ me.owner.getTargetEl().dom[names.scrollLeft] = me.scrollPos;
+ }
+ },
+
+ finishedLayout: function(ownerContext) {
+ this.overflowHandler.finishedLayout(ownerContext);
+ this.callParent(arguments);
+
+
+
+
+
+
+
+ if (Ext.isWebKit) {
+ this.targetEl.setWidth(ownerContext.innerCtContext.props.width);
+ }
+ },
+
+ onBeforeInvalidateChild: function (childContext, options) {
+
+ var heightModelName = options.names.heightModel;
+
+
+
+
+
+ if (!childContext[heightModelName].constrainedMax) {
+
+
+ childContext[heightModelName] = Ext.layout.SizeModel.calculated;
+ }
+ },
+
+ onAfterInvalidateChild: function (childContext, options) {
+
+ var names = options.names,
+ scrollbarSize = Ext.getScrollbarSize(),
+ childHeight = options.childHeight,
+ childWidth = options.childWidth;
+
+ childContext.setProp('x', options.childX);
+ childContext.setProp('y', options.childY);
+
+ if (childContext[names.heightModel].calculated) {
+
+
+ childContext[names.setHeight](childHeight);
+ }
+
+ if (childContext[names.widthModel].calculated) {
+ childContext[names.setWidth](childWidth);
+ }
+ },
+
+ publishInnerCtSize: function(ownerContext, reservedSpace) {
+ var me = this,
+ names = ownerContext.boxNames,
+ heightName = names.height,
+ widthName = names.width,
+ align = ownerContext.boxOptions.align,
+ dock = me.owner.dock,
+ padding = me.padding,
+ plan = ownerContext.state.boxPlan,
+ targetSize = plan.targetSize,
+ height = targetSize[heightName],
+ innerCtContext = ownerContext.innerCtContext,
+ innerCtWidth = (ownerContext.parallelSizeModel.shrinkWrap || (plan.tooNarrow && me.scrollParallel)
+ ? ownerContext.state.contentWidth
+ : targetSize[widthName]) - (reservedSpace || 0),
+ innerCtHeight;
+
+ if (align.stretch) {
+ innerCtHeight = height;
+ } else {
+ innerCtHeight = plan.maxSize + padding[names.top] + padding[names.bottom] + innerCtContext.getBorderInfo()[heightName];
+
+ if (!ownerContext.perpendicularSizeModel.shrinkWrap && align.center) {
+ innerCtHeight = Math.max(height, innerCtHeight);
+ }
+ }
+
+ innerCtContext[names.setWidth](innerCtWidth);
+ innerCtContext[names.setHeight](innerCtHeight);
+
+
+ if (isNaN(innerCtWidth + innerCtHeight)) {
+ me.done = false;
+ }
+
+
+
+
+
+
+
+ if (plan.calculatedWidth && (dock == 'left' || dock == 'right')) {
+
+ ownerContext.setWidth(plan.calculatedWidth, true, true);
+ }
+ },
+
+ onRemove: function(comp){
+ var me = this;
+ me.callParent(arguments);
+ if (me.overflowHandler) {
+ me.overflowHandler.onRemove(comp);
+ }
+ if (comp.layoutMarginCap == me.id) {
+ delete comp.layoutMarginCap;
+ }
+ },
+
+
+ initOverflowHandler: function() {
+ var me = this,
+ handler = me.overflowHandler,
+ handlerType,
+ constructor;
+
+ if (typeof handler == 'string') {
+ handler = {
+ type: handler
+ };
+ }
+
+ handlerType = 'None';
+ if (handler && handler.type !== undefined) {
+ handlerType = handler.type;
+ }
+
+ constructor = Ext.layout.container.boxOverflow[handlerType];
+ if (constructor[me.type]) {
+ constructor = constructor[me.type];
+ }
+
+ me.overflowHandler = Ext.create('Ext.layout.container.boxOverflow.' + handlerType, me, handler);
+ },
+
+
+
+ getRenderTarget: function() {
+ return this.targetEl;
+ },
+
+
+
+ getElementTarget: function() {
+ return this.innerCt;
+ },
+
+
+
+ destroy: function() {
+ Ext.destroy(this.innerCt, 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',
+
+ type : 'hbox',
+
+ direction: 'horizontal',
+
+ horizontal: true,
+
+ names: {
+
+ lr: 'lr',
+ left: 'left',
+ leftCap: 'Left',
+ right: 'right',
+ position: 'left',
+ width: 'width',
+ contentWidth: 'contentWidth',
+ minWidth: 'minWidth',
+ maxWidth: 'maxWidth',
+ widthCap: 'Width',
+ widthModel: 'widthModel',
+ widthIndex: 0,
+ x: 'x',
+ scrollLeft: 'scrollLeft',
+ overflowX: 'overflowX',
+ hasOverflowX: 'hasOverflowX',
+ invalidateScrollX: 'invalidateScrollX',
+
+
+ center: 'middle',
+ top: 'top',
+ topPosition: 'top',
+ bottom: 'bottom',
+ height: 'height',
+ contentHeight: 'contentHeight',
+ minHeight: 'minHeight',
+ maxHeight: 'maxHeight',
+ heightCap: 'Height',
+ heightModel: 'heightModel',
+ heightIndex: 1,
+ y: 'y',
+ scrollTop: 'scrollTop',
+ overflowY: 'overflowY',
+ hasOverflowY: 'hasOverflowY',
+ invalidateScrollY: 'invalidateScrollY',
+
+
+ getWidth: 'getWidth',
+ getHeight: 'getHeight',
+ setWidth: 'setWidth',
+ setHeight: 'setHeight',
+ gotWidth: 'gotWidth',
+ gotHeight: 'gotHeight',
+ setContentWidth: 'setContentWidth',
+ setContentHeight: 'setContentHeight',
+ setWidthInDom: 'setWidthInDom',
+ setHeightInDom: 'setHeightInDom'
+ },
+
+ sizePolicy: {
+ flex: {
+ '': {
+ setsWidth: 1,
+ setsHeight: 0
+ },
+ stretch: {
+ setsWidth: 1,
+ setsHeight: 1
+ },
+ stretchmax: {
+ readsHeight: 1,
+ setsWidth: 1,
+ setsHeight: 1
+ }
+ },
+ '': {
+ setsWidth: 0,
+ setsHeight: 0
+ },
+ stretch: {
+ setsWidth: 0,
+ setsHeight: 1
+ },
+ stretchmax: {
+ readsHeight: 1,
+ setsWidth: 0,
+ setsHeight: 1
+ }
+ }
+});
+
+
+Ext.define('Ext.layout.container.VBox', {
+
+
+
+ alias: ['layout.vbox'],
+ extend: 'Ext.layout.container.Box',
+ alternateClassName: 'Ext.layout.VBoxLayout',
+
+
+
+
+ align : 'left',
+
+ type: 'vbox',
+
+ direction: 'vertical',
+
+ horizontal: false,
+
+ names: {
+
+ lr: 'tb',
+ left: 'top',
+ leftCap: 'Top',
+ right: 'bottom',
+ position: 'top',
+ width: 'height',
+ contentWidth: 'contentHeight',
+ minWidth: 'minHeight',
+ maxWidth: 'maxHeight',
+ widthCap: 'Height',
+ widthModel: 'heightModel',
+ widthIndex: 1,
+ x: 'y',
+ scrollLeft: 'scrollTop',
+ overflowX: 'overflowY',
+ hasOverflowX: 'hasOverflowY',
+ invalidateScrollX: 'invalidateScrollY',
+
+
+ center: 'center',
+ top: 'left',
+ topPosition: 'left',
+ bottom: 'right',
+ height: 'width',
+ contentHeight: 'contentWidth',
+ minHeight: 'minWidth',
+ maxHeight: 'maxWidth',
+ heightCap: 'Width',
+ heightModel: 'widthModel',
+ heightIndex: 0,
+ y: 'x',
+ scrollTop: 'scrollLeft',
+ overflowY: 'overflowX',
+ hasOverflowY: 'hasOverflowX',
+ invalidateScrollY: 'invalidateScrollX',
+
+
+ getWidth: 'getHeight',
+ getHeight: 'getWidth',
+ setWidth: 'setHeight',
+ setHeight: 'setWidth',
+ gotWidth: 'gotHeight',
+ gotHeight: 'gotWidth',
+ setContentWidth: 'setContentHeight',
+ setContentHeight: 'setContentWidth',
+ setWidthInDom: 'setHeightInDom',
+ setHeightInDom: 'setWidthInDom'
+ },
+
+ sizePolicy: {
+ flex: {
+ '': {
+ setsWidth: 0,
+ setsHeight: 1
+ },
+ stretch: {
+ setsWidth: 1,
+ setsHeight: 1
+ },
+ stretchmax: {
+ readsWidth: 1,
+ setsWidth: 1,
+ setsHeight: 1
+ }
+ },
+ '': {
+ setsWidth: 0,
+ setsHeight: 0
+ },
+ stretch: {
+ setsWidth: 1,
+ setsHeight: 0
+ },
+ stretchmax: {
+ readsWidth: 1,
+ setsWidth: 1,
+ setsHeight: 0
+ }
+ }
+});
+
+
+Ext.define('Ext.toolbar.Toolbar', {
+ extend: 'Ext.container.Container',
+ requires: [
+ 'Ext.toolbar.Fill',
+ 'Ext.layout.container.HBox',
+ 'Ext.layout.container.VBox'
+ ],
+ uses: [
+ 'Ext.toolbar.Separator'
+ ],
+ alias: 'widget.toolbar',
+ alternateClassName: 'Ext.Toolbar',
+
+
+ isToolbar: true,
+ baseCls : Ext.baseCSSPrefix + 'toolbar',
+ ariaRole : 'toolbar',
+
+ defaultType: 'button',
+
+
+ vertical: false,
+
+
+
+
+ enableOverflow: false,
+
+
+ menuTriggerCls: Ext.baseCSSPrefix + 'toolbar-more-icon',
+
+
+ trackMenus: true,
+
+ itemCls: Ext.baseCSSPrefix + 'toolbar-item',
+
+ statics: {
+ shortcuts: {
+ '-' : 'tbseparator',
+ ' ' : 'tbspacer'
+ },
+
+ shortcutsHV: {
+
+ 0: {
+ '->': { xtype: 'tbfill', height: 0 }
+ },
+
+ 1: {
+ '->': { xtype: 'tbfill', width: 0 }
+ }
+ }
+ },
+
+ 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'
+ });
+
+ if (me.vertical) {
+ me.addClsWithUI('vertical');
+ }
+
+
+ if (me.ui === 'footer') {
+ me.ignoreBorderManagement = true;
+ }
+
+ me.callParent();
+
+
+ me.addEvents('overflowchange');
+ },
+
+ getRefItems: function(deep) {
+ var me = this,
+ items = me.callParent(arguments),
+ layout = me.layout,
+ handler;
+
+ if (deep && me.enableOverflow) {
+ handler = layout.overflowHandler;
+ if (handler && handler.menu) {
+ items = items.concat(handler.menu.getRefItems(deep));
+ }
+ }
+ return items;
+ },
+
+
+
+
+ lookupComponent: function(c) {
+ if (typeof c == 'string') {
+ var T = Ext.toolbar.Toolbar,
+ shortcut = T.shortcutsHV[this.vertical ? 1 : 0][c] || T.shortcuts[c];
+
+ if (typeof shortcut == 'string') {
+ c = {
+ xtype: shortcut
+ };
+ } else if (shortcut) {
+ c = Ext.apply({}, 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);
+ }
+ return c;
+ },
+
+
+ trackMenu: function(item, remove) {
+ if (this.trackMenus && item.menu) {
+ var method = remove ? 'mun' : 'mon',
+ me = this;
+
+ me[method](item, 'mouseover', me.onButtonOver, me);
+ me[method](item, 'menushow', me.onButtonMenuShow, me);
+ me[method](item, 'menuhide', me.onButtonMenuHide, me);
+ }
+ },
+
+
+ constructButton: function(item) {
+ return item.events ? item
+ : Ext.widget(item.split ? 'splitbutton' : this.defaultType, item);
+ },
+
+
+ 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);
+ },
+
+
+ onRemove: function(c) {
+ this.callParent(arguments);
+ this.trackMenu(c, true);
+ },
+
+ getChildItemsToDisable: function() {
+ return this.items.getRange();
+ },
+
+
+ onButtonOver: 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;
+ }
+});
+
+
+Ext.define('Ext.container.DockingContainer', {
+
+
+
+ requires: ['Ext.util.MixedCollection', 'Ext.Element' ],
+
+
+
+ isDockingContainer: true,
+
+
+ defaultDockWeights: {
+ top: { render: 1, visual: 1 },
+ left: { render: 3, visual: 5 },
+ right: { render: 5, visual: 7 },
+ bottom: { render: 7, visual: 3 }
+ },
+
+
+
+
+
+ dockOrder: {
+ top: -1,
+ left: -1,
+ right: 1,
+ bottom: 1
+ },
+
+
+ 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 (pos !== undefined) {
+ me.dockedItems.insert(pos + i, item);
+ } else {
+ me.dockedItems.add(item);
+ }
+ if (item.onAdded !== Ext.emptyFn) {
+ item.onAdded(me, i);
+ }
+ if (me.onDockedAdd !== Ext.emptyFn) {
+ me.onDockedAdd(item);
+ }
+ }
+
+ if (me.rendered && !me.suspendLayout) {
+ me.updateLayout();
+ }
+ return items;
+ },
+
+ destroyDockedItems: function(){
+ var dockedItems = this.dockedItems,
+ c;
+
+ if (dockedItems) {
+ while ((c = dockedItems.first())) {
+ this.removeDocked(c, true);
+ }
+ }
+ },
+
+ doRenderDockedItems: function (out, renderData, after) {
+
+
+
+
+
+
+
+
+ var me = renderData.$comp,
+ layout = me.componentLayout,
+ items,
+ tree;
+
+ if (layout.getDockedItems && !renderData.$skipDockedItems) {
+ items = layout.getDockedItems('render', !after);
+ tree = items && layout.getItemsRenderTree(items);
+
+ if (tree) {
+ Ext.DomHelper.generateMarkup(tree, out);
+ }
+ }
+ },
+
+
+ getDockedComponent: function(comp) {
+ if (Ext.isObject(comp)) {
+ comp = comp.getItemId();
+ }
+ return this.dockedItems.get(comp);
+ },
+
+
+ getDockedItems : function(selector, beforeBody) {
+ var dockedItems = this.getComponentLayout().getDockedItems('render', beforeBody);
+
+ if (selector && dockedItems.length) {
+ dockedItems = Ext.ComponentQuery.query(selector, dockedItems);
+ }
+
+ return dockedItems;
+ },
+
+ getDockingRefItems: function(deep, containerItems) {
+
+ var selector = deep && '*,* *',
+
+ dockedItems = this.getDockedItems(selector, true),
+ items;
+
+
+ dockedItems.push.apply(dockedItems, containerItems);
+
+
+ items = this.getDockedItems(selector, false);
+ dockedItems.push.apply(dockedItems, items);
+
+ return dockedItems;
+ },
+
+ initDockingItems: function() {
+ var me = this,
+ items = me.dockedItems;
+
+ me.dockedItems = new Ext.util.AbstractMixedCollection(false, me.getComponentId);
+ if (items) {
+ me.addDocked(items);
+ }
+ },
+
+
+ insertDocked : function(pos, items) {
+ this.addDocked(items, pos);
+ },
+
+
+
+ onDockedAdd : Ext.emptyFn,
+
+ onDockedRemove : Ext.emptyFn,
+
+
+ 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();
+ } else if (hasLayout) {
+
+ layout.afterRemove(item);
+ }
+
+ if (!me.destroying && !me.suspendLayout) {
+ me.updateLayout();
+ }
+
+ return item;
+ },
+
+ setupDockingRenderTpl: function (renderTpl) {
+ renderTpl.renderDockedItems = this.doRenderDockedItems;
+ }
+});
+
+
+Ext.define('Ext.panel.AbstractPanel', {
+
+
+
+ extend: 'Ext.container.Container',
+
+ mixins: {
+ docking: 'Ext.container.DockingContainer'
+ },
+
+ requires: ['Ext.util.MixedCollection', 'Ext.Element', 'Ext.toolbar.Toolbar'],
+
+
+
+
+ baseCls : Ext.baseCSSPrefix + 'panel',
+
+
+
+
+
+
+
+
+
+
+ isPanel: true,
+
+ componentLayout: 'dock',
+
+ childEls: [
+ 'body'
+ ],
+
+ renderTpl: [
+
+ '{% this.renderDockedItems(out,values,0); %}',
+
+
+
+
+
+
+
+ (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks) ? '' : '',
+ ' {bodyCls}',
+ ' {baseCls}-body-{ui}',
+ ' {parent.baseCls}-body-{parent.ui}-{.} ',
+ ' " style="{bodyStyle}" >',
+ '{%this.renderContainer(out,values);%}',
+ '
',
+ '{% this.renderDockedItems(out,values,1); %}'
+ ],
+
+ bodyPosProps: {
+ x: 'x',
+ y: 'y'
+ },
+
+
+
+
+ border: true,
+
+
+ emptyArray: [],
+
+ initComponent : function() {
+ var me = this;
+
+
+
+
+ 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();
+ },
+
+ beforeDestroy: function(){
+ this.destroyDockedItems();
+ this.callParent();
+ },
+
+
+ initItems : function() {
+ this.callParent();
+ this.initDockingItems();
+ },
+
+
+ initRenderData: function() {
+ var me = this,
+ data = me.callParent();
+
+ me.initBodyStyles();
+ me.protoBody.writeTo(data);
+ delete me.protoBody;
+
+ return data;
+ },
+
+
+ getComponent: function(comp) {
+ var component = this.callParent(arguments);
+ if (component === undefined && !Ext.isNumber(comp)) {
+
+ component = this.getDockedComponent(comp);
+ }
+ return component;
+ },
+
+ getProtoBody: function () {
+ var me = this,
+ body = me.protoBody;
+
+ if (!body) {
+ me.protoBody = body = new Ext.util.ProtoElement({
+ cls: me.bodyCls,
+ style: me.bodyStyle,
+ clsProp: 'bodyCls',
+ styleProp: 'bodyStyle',
+ styleIsText: true
+ });
+ }
+
+ return body;
+ },
+
+
+ initBodyStyles: function() {
+ var me = this,
+ body = me.getProtoBody(),
+ Element = Ext.Element;
+
+ if (me.bodyPadding !== undefined) {
+ body.setStyle('padding', Element.unitizeBox((me.bodyPadding === true) ? 5 : me.bodyPadding));
+ }
+ if (me.frame && me.bodyBorder) {
+ if (!Ext.isNumber(me.bodyBorder)) {
+ me.bodyBorder = 1;
+ }
+ body.setStyle('border-width', Element.unitizeBox(me.bodyBorder));
+ }
+ },
+
+ getCollapsedDockedItems: function () {
+ var me = this;
+ return me.collapseMode == 'placeholder' ? me.emptyArray : [ me.getReExpander() ];
+ },
+
+
+ setBodyStyle: function(style, value) {
+ var me = this,
+ body = me.rendered ? me.body : me.getProtoBody();
+
+ if (Ext.isFunction(style)) {
+ style = style();
+ }
+ if (arguments.length == 1) {
+ if (Ext.isString(style)) {
+ style = Ext.Element.parseStyles(style);
+ }
+ body.setStyle(style);
+ } else {
+ body.setStyle(style, value);
+ }
+ return me;
+ },
+
+
+ addBodyCls: function(cls) {
+ var me = this,
+ body = me.rendered ? me.body : me.getProtoBody();
+
+ body.addCls(cls);
+ return me;
+ },
+
+
+ removeBodyCls: function(cls) {
+ var me = this,
+ body = me.rendered ? me.body : me.getProtoBody();
+
+ body.removeCls(cls);
+ return me;
+ },
+
+
+ addUIClsToElement: function(cls) {
+ var me = this,
+ result = me.callParent(arguments);
+
+ me.addBodyCls([Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls]);
+ return result;
+ },
+
+
+ removeUIClsFromElement: function(cls) {
+ var me = this,
+ result = me.callParent(arguments);
+
+ me.removeBodyCls([Ext.baseCSSPrefix + cls, me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls]);
+ return result;
+ },
+
+
+ addUIToElement: function() {
+ var me = this;
+
+ me.callParent(arguments);
+ me.addBodyCls(me.baseCls + '-body-' + me.ui);
+ },
+
+
+ removeUIFromElement: function() {
+ var me = this;
+
+ me.callParent(arguments);
+ me.removeBodyCls(me.baseCls + '-body-' + me.ui);
+ },
+
+
+ getTargetEl : function() {
+ return this.body;
+ },
+
+ getRefItems: function(deep) {
+ var items = this.callParent(arguments);
+
+ return this.getDockingRefItems(deep, items);
+ },
+
+ setupRenderTpl: function (renderTpl) {
+ this.callParent(arguments);
+ this.setupDockingRenderTpl(renderTpl);
+ }
+});
+
+
+Ext.define('Ext.layout.component.Body', {
+
+
+
+ alias: ['layout.body'],
+
+ extend: 'Ext.layout.component.Auto',
+
+
+
+ type: 'body',
+
+ beginLayout: function (ownerContext) {
+ this.callParent(arguments);
+
+ ownerContext.bodyContext = ownerContext.getEl('body');
+ },
+
+
+
+
+
+
+
+
+ calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+ var height = this.callParent(arguments);
+
+ if (ownerContext.targetContext != ownerContext) {
+ height += ownerContext.getPaddingInfo().height;
+ }
+
+ return height;
+ },
+
+ calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+ var width = this.callParent(arguments);
+
+ if (ownerContext.targetContext != ownerContext) {
+ width += ownerContext.getPaddingInfo().width;
+ }
+
+ return width;
+ },
+
+ measureContentWidth: function (ownerContext) {
+ return ownerContext.bodyContext.setWidth(ownerContext.bodyContext.el.dom.offsetWidth, false);
+ },
+
+ measureContentHeight: function (ownerContext) {
+ return ownerContext.bodyContext.setHeight(ownerContext.bodyContext.el.dom.offsetHeight, false);
+ },
+
+ publishInnerHeight: function (ownerContext, height) {
+ var innerHeight = height - ownerContext.getFrameInfo().height,
+ targetContext = ownerContext.targetContext;
+
+ if (targetContext != ownerContext) {
+ innerHeight -= ownerContext.getPaddingInfo().height;
+ }
+
+
+ return ownerContext.bodyContext.setHeight(innerHeight, !ownerContext.heightModel.natural);
+ },
+
+ publishInnerWidth: function (ownerContext, width) {
+ var innerWidth = width - ownerContext.getFrameInfo().width,
+ targetContext = ownerContext.targetContext;
+
+ if (targetContext != ownerContext) {
+ innerWidth -= ownerContext.getPaddingInfo().width;
+ }
+
+ ownerContext.bodyContext.setWidth(innerWidth, !ownerContext.widthModel.natural);
+ }
+});
+
+
+Ext.define('Ext.panel.Header', {
+ extend: 'Ext.container.Container',
+ uses: ['Ext.panel.Tool', 'Ext.draw.Component', 'Ext.util.CSS', 'Ext.layout.component.Body', 'Ext.Img'],
+ alias: 'widget.header',
+
+
+ isHeader : true,
+ defaultType : 'tool',
+ indicateDrag : false,
+ weight : -1,
+ componentLayout: 'body',
+
+
+ titleAlign: 'left',
+
+ childEls: [
+ 'body'
+ ],
+
+ renderTpl: [
+ ' {parent.baseCls}-body-{parent.ui}-{.}"',
+ ' style="{bodyStyle}" >',
+ '{%this.renderContainer(out,values)%}',
+ '
'
+ ],
+
+ headingTpl: '{title}',
+
+ shrinkWrap: 3,
+
+
+
+
+
+
+
+ initComponent: function() {
+ var me = this,
+ ruleStyle,
+ rule,
+ style,
+ ui,
+ tempEl;
+
+ me.addEvents(
+
+ 'click',
+
+
+ 'dblclick'
+ );
+
+ 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.dock]);
+
+ if (me.indicateDrag) {
+ me.addCls(me.indicateDragCls);
+ }
+
+
+ if (!Ext.isEmpty(me.iconCls) || !Ext.isEmpty(me.icon)) {
+ me.initIconCmp();
+ me.items.push(me.iconCmp);
+ }
+
+
+ if (me.orientation == 'vertical') {
+ me.layout = {
+ type : 'vbox',
+ align: 'center'
+ };
+ me.textConfig = {
+ width: 16,
+ cls: me.baseCls + '-text',
+ type: 'text',
+ text: me.title,
+ rotate: {
+ degrees: 90
+ }
+ };
+ ui = me.ui;
+ if (Ext.isArray(ui)) {
+ ui = ui[0];
+ }
+ ruleStyle = '.' + me.baseCls + '-text-' + ui;
+ if (Ext.scopeResetCSS) {
+ ruleStyle = '.' + Ext.baseCSSPrefix + 'reset ' + ruleStyle;
+ }
+ rule = Ext.util.CSS.getRule(ruleStyle);
+
+
+ if (rule) {
+ style = rule.style;
+ } else {
+ style = (tempEl = Ext.resetElement.createChild({style: 'position:absolute', cls: me.baseCls + '-text-' + ui})).getStyles('fontFamily', 'fontWeight', 'fontSize', 'color');
+ tempEl.remove();
+ }
+ if (style) {
+ Ext.apply(me.textConfig, {
+ 'font-family': style.fontFamily,
+ 'font-weight': style.fontWeight,
+ 'font-size': style.fontSize,
+ fill: style.color
+ });
+ }
+ me.titleCmp = new Ext.draw.Component({
+ width : 16,
+ ariaRole : 'heading',
+ focusable : false,
+ viewBox : false,
+ flex : 1,
+ id : me.id + '_hd',
+ autoSize : true,
+ items : me.textConfig,
+ xhooks: {
+ setSize: function (width) {
+
+ this.callParent([width]);
+ }
+ },
+
+
+ childEls : [
+ { name: 'textEl', select: '.' + me.baseCls + '-text' }
+ ]
+ });
+ } else {
+ me.layout = {
+ type : 'hbox',
+ align: 'middle'
+ };
+ me.titleCmp = new Ext.Component({
+ ariaRole : 'heading',
+ focusable : false,
+ noWrap : true,
+ flex : 1,
+ id : me.id + '_hd',
+ style : 'text-align:' + me.titleAlign,
+ cls : me.baseCls + '-text-container',
+ renderTpl : me.getTpl('headingTpl'),
+ renderData: {
+ title: me.title,
+ cls : me.baseCls,
+ ui : me.ui
+ },
+ childEls : ['textEl']
+ });
+ }
+ me.items.push(me.titleCmp);
+
+
+ me.items = me.items.concat(me.tools);
+ me.callParent();
+
+ me.on({
+ dblclick: me.onDblClick,
+ click: me.onClick,
+ element: 'el',
+ scope: me
+ });
+ },
+
+ initIconCmp: function() {
+ var me = this,
+ cfg = {
+ focusable: false,
+ src: Ext.BLANK_IMAGE_URL,
+ cls: [me.baseCls + '-icon', me.iconCls],
+ id: me.id + '-iconEl',
+ iconCls: me.iconCls
+ };
+
+ if (!Ext.isEmpty(me.icon)) {
+ delete cfg.iconCls;
+ cfg.src = me.icon;
+ }
+
+ me.iconCmp = new Ext.Img(cfg);
+ },
+
+ afterRender: function() {
+ this.el.unselectable();
+ this.callParent();
+ },
+
+
+ addUIClsToElement: function(cls) {
+ var me = this,
+ result = me.callParent(arguments),
+ classes = [me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
+ array, i;
+
+ 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) {
+ var me = this,
+ result = me.callParent(arguments),
+ classes = [me.baseCls + '-body-' + cls, me.baseCls + '-body-' + me.ui + '-' + cls],
+ array, i;
+
+ 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() {
+ var me = this,
+ array, cls;
+
+ me.callParent(arguments);
+
+ cls = me.baseCls + '-body-' + me.ui;
+ if (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;
+ }
+ }
+
+ if (me.titleCmp && me.titleCmp.rendered && me.titleCmp.textEl) {
+ me.titleCmp.textEl.addCls(me.baseCls + '-text-' + me.ui);
+ }
+ },
+
+
+ removeUIFromElement: function() {
+ var me = this,
+ array, cls;
+
+ me.callParent(arguments);
+
+ cls = me.baseCls + '-body-' + me.ui;
+ 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;
+ }
+ }
+
+ if (me.titleCmp && me.titleCmp.rendered && me.titleCmp.textEl) {
+ me.titleCmp.textEl.removeCls(me.baseCls + '-text-' + me.ui);
+ }
+ },
+
+ onClick: function(e) {
+ this.fireClickEvent('click', e);
+ },
+
+ onDblClick: function(e){
+ this.fireClickEvent('dblclick', e);
+ },
+
+ fireClickEvent: function(type, e){
+ var toolCls = '.' + Ext.panel.Tool.prototype.baseCls;
+ if (!e.getTarget(toolCls)) {
+ this.fireEvent(type, this, e);
+ }
+ },
+
+ getFocusEl: function() {
+ return this.el;
+ },
+
+ getTargetEl: function() {
+ return this.body || this.frameBody || this.el;
+ },
+
+
+ setTitle: function(title) {
+ var me = this,
+ sprite,
+ surface;
+ if (me.rendered) {
+ if (me.titleCmp.rendered) {
+ if (me.titleCmp.surface) {
+ me.title = title || '';
+ sprite = me.titleCmp.surface.items.items[0];
+ surface = me.titleCmp.surface;
+
+ surface.remove(sprite);
+ me.textConfig.type = 'text';
+ me.textConfig.text = title;
+ sprite = surface.add(me.textConfig);
+ sprite.setAttributes({
+ rotate: {
+ degrees: 90
+ }
+ }, true);
+ me.titleCmp.autoSizeSurface();
+ } else {
+ me.title = title;
+ me.titleCmp.textEl.update(me.title || ' ');
+ }
+ me.titleCmp.updateLayout();
+ } else {
+ me.titleCmp.on({
+ render: function() {
+ me.setTitle(title);
+ },
+ single: true
+ });
+ }
+ } else {
+ me.title = title;
+ }
+ },
+
+
+ getMinWidth: function() {
+ var me = this,
+ textEl = me.titleCmp.textEl.dom,
+ result,
+ tools = me.tools,
+ l, i;
+
+
+ textEl.style.display = 'inline';
+ result = textEl.offsetWidth;
+ textEl.style.display = '';
+
+
+ if (tools && (l = tools.length)) {
+ for (i = 0; i < l; i++) {
+ if (tools[i].el) {
+ result += tools[i].el.dom.offsetWidth;
+ }
+ }
+ }
+
+
+ if (me.iconCmp) {
+ result += me.iconCmp.el.dom.offsetWidth;
+ }
+
+
+ return result + 10;
+ },
+
+
+ setIconCls: function(cls) {
+ var me = this,
+ isEmpty = !cls || !cls.length,
+ iconCmp = me.iconCmp;
+
+ me.iconCls = cls;
+ if (!me.iconCmp && !isEmpty) {
+ me.initIconCmp();
+ me.insert(0, me.iconCmp);
+ } else if (iconCmp) {
+ if (isEmpty) {
+ me.iconCmp.destroy();
+ delete me.iconCmp;
+ } else {
+ iconCmp.removeCls(iconCmp.iconCls);
+ iconCmp.addCls(cls);
+ iconCmp.iconCls = cls;
+ }
+ }
+ },
+
+
+ setIcon: function(icon) {
+ var me = this,
+ isEmpty = !icon || !icon.length,
+ iconCmp = me.iconCmp;
+
+ me.icon = icon;
+ if (!me.iconCmp && !isEmpty) {
+ me.initIconCmp();
+ me.insert(0, me.iconCmp);
+ } else if (iconCmp) {
+ if (isEmpty) {
+ me.iconCmp.destroy();
+ delete me.iconCmp;
+ } else {
+ iconCmp.setSrc(me.icon);
+ }
+ }
+ },
+
+
+ addTool: function(tool) {
+ this.tools.push(this.add(tool));
+ },
+
+
+ onAdd: function(component, index) {
+ this.callParent(arguments);
+ if (component instanceof Ext.panel.Tool) {
+ component.bindTo(this.ownerCt);
+ this.tools[component.type] = component;
+ }
+ },
+
+
+ initRenderData: function() {
+ return Ext.applyIf(this.callParent(), {
+ bodyCls: this.bodyCls
+ });
+ }
+});
+
+
+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.Element', {
+
+
+
+ extend: 'Ext.fx.target.Target',
+
+
+
+ type: 'element',
+
+ getElVal: function(el, attr, val) {
+ if (val == undefined) {
+ if (attr === 'x') {
+ val = el.getX();
+ }
+ else if (attr === 'y') {
+ val = el.getY();
+ }
+ else if (attr === 'scrollTop') {
+ val = el.getScroll().top;
+ }
+ else if (attr === 'scrollLeft') {
+ val = el.getScroll().left;
+ }
+ else if (attr === 'height') {
+ val = el.getHeight();
+ }
+ else if (attr === 'width') {
+ val = el.getWidth();
+ }
+ else {
+ val = el.getStyle(attr);
+ }
+ }
+ return val;
+ },
+
+ getAttr: function(attr, val) {
+ var el = this.target;
+ return [[ el, this.getElVal(el, attr, val)]];
+ },
+
+ setAttr: function(targetData) {
+ var target = this.target,
+ ln = targetData.length,
+ attrs, attr, o, i, j, ln2, element, value;
+ for (i = 0; i < ln; i++) {
+ attrs = targetData[i].attrs;
+ for (attr in attrs) {
+ if (attrs.hasOwnProperty(attr)) {
+ ln2 = attrs[attr].length;
+ for (j = 0; j < ln2; j++) {
+ o = attrs[attr][j];
+ element = o[0];
+ value = o[1];
+ if (attr === 'x') {
+ element.setX(value);
+ } else if (attr === 'y') {
+ element.setY(value);
+ } else if (attr === 'scrollTop') {
+ element.scrollTo('top', value);
+ } else if (attr === 'scrollLeft') {
+ element.scrollTo('left',value);
+ } else if (attr === 'width') {
+ element.setWidth(value);
+ } else if (attr === 'height') {
+ element.setHeight(value);
+ } else {
+ element.setStyle(attr, value);
+ }
+ }
+ }
+ }
+ }
+ }
+});
+
+
+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.CompositeElement', {
+
+
+
+ extend: 'Ext.fx.target.Element',
+
+
+
+
+ isComposite: true,
+
+ constructor: function(target) {
+ target.id = target.id || Ext.id(null, 'ext-composite-');
+ this.callParent([target]);
+ },
+
+ getAttr: function(attr, val) {
+ var out = [],
+ elements = this.target.elements,
+ length = elements.length,
+ i,
+ el;
+
+ for (i = 0; i < length; i++) {
+ el = elements[i];
+
+ if (el) {
+ el = this.target.getElement(el);
+ out.push([el, this.getElVal(el, attr, val)]);
+ }
+ }
+
+ return out;
+ }
+});
+
+
+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.fx.target.Sprite', {
+
+
+
+ extend: 'Ext.fx.target.Target',
+
+
+
+ type: 'draw',
+
+ getFromPrim: function (sprite, attr) {
+ var obj;
+ switch (attr) {
+ case 'rotate':
+ case 'rotation':
+ obj = sprite.attr.rotation;
+ return {
+ x: obj.x || 0,
+ y: obj.y || 0,
+ degrees: obj.degrees || 0
+ };
+ case 'scale':
+ case 'scaling':
+ obj = sprite.attr.scaling;
+ return {
+ x: obj.x || 1,
+ y: obj.y || 1,
+ cx: obj.cx || 0,
+ cy: obj.cy || 0
+ };
+ case 'translate':
+ case 'translation':
+ obj = sprite.attr.translation;
+ return {
+ x: obj.x || 0,
+ y: obj.y || 0
+ };
+ default:
+ return sprite.attr[attr];
+ }
+ },
+
+ getAttr: function (attr, val) {
+ return [
+ [this.target, val != undefined ? val : this.getFromPrim(this.target, attr)]
+ ];
+ },
+
+ setAttr: function (targetData) {
+ var ln = targetData.length,
+ spriteArr = [],
+ attrsConf, attr, attrArr, attrs, sprite, idx, value, i, j, x, y, ln2;
+ for (i = 0; i < ln; i++) {
+ attrsConf = targetData[i].attrs;
+ for (attr in attrsConf) {
+ attrArr = attrsConf[attr];
+ ln2 = attrArr.length;
+ for (j = 0; j < ln2; j++) {
+ sprite = attrArr[j][0];
+ attrs = attrArr[j][1];
+ if (attr === 'translate' || attr === 'translation') {
+ value = {
+ x: attrs.x,
+ y: attrs.y
+ };
+ }
+ else if (attr === 'rotate' || attr === 'rotation') {
+ x = attrs.x;
+ if (isNaN(x)) {
+ x = null;
+ }
+ y = attrs.y;
+ if (isNaN(y)) {
+ y = null;
+ }
+ value = {
+ degrees: attrs.degrees,
+ x: x,
+ y: y
+ };
+ } else if (attr === 'scale' || attr === 'scaling') {
+ x = attrs.x;
+ if (isNaN(x)) {
+ x = null;
+ }
+ y = attrs.y;
+ if (isNaN(y)) {
+ y = null;
+ }
+ value = {
+ x: x,
+ y: y,
+ cx: attrs.cx,
+ cy: attrs.cy
+ };
+ }
+ else if (attr === 'width' || attr === 'height' || attr === 'x' || attr === 'y') {
+ value = parseFloat(attrs);
+ }
+ else {
+ value = attrs;
+ }
+ idx = Ext.Array.indexOf(spriteArr, sprite);
+ if (idx == -1) {
+ spriteArr.push([sprite, {}]);
+ idx = spriteArr.length - 1;
+ }
+ spriteArr[idx][1][attr] = value;
+ }
+ }
+ }
+ ln = spriteArr.length;
+ for (i = 0; i < ln; i++) {
+ spriteArr[i][0].setAttributes(spriteArr[i][1]);
+ }
+ this.target.redraw();
+ }
+});
+
+
+
+Ext.define('Ext.fx.target.CompositeSprite', {
+
+
+
+ extend: 'Ext.fx.target.Sprite',
+
+
+
+ getAttr: function(attr, val) {
+ var out = [],
+ sprites = [].concat(this.target.items),
+ length = sprites.length,
+ i,
+ sprite;
+
+ for (i = 0; i < length; i++) {
+ sprite = sprites[i];
+ out.push([sprite, val != undefined ? val : this.getFromPrim(sprite, attr)]);
+ }
+
+ 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 : parseFloat(o.left);
+ top = (o.top === undefined) ? undefined : parseFloat(o.top);
+ 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() : parseFloat(o.width);
+ h = (o.height === undefined) ? o.target.getHeight() : parseFloat(o.height);
+
+
+
+
+
+
+
+
+ if (isLastFrame || me.dynamic) {
+ 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.Queue', {
+
+ requires: ['Ext.util.HashMap'],
+
+ constructor: function() {
+ this.targets = new 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.Manager', {
+
+
+
+ singleton: true,
+
+ requires: ['Ext.util.MixedCollection',
+ 'Ext.fx.target.Element',
+ 'Ext.fx.target.ElementCSS',
+ 'Ext.fx.target.CompositeElement',
+ 'Ext.fx.target.CompositeElementCSS',
+ 'Ext.fx.target.Sprite',
+ 'Ext.fx.target.CompositeSprite',
+ 'Ext.fx.target.Component'],
+
+ mixins: {
+ queue: 'Ext.fx.Queue'
+ },
+
+
+
+ constructor: function() {
+ this.items = new Ext.util.MixedCollection();
+ this.mixins.queue.constructor.call(this);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ },
+
+
+ interval: 16,
+
+
+ forceJS: true,
+
+
+ createTarget: function(target) {
+ var me = this,
+ useCSS3 = !me.forceJS && Ext.supports.Transitions,
+ targetObj;
+
+ me.useCSS3 = useCSS3;
+
+ if (target) {
+
+ if (target.tagName || Ext.isString(target) || target.isFly) {
+ target = Ext.get(target);
+ targetObj = new Ext.fx.target['Element' + (useCSS3 ? 'CSS' : '')](target);
+ }
+
+ else if (target.dom) {
+ targetObj = new Ext.fx.target['Element' + (useCSS3 ? 'CSS' : '')](target);
+ }
+
+ else if (target.isComposite) {
+ targetObj = new Ext.fx.target['CompositeElement' + (useCSS3 ? 'CSS' : '')](target);
+ }
+
+ else if (target.isSprite) {
+ targetObj = new Ext.fx.target.Sprite(target);
+ }
+
+ else if (target.isCompositeSprite) {
+ targetObj = new Ext.fx.target.CompositeSprite(target);
+ }
+
+ else if (target.isComponent) {
+ targetObj = new Ext.fx.target.Component(target);
+ }
+ else if (target.isAnimTarget) {
+ return target;
+ }
+ else {
+ return null;
+ }
+ me.targets.add(targetObj);
+ return targetObj;
+ }
+ else {
+ return null;
+ }
+ },
+
+
+ addAnim: function(anim) {
+ var items = this.items,
+ task = this.task;
+
+
+
+
+ items.add(anim.id, anim);
+
+
+
+ if (!task && items.length) {
+ task = this.task = {
+ run: this.runner,
+ interval: this.interval,
+ scope: this
+ };
+
+ Ext.TaskManager.start(task);
+ }
+ },
+
+
+ removeAnim: function(anim) {
+ var me = this,
+ items = me.items,
+ task = me.task;
+
+ items.removeAtKey(anim.id);
+
+
+
+ if (task && !items.length) {
+
+ Ext.TaskManager.stop(task);
+ delete me.task;
+ }
+ },
+
+
+ runner: function() {
+ var me = this,
+ items = me.items.getRange(),
+ i = 0,
+ len = items.length,
+ anim;
+
+
+ me.targetArr = {};
+
+
+ me.timestamp = new Date();
+
+
+
+
+
+
+
+
+
+
+
+ for (; i < len; i++) {
+ anim = items[i];
+
+ if (anim.isReady()) {
+
+ me.startAnim(anim);
+ }
+ }
+
+ for (i = 0; i < len; i++) {
+ anim = items[i];
+
+ if (anim.isRunning()) {
+
+ me.runAnim(anim);
+ }
+ }
+
+
+ me.applyPendingAttrs();
+ },
+
+
+ startAnim: function(anim) {
+ anim.start(this.timestamp);
+ },
+
+
+ runAnim: function(anim) {
+ if (!anim) {
+ return;
+ }
+ var me = this,
+ targetId = anim.target.getId(),
+ useCSS3 = me.useCSS3 && anim.target.type == 'element',
+ elapsedTime = me.timestamp - anim.startTime,
+ lastFrame = (elapsedTime >= anim.duration),
+ target, o;
+
+ target = this.collectTargetData(anim, elapsedTime, useCSS3, lastFrame);
+
+
+
+ if (useCSS3) {
+
+
+
+ anim.target.setAttr(target.anims[anim.id].attributes, true);
+
+
+ me.collectTargetData(anim, anim.duration, useCSS3, lastFrame);
+
+
+ anim.paused = true;
+
+ target = anim.target.target;
+
+ if (anim.target.isComposite) {
+ target = anim.target.target.last();
+ }
+
+
+ o = {};
+ o[Ext.supports.CSS3TransitionEnd] = anim.lastFrame;
+ o.scope = anim;
+ o.single = true;
+ target.on(o);
+ }
+ },
+
+
+ collectTargetData: function(anim, elapsedTime, useCSS3, isLastFrame) {
+ var targetId = anim.target.getId(),
+ target = this.targetArr[targetId];
+
+ if (!target) {
+
+
+
+
+ target = this.targetArr[targetId] = {
+ id: targetId,
+ el: anim.target,
+ anims: {}
+ };
+ }
+
+
+
+
+
+ target.anims[anim.id] = {
+ id: anim.id,
+ anim: anim,
+ elapsed: elapsedTime,
+ isLastFrame: isLastFrame,
+
+ attributes: [{
+ duration: anim.duration,
+ easing: (useCSS3 && anim.reverse) ? anim.easingFn.reverse().toCSS3() : anim.easing,
+
+
+ attrs: anim.runAnim(elapsedTime)
+ }]
+ };
+
+ return target;
+ },
+
+
+ applyPendingAttrs: function() {
+ var targetArr = this.targetArr,
+ target, targetId, animWrap, anim, animId;
+
+
+ for (targetId in targetArr) {
+ if (targetArr.hasOwnProperty(targetId)) {
+ target = targetArr[targetId];
+
+
+ for (animId in target.anims) {
+ if (target.anims.hasOwnProperty(animId)) {
+ animWrap = target.anims[animId];
+ anim = animWrap.anim;
+
+
+ if (animWrap.attributes && anim.isRunning()) {
+
+ target.el.setAttr(animWrap.attributes, false, animWrap.isLastFrame);
+
+
+ if (animWrap.isLastFrame) {
+
+ anim.lastFrame();
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+});
+
+
+Ext.define('Ext.fx.Animator', {
+
+
+
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
+
+ requires: ['Ext.fx.Manager'],
+
+
+
+
+ isAnimator: true,
+
+
+ duration: 250,
+
+
+ delay: 0,
+
+
+ delayStart: 0,
+
+
+ dynamic: false,
+
+
+ easing: 'ease',
+
+
+ running: false,
+
+
+ paused: false,
+
+
+ damper: 1,
+
+
+ iterations: 1,
+
+
+ currentIteration: 0,
+
+
+ keyframeStep: 0,
+
+
+ animKeyFramesRE: /^(from|to|\d+%?)$/,
+
+
+
+
+ constructor: function(config) {
+ var me = this;
+ config = Ext.apply(me, config || {});
+ me.config = config;
+ me.id = Ext.id(null, 'ext-animator-');
+ me.addEvents(
+
+ 'beforeanimate',
+
+ 'keyframe',
+
+ 'afteranimate'
+ );
+ me.mixins.observable.constructor.call(me, config);
+ me.timeline = [];
+ me.createTimeline(me.keyframes);
+ if (me.target) {
+ me.applyAnimator(me.target);
+ Ext.fx.Manager.addAnim(me);
+ }
+ },
+
+
+ sorter: function (a, b) {
+ return a.pct - b.pct;
+ },
+
+
+ createTimeline: function(keyframes) {
+ var me = this,
+ attrs = [],
+ to = me.to || {},
+ duration = me.duration,
+ prevMs, ms, i, ln, pct, anim, nextAnim, attr;
+
+ for (pct in keyframes) {
+ if (keyframes.hasOwnProperty(pct) && me.animKeyFramesRE.test(pct)) {
+ attr = {attrs: Ext.apply(keyframes[pct], to)};
+
+ if (pct == "from") {
+ pct = 0;
+ }
+ else if (pct == "to") {
+ pct = 100;
+ }
+
+ attr.pct = parseInt(pct, 10);
+ attrs.push(attr);
+ }
+ }
+
+ Ext.Array.sort(attrs, me.sorter);
+
+
+
+
+
+ ln = attrs.length;
+ for (i = 0; i < ln; i++) {
+ prevMs = (attrs[i - 1]) ? duration * (attrs[i - 1].pct / 100) : 0;
+ ms = duration * (attrs[i].pct / 100);
+ me.timeline.push({
+ duration: ms - prevMs,
+ attrs: attrs[i].attrs
+ });
+ }
+ },
+
+
+ applyAnimator: function(target) {
+ var me = this,
+ anims = [],
+ timeline = me.timeline,
+ reverse = me.reverse,
+ ln = timeline.length,
+ anim, easing, damper, initial, attrs, lastAttrs, i;
+
+ if (me.fireEvent('beforeanimate', me) !== false) {
+ for (i = 0; i < ln; i++) {
+ anim = timeline[i];
+ attrs = anim.attrs;
+ easing = attrs.easing || me.easing;
+ damper = attrs.damper || me.damper;
+ delete attrs.easing;
+ delete attrs.damper;
+ anim = new Ext.fx.Anim({
+ target: target,
+ easing: easing,
+ damper: damper,
+ duration: anim.duration,
+ paused: true,
+ to: attrs
+ });
+ anims.push(anim);
+ }
+ me.animations = anims;
+ me.target = anim.target;
+ for (i = 0; i < ln - 1; i++) {
+ anim = anims[i];
+ anim.nextAnim = anims[i + 1];
+ anim.on('afteranimate', function() {
+ this.nextAnim.paused = false;
+ });
+ anim.on('afteranimate', function() {
+ this.fireEvent('keyframe', this, ++this.keyframeStep);
+ }, me);
+ }
+ anims[ln - 1].on('afteranimate', function() {
+ this.lastFrame();
+ }, me);
+ }
+ },
+
+
+ start: function(startTime) {
+ var me = this,
+ delay = me.delay,
+ delayStart = me.delayStart,
+ delayDelta;
+ if (delay) {
+ if (!delayStart) {
+ me.delayStart = startTime;
+ return;
+ }
+ else {
+ delayDelta = startTime - delayStart;
+ if (delayDelta < delay) {
+ return;
+ }
+ else {
+
+ startTime = new Date(delayStart.getTime() + delay);
+ }
+ }
+ }
+ if (me.fireEvent('beforeanimate', me) !== false) {
+ me.startTime = startTime;
+ me.running = true;
+ me.animations[me.keyframeStep].paused = false;
+ }
+ },
+
+
+ lastFrame: function() {
+ var me = this,
+ iter = me.iterations,
+ iterCount = me.currentIteration;
+
+ iterCount++;
+ if (iterCount < iter) {
+ me.startTime = new Date();
+ me.currentIteration = iterCount;
+ me.keyframeStep = 0;
+ me.applyAnimator(me.target);
+ me.animations[me.keyframeStep].paused = false;
+ }
+ else {
+ me.currentIteration = 0;
+ me.end();
+ }
+ },
+
+
+ end: function() {
+ var me = this;
+ me.fireEvent('afteranimate', me, me.startTime, new Date() - me.startTime);
+ },
+
+ isReady: function() {
+ return this.paused === false && this.running === false && this.iterations > 0;
+ },
+
+ isRunning: function() {
+
+ return false;
+ }
+});
+
+
+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;
+ }
+});
+
+//@define Ext.fx.Easing
+
+
+Ext.ns('Ext.fx');
+
+Ext.require('Ext.fx.CubicBezier', function() {
+ var math = Math,
+ pi = math.PI,
+ pow = math.pow,
+ sin = math.sin,
+ sqrt = math.sqrt,
+ abs = math.abs,
+ backInSeed = 1.70158;
+ Ext.fx.Easing = {
+
+
+
+
+
+
+
+
+ };
+
+ Ext.apply(Ext.fx.Easing, {
+ linear: function(n) {
+ return n;
+ },
+ ease: function(n) {
+ var q = 0.07813 - n / 2,
+ alpha = -0.25,
+ Q = sqrt(0.0066 + q * q),
+ x = Q - q,
+ X = pow(abs(x), 1/3) * (x < 0 ? -1 : 1),
+ y = -Q - q,
+ Y = pow(abs(y), 1/3) * (y < 0 ? -1 : 1),
+ t = X + Y + 0.25;
+ return pow(1 - t, 2) * 3 * t * 0.1 + (1 - t) * 3 * t * t + t * t * t;
+ },
+ easeIn: function (n) {
+ return pow(n, 1.7);
+ },
+ easeOut: function (n) {
+ return pow(n, 0.48);
+ },
+ easeInOut: function(n) {
+ var q = 0.48 - n / 1.04,
+ Q = sqrt(0.1734 + q * q),
+ x = Q - q,
+ X = pow(abs(x), 1/3) * (x < 0 ? -1 : 1),
+ y = -Q - q,
+ Y = pow(abs(y), 1/3) * (y < 0 ? -1 : 1),
+ t = X + Y + 0.5;
+ return (1 - t) * 3 * t * t + t * t * t;
+ },
+ backIn: function (n) {
+ return n * n * ((backInSeed + 1) * n - backInSeed);
+ },
+ backOut: function (n) {
+ n = n - 1;
+ return n * n * ((backInSeed + 1) * n + backInSeed) + 1;
+ },
+ elasticIn: function (n) {
+ if (n === 0 || n === 1) {
+ return n;
+ }
+ var p = 0.3,
+ s = p / 4;
+ return pow(2, -10 * n) * sin((n - s) * (2 * pi) / p) + 1;
+ },
+ elasticOut: function (n) {
+ return 1 - Ext.fx.Easing.elasticIn(1 - n);
+ },
+ bounceIn: function (n) {
+ return 1 - Ext.fx.Easing.bounceOut(1 - n);
+ },
+ bounceOut: function (n) {
+ var s = 7.5625,
+ p = 2.75,
+ l;
+ if (n < (1 / p)) {
+ l = s * n * n;
+ } else {
+ if (n < (2 / p)) {
+ n -= (1.5 / p);
+ l = s * n * n + 0.75;
+ } else {
+ if (n < (2.5 / p)) {
+ n -= (2.25 / p);
+ l = s * n * n + 0.9375;
+ } else {
+ n -= (2.625 / p);
+ l = s * n * n + 0.984375;
+ }
+ }
+ }
+ return l;
+ }
+ });
+ Ext.apply(Ext.fx.Easing, {
+ 'back-in': Ext.fx.Easing.backIn,
+ 'back-out': Ext.fx.Easing.backOut,
+ 'ease-in': Ext.fx.Easing.easeIn,
+ 'ease-out': Ext.fx.Easing.easeOut,
+ 'elastic-in': Ext.fx.Easing.elasticIn,
+ 'elastic-out': Ext.fx.Easing.elasticIn,
+ 'bounce-in': Ext.fx.Easing.bounceIn,
+ 'bounce-out': Ext.fx.Easing.bounceOut,
+ 'ease-in-out': Ext.fx.Easing.easeInOut
+ });
+});
+
+
+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),
+ red,
+ green,
+ blue,
+ rgb;
+
+ if (Ext.isArray(digits)) {
+ 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 color;
+ }
+ },
+
+
+ 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 : new 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 new 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.draw.Draw', {
+
+
+ singleton: true,
+
+ requires: ['Ext.draw.Color'],
+
+
+
+ pathToStringRE: /,?([achlmqrstvxz]),?/gi,
+ pathCommandRE: /([achlmqstvz])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?\s*,?\s*)+)/ig,
+ pathValuesRE: /(-?\d*\.?\d*(?:e[-+]?\d+)?)\s*,?\s*/ig,
+ stopsRE: /^(\d+%?)$/,
+ radian: Math.PI / 180,
+
+ availableAnimAttrs: {
+ along: "along",
+ blur: null,
+ "clip-rect": "csv",
+ cx: null,
+ cy: null,
+ fill: "color",
+ "fill-opacity": null,
+ "font-size": null,
+ height: null,
+ opacity: null,
+ path: "path",
+ r: null,
+ rotation: "csv",
+ rx: null,
+ ry: null,
+ scale: "csv",
+ stroke: "color",
+ "stroke-opacity": null,
+ "stroke-width": null,
+ translation: "csv",
+ width: null,
+ x: null,
+ y: null
+ },
+
+ is: function(o, type) {
+ type = String(type).toLowerCase();
+ return (type == "object" && o === Object(o)) ||
+ (type == "undefined" && typeof o == type) ||
+ (type == "null" && o === null) ||
+ (type == "array" && Array.isArray && Array.isArray(o)) ||
+ (Object.prototype.toString.call(o).toLowerCase().slice(8, -1)) == type;
+ },
+
+ ellipsePath: function(sprite) {
+ var attr = sprite.attr;
+ return Ext.String.format("M{0},{1}A{2},{3},0,1,1,{0},{4}A{2},{3},0,1,1,{0},{1}z", attr.x, attr.y - attr.ry, attr.rx, attr.ry, attr.y + attr.ry);
+ },
+
+ rectPath: function(sprite) {
+ var attr = sprite.attr;
+ if (attr.radius) {
+ return Ext.String.format("M{0},{1}l{2},0a{3},{3},0,0,1,{3},{3}l0,{5}a{3},{3},0,0,1,{4},{3}l{6},0a{3},{3},0,0,1,{4},{4}l0,{7}a{3},{3},0,0,1,{3},{4}z", attr.x + attr.radius, attr.y, attr.width - attr.radius * 2, attr.radius, -attr.radius, attr.height - attr.radius * 2, attr.radius * 2 - attr.width, attr.radius * 2 - attr.height);
+ }
+ else {
+ return Ext.String.format("M{0},{1}L{2},{1},{2},{3},{0},{3}z", attr.x, attr.y, attr.width + attr.x, attr.height + attr.y);
+ }
+ },
+
+
+ path2string: function () {
+ return this.join(",").replace(Ext.draw.Draw.pathToStringRE, "$1");
+ },
+
+
+ pathToString: function(arrayPath) {
+ return arrayPath.join(",").replace(Ext.draw.Draw.pathToStringRE, "$1");
+ },
+
+ parsePathString: function (pathString) {
+ if (!pathString) {
+ return null;
+ }
+ var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0},
+ data = [],
+ me = this;
+ if (me.is(pathString, "array") && me.is(pathString[0], "array")) {
+ data = me.pathClone(pathString);
+ }
+ if (!data.length) {
+ String(pathString).replace(me.pathCommandRE, function (a, b, c) {
+ var params = [],
+ name = b.toLowerCase();
+ c.replace(me.pathValuesRE, function (a, b) {
+ b && params.push(+b);
+ });
+ if (name == "m" && params.length > 2) {
+ data.push([b].concat(Ext.Array.splice(params, 0, 2)));
+ name = "l";
+ b = (b == "m") ? "l" : "L";
+ }
+ while (params.length >= paramCounts[name]) {
+ data.push([b].concat(Ext.Array.splice(params, 0, paramCounts[name])));
+ if (!paramCounts[name]) {
+ break;
+ }
+ }
+ });
+ }
+ data.toString = me.path2string;
+ return data;
+ },
+
+ mapPath: function (path, matrix) {
+ if (!matrix) {
+ return path;
+ }
+ var x, y, i, ii, j, jj, pathi;
+ path = this.path2curve(path);
+ for (i = 0, ii = path.length; i < ii; i++) {
+ pathi = path[i];
+ for (j = 1, jj = pathi.length; j < jj-1; j += 2) {
+ x = matrix.x(pathi[j], pathi[j + 1]);
+ y = matrix.y(pathi[j], pathi[j + 1]);
+ pathi[j] = x;
+ pathi[j + 1] = y;
+ }
+ }
+ return path;
+ },
+
+ pathClone: function(pathArray) {
+ var res = [],
+ j, jj, i, ii;
+ if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) {
+ pathArray = this.parsePathString(pathArray);
+ }
+ for (i = 0, ii = pathArray.length; i < ii; i++) {
+ res[i] = [];
+ for (j = 0, jj = pathArray[i].length; j < jj; j++) {
+ res[i][j] = pathArray[i][j];
+ }
+ }
+ res.toString = this.path2string;
+ return res;
+ },
+
+ pathToAbsolute: function (pathArray) {
+ if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) {
+ pathArray = this.parsePathString(pathArray);
+ }
+ var res = [],
+ x = 0,
+ y = 0,
+ mx = 0,
+ my = 0,
+ i = 0,
+ ln = pathArray.length,
+ r, pathSegment, j, ln2;
+
+ if (ln && pathArray[0][0] == "M") {
+ x = +pathArray[0][1];
+ y = +pathArray[0][2];
+ mx = x;
+ my = y;
+ i++;
+ res[0] = ["M", x, y];
+ }
+ for (; i < ln; i++) {
+ r = res[i] = [];
+ pathSegment = pathArray[i];
+ if (pathSegment[0] != pathSegment[0].toUpperCase()) {
+ r[0] = pathSegment[0].toUpperCase();
+ switch (r[0]) {
+
+ case "A":
+ r[1] = pathSegment[1];
+ r[2] = pathSegment[2];
+ r[3] = pathSegment[3];
+ r[4] = pathSegment[4];
+ r[5] = pathSegment[5];
+ r[6] = +(pathSegment[6] + x);
+ r[7] = +(pathSegment[7] + y);
+ break;
+
+ case "V":
+ r[1] = +pathSegment[1] + y;
+ break;
+
+ case "H":
+ r[1] = +pathSegment[1] + x;
+ break;
+ case "M":
+
+ mx = +pathSegment[1] + x;
+ my = +pathSegment[2] + y;
+ default:
+ j = 1;
+ ln2 = pathSegment.length;
+ for (; j < ln2; j++) {
+ r[j] = +pathSegment[j] + ((j % 2) ? x : y);
+ }
+ }
+ }
+ else {
+ j = 0;
+ ln2 = pathSegment.length;
+ for (; j < ln2; j++) {
+ res[i][j] = pathSegment[j];
+ }
+ }
+ switch (r[0]) {
+
+ case "Z":
+ x = mx;
+ y = my;
+ break;
+
+ case "H":
+ x = r[1];
+ break;
+
+ case "V":
+ y = r[1];
+ break;
+
+ case "M":
+ pathSegment = res[i];
+ ln2 = pathSegment.length;
+ mx = pathSegment[ln2 - 2];
+ my = pathSegment[ln2 - 1];
+ default:
+ pathSegment = res[i];
+ ln2 = pathSegment.length;
+ x = pathSegment[ln2 - 2];
+ y = pathSegment[ln2 - 1];
+ }
+ }
+ res.toString = this.path2string;
+ return res;
+ },
+
+
+ pathToRelative: function (pathArray) {
+ if (!this.is(pathArray, "array") || !this.is(pathArray && pathArray[0], "array")) {
+ pathArray = this.parsePathString(pathArray);
+ }
+ var res = [],
+ x = 0,
+ y = 0,
+ mx = 0,
+ my = 0,
+ start = 0,
+ r,
+ pa,
+ i,
+ j,
+ k,
+ len,
+ ii,
+ jj,
+ kk;
+
+ if (pathArray[0][0] == "M") {
+ x = pathArray[0][1];
+ y = pathArray[0][2];
+ mx = x;
+ my = y;
+ start++;
+ res.push(["M", x, y]);
+ }
+ for (i = start, ii = pathArray.length; i < ii; i++) {
+ r = res[i] = [];
+ pa = pathArray[i];
+ if (pa[0] != pa[0].toLowerCase()) {
+ r[0] = pa[0].toLowerCase();
+ switch (r[0]) {
+ case "a":
+ r[1] = pa[1];
+ r[2] = pa[2];
+ r[3] = pa[3];
+ r[4] = pa[4];
+ r[5] = pa[5];
+ r[6] = +(pa[6] - x).toFixed(3);
+ r[7] = +(pa[7] - y).toFixed(3);
+ break;
+ case "v":
+ r[1] = +(pa[1] - y).toFixed(3);
+ break;
+ case "m":
+ mx = pa[1];
+ my = pa[2];
+ default:
+ for (j = 1, jj = pa.length; j < jj; j++) {
+ r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
+ }
+ }
+ } else {
+ r = res[i] = [];
+ if (pa[0] == "m") {
+ mx = pa[1] + x;
+ my = pa[2] + y;
+ }
+ for (k = 0, kk = pa.length; k < kk; k++) {
+ res[i][k] = pa[k];
+ }
+ }
+ len = res[i].length;
+ switch (res[i][0]) {
+ case "z":
+ x = mx;
+ y = my;
+ break;
+ case "h":
+ x += +res[i][len - 1];
+ break;
+ case "v":
+ y += +res[i][len - 1];
+ break;
+ default:
+ x += +res[i][len - 2];
+ y += +res[i][len - 1];
+ }
+ }
+ res.toString = this.path2string;
+ return res;
+ },
+
+
+ path2curve: function (path) {
+ var me = this,
+ points = me.pathToAbsolute(path),
+ ln = points.length,
+ attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+ i, seg, segLn, point;
+
+ for (i = 0; i < ln; i++) {
+ points[i] = me.command2curve(points[i], attrs);
+ if (points[i].length > 7) {
+ points[i].shift();
+ point = points[i];
+ while (point.length) {
+ Ext.Array.splice(points, i++, 0, ["C"].concat(Ext.Array.splice(point, 0, 6)));
+ }
+ Ext.Array.erase(points, i, 1);
+ ln = points.length;
+ i--;
+ }
+ seg = points[i];
+ segLn = seg.length;
+ attrs.x = seg[segLn - 2];
+ attrs.y = seg[segLn - 1];
+ attrs.bx = parseFloat(seg[segLn - 4]) || attrs.x;
+ attrs.by = parseFloat(seg[segLn - 3]) || attrs.y;
+ }
+ return points;
+ },
+
+ interpolatePaths: function (path, path2) {
+ var me = this,
+ p = me.pathToAbsolute(path),
+ p2 = me.pathToAbsolute(path2),
+ attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+ attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
+ fixArc = function (pp, i) {
+ if (pp[i].length > 7) {
+ pp[i].shift();
+ var pi = pp[i];
+ while (pi.length) {
+ Ext.Array.splice(pp, i++, 0, ["C"].concat(Ext.Array.splice(pi, 0, 6)));
+ }
+ Ext.Array.erase(pp, i, 1);
+ ii = Math.max(p.length, p2.length || 0);
+ }
+ },
+ fixM = function (path1, path2, a1, a2, i) {
+ if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
+ Ext.Array.splice(path2, i, 0, ["M", a2.x, a2.y]);
+ a1.bx = 0;
+ a1.by = 0;
+ a1.x = path1[i][1];
+ a1.y = path1[i][2];
+ ii = Math.max(p.length, p2.length || 0);
+ }
+ },
+ i, ii,
+ seg, seg2, seglen, seg2len;
+ for (i = 0, ii = Math.max(p.length, p2.length || 0); i < ii; i++) {
+ p[i] = me.command2curve(p[i], attrs);
+ fixArc(p, i);
+ (p2[i] = me.command2curve(p2[i], attrs2));
+ fixArc(p2, i);
+ fixM(p, p2, attrs, attrs2, i);
+ fixM(p2, p, attrs2, attrs, i);
+ seg = p[i];
+ seg2 = p2[i];
+ seglen = seg.length;
+ seg2len = seg2.length;
+ attrs.x = seg[seglen - 2];
+ attrs.y = seg[seglen - 1];
+ attrs.bx = parseFloat(seg[seglen - 4]) || attrs.x;
+ attrs.by = parseFloat(seg[seglen - 3]) || attrs.y;
+ attrs2.bx = (parseFloat(seg2[seg2len - 4]) || attrs2.x);
+ attrs2.by = (parseFloat(seg2[seg2len - 3]) || attrs2.y);
+ attrs2.x = seg2[seg2len - 2];
+ attrs2.y = seg2[seg2len - 1];
+ }
+ return [p, p2];
+ },
+
+
+ command2curve: function (pathCommand, d) {
+ var me = this;
+ if (!pathCommand) {
+ return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
+ }
+ if (pathCommand[0] != "T" && pathCommand[0] != "Q") {
+ d.qx = d.qy = null;
+ }
+ switch (pathCommand[0]) {
+ case "M":
+ d.X = pathCommand[1];
+ d.Y = pathCommand[2];
+ break;
+ case "A":
+ pathCommand = ["C"].concat(me.arc2curve.apply(me, [d.x, d.y].concat(pathCommand.slice(1))));
+ break;
+ case "S":
+ pathCommand = ["C", d.x + (d.x - (d.bx || d.x)), d.y + (d.y - (d.by || d.y))].concat(pathCommand.slice(1));
+ break;
+ case "T":
+ d.qx = d.x + (d.x - (d.qx || d.x));
+ d.qy = d.y + (d.y - (d.qy || d.y));
+ pathCommand = ["C"].concat(me.quadratic2curve(d.x, d.y, d.qx, d.qy, pathCommand[1], pathCommand[2]));
+ break;
+ case "Q":
+ d.qx = pathCommand[1];
+ d.qy = pathCommand[2];
+ pathCommand = ["C"].concat(me.quadratic2curve(d.x, d.y, pathCommand[1], pathCommand[2], pathCommand[3], pathCommand[4]));
+ break;
+ case "L":
+ pathCommand = ["C"].concat(d.x, d.y, pathCommand[1], pathCommand[2], pathCommand[1], pathCommand[2]);
+ break;
+ case "H":
+ pathCommand = ["C"].concat(d.x, d.y, pathCommand[1], d.y, pathCommand[1], d.y);
+ break;
+ case "V":
+ pathCommand = ["C"].concat(d.x, d.y, d.x, pathCommand[1], d.x, pathCommand[1]);
+ break;
+ case "Z":
+ pathCommand = ["C"].concat(d.x, d.y, d.X, d.Y, d.X, d.Y);
+ break;
+ }
+ return pathCommand;
+ },
+
+ quadratic2curve: function (x1, y1, ax, ay, x2, y2) {
+ var _13 = 1 / 3,
+ _23 = 2 / 3;
+ return [
+ _13 * x1 + _23 * ax,
+ _13 * y1 + _23 * ay,
+ _13 * x2 + _23 * ax,
+ _13 * y2 + _23 * ay,
+ x2,
+ y2
+ ];
+ },
+
+ rotate: function (x, y, rad) {
+ var cos = Math.cos(rad),
+ sin = Math.sin(rad),
+ X = x * cos - y * sin,
+ Y = x * sin + y * cos;
+ return {x: X, y: Y};
+ },
+
+ arc2curve: function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
+
+
+ var me = this,
+ PI = Math.PI,
+ radian = me.radian,
+ _120 = PI * 120 / 180,
+ rad = radian * (+angle || 0),
+ res = [],
+ math = Math,
+ mcos = math.cos,
+ msin = math.sin,
+ msqrt = math.sqrt,
+ mabs = math.abs,
+ masin = math.asin,
+ xy, cos, sin, x, y, h, rx2, ry2, k, cx, cy, f1, f2, df, c1, s1, c2, s2,
+ t, hx, hy, m1, m2, m3, m4, newres, i, ln, f2old, x2old, y2old;
+ if (!recursive) {
+ xy = me.rotate(x1, y1, -rad);
+ x1 = xy.x;
+ y1 = xy.y;
+ xy = me.rotate(x2, y2, -rad);
+ x2 = xy.x;
+ y2 = xy.y;
+ cos = mcos(radian * angle);
+ sin = msin(radian * angle);
+ x = (x1 - x2) / 2;
+ y = (y1 - y2) / 2;
+ h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
+ if (h > 1) {
+ h = msqrt(h);
+ rx = h * rx;
+ ry = h * ry;
+ }
+ rx2 = rx * rx;
+ ry2 = ry * ry;
+ k = (large_arc_flag == sweep_flag ? -1 : 1) *
+ msqrt(mabs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)));
+ cx = k * rx * y / ry + (x1 + x2) / 2;
+ cy = k * -ry * x / rx + (y1 + y2) / 2;
+ f1 = masin(((y1 - cy) / ry).toFixed(7));
+ f2 = masin(((y2 - cy) / ry).toFixed(7));
+
+ f1 = x1 < cx ? PI - f1 : f1;
+ f2 = x2 < cx ? PI - f2 : f2;
+ if (f1 < 0) {
+ f1 = PI * 2 + f1;
+ }
+ if (f2 < 0) {
+ f2 = PI * 2 + f2;
+ }
+ if (sweep_flag && f1 > f2) {
+ f1 = f1 - PI * 2;
+ }
+ if (!sweep_flag && f2 > f1) {
+ f2 = f2 - PI * 2;
+ }
+ }
+ else {
+ f1 = recursive[0];
+ f2 = recursive[1];
+ cx = recursive[2];
+ cy = recursive[3];
+ }
+ df = f2 - f1;
+ if (mabs(df) > _120) {
+ f2old = f2;
+ x2old = x2;
+ y2old = y2;
+ f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
+ x2 = cx + rx * mcos(f2);
+ y2 = cy + ry * msin(f2);
+ res = me.arc2curve(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
+ }
+ df = f2 - f1;
+ c1 = mcos(f1);
+ s1 = msin(f1);
+ c2 = mcos(f2);
+ s2 = msin(f2);
+ t = math.tan(df / 4);
+ hx = 4 / 3 * rx * t;
+ hy = 4 / 3 * ry * t;
+ m1 = [x1, y1];
+ m2 = [x1 + hx * s1, y1 - hy * c1];
+ m3 = [x2 + hx * s2, y2 - hy * c2];
+ m4 = [x2, y2];
+ m2[0] = 2 * m1[0] - m2[0];
+ m2[1] = 2 * m1[1] - m2[1];
+ if (recursive) {
+ return [m2, m3, m4].concat(res);
+ }
+ else {
+ res = [m2, m3, m4].concat(res).join().split(",");
+ newres = [];
+ ln = res.length;
+ for (i = 0; i < ln; i++) {
+ newres[i] = i % 2 ? me.rotate(res[i - 1], res[i], rad).y : me.rotate(res[i], res[i + 1], rad).x;
+ }
+ return newres;
+ }
+ },
+
+
+ rotateAndTranslatePath: function (sprite) {
+ var alpha = sprite.rotation.degrees,
+ cx = sprite.rotation.x,
+ cy = sprite.rotation.y,
+ dx = sprite.translation.x,
+ dy = sprite.translation.y,
+ path,
+ i,
+ p,
+ xy,
+ j,
+ res = [];
+ if (!alpha && !dx && !dy) {
+ return this.pathToAbsolute(sprite.attr.path);
+ }
+ dx = dx || 0;
+ dy = dy || 0;
+ path = this.pathToAbsolute(sprite.attr.path);
+ for (i = path.length; i--;) {
+ p = res[i] = path[i].slice();
+ if (p[0] == "A") {
+ xy = this.rotatePoint(p[6], p[7], alpha, cx, cy);
+ p[6] = xy.x + dx;
+ p[7] = xy.y + dy;
+ } else {
+ j = 1;
+ while (p[j + 1] != null) {
+ xy = this.rotatePoint(p[j], p[j + 1], alpha, cx, cy);
+ p[j] = xy.x + dx;
+ p[j + 1] = xy.y + dy;
+ j += 2;
+ }
+ }
+ }
+ return res;
+ },
+
+
+ rotatePoint: function (x, y, alpha, cx, cy) {
+ if (!alpha) {
+ return {
+ x: x,
+ y: y
+ };
+ }
+ cx = cx || 0;
+ cy = cy || 0;
+ x = x - cx;
+ y = y - cy;
+ alpha = alpha * this.radian;
+ var cos = Math.cos(alpha),
+ sin = Math.sin(alpha);
+ return {
+ x: x * cos - y * sin + cx,
+ y: x * sin + y * cos + cy
+ };
+ },
+
+ pathDimensions: function (path) {
+ if (!path || !(path + "")) {
+ return {x: 0, y: 0, width: 0, height: 0};
+ }
+ path = this.path2curve(path);
+ var x = 0,
+ y = 0,
+ X = [],
+ Y = [],
+ i = 0,
+ ln = path.length,
+ p, xmin, ymin, dim;
+ for (; i < ln; i++) {
+ p = path[i];
+ if (p[0] == "M") {
+ x = p[1];
+ y = p[2];
+ X.push(x);
+ Y.push(y);
+ }
+ else {
+ dim = this.curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
+ X = X.concat(dim.min.x, dim.max.x);
+ Y = Y.concat(dim.min.y, dim.max.y);
+ x = p[5];
+ y = p[6];
+ }
+ }
+ xmin = Math.min.apply(0, X);
+ ymin = Math.min.apply(0, Y);
+ return {
+ x: xmin,
+ y: ymin,
+ path: path,
+ width: Math.max.apply(0, X) - xmin,
+ height: Math.max.apply(0, Y) - ymin
+ };
+ },
+
+ intersectInside: function(path, cp1, cp2) {
+ return (cp2[0] - cp1[0]) * (path[1] - cp1[1]) > (cp2[1] - cp1[1]) * (path[0] - cp1[0]);
+ },
+
+ intersectIntersection: function(s, e, cp1, cp2) {
+ var p = [],
+ dcx = cp1[0] - cp2[0],
+ dcy = cp1[1] - cp2[1],
+ dpx = s[0] - e[0],
+ dpy = s[1] - e[1],
+ n1 = cp1[0] * cp2[1] - cp1[1] * cp2[0],
+ n2 = s[0] * e[1] - s[1] * e[0],
+ n3 = 1 / (dcx * dpy - dcy * dpx);
+
+ p[0] = (n1 * dpx - n2 * dcx) * n3;
+ p[1] = (n1 * dpy - n2 * dcy) * n3;
+ return p;
+ },
+
+ intersect: function(subjectPolygon, clipPolygon) {
+ var me = this,
+ i = 0,
+ ln = clipPolygon.length,
+ cp1 = clipPolygon[ln - 1],
+ outputList = subjectPolygon,
+ cp2, s, e, point, ln2, inputList, j;
+ for (; i < ln; ++i) {
+ cp2 = clipPolygon[i];
+ inputList = outputList;
+ outputList = [];
+ s = inputList[inputList.length - 1];
+ j = 0;
+ ln2 = inputList.length;
+ for (; j < ln2; j++) {
+ e = inputList[j];
+ if (me.intersectInside(e, cp1, cp2)) {
+ if (!me.intersectInside(s, cp1, cp2)) {
+ outputList.push(me.intersectIntersection(s, e, cp1, cp2));
+ }
+ outputList.push(e);
+ }
+ else if (me.intersectInside(s, cp1, cp2)) {
+ outputList.push(me.intersectIntersection(s, e, cp1, cp2));
+ }
+ s = e;
+ }
+ cp1 = cp2;
+ }
+ return outputList;
+ },
+
+ bezier : function (a, b, c, d, x) {
+ if (x === 0) {
+ return a;
+ }
+ else if (x === 1) {
+ return d;
+ }
+ var du = 1 - x,
+ d3 = du * du * du,
+ r = x / du;
+ return d3 * (a + r * (3 * b + r * (3 * c + d * r)));
+ },
+
+ bezierDim : function (a, b, c, d) {
+ var points = [], r,
+ A, top, C, delta, bottom, s,
+ min, max, i;
+
+ if (a + 3 * c == d + 3 * b) {
+ r = a - b;
+ r /= 2 * (a - b - b + c);
+ if ( r < 1 && r > 0) {
+ points.push(r);
+ }
+ } else {
+
+
+ A = a - 3 * b + 3 * c - d;
+ top = 2 * (a - b - b + c);
+ C = a - b;
+ delta = top * top - 4 * A * C;
+ bottom = A + A;
+ if (delta === 0) {
+ r = top / bottom;
+ if (r < 1 && r > 0) {
+ points.push(r);
+ }
+ } else if (delta > 0) {
+ s = Math.sqrt(delta);
+ r = (s + top) / bottom;
+
+ if (r < 1 && r > 0) {
+ points.push(r);
+ }
+
+ r = (top - s) / bottom;
+
+ if (r < 1 && r > 0) {
+ points.push(r);
+ }
+ }
+ }
+ min = Math.min(a, d);
+ max = Math.max(a, d);
+ for (i = 0; i < points.length; i++) {
+ min = Math.min(min, this.bezier(a, b, c, d, points[i]));
+ max = Math.max(max, this.bezier(a, b, c, d, points[i]));
+ }
+ return [min, max];
+ },
+
+ curveDim: function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
+ var x = this.bezierDim(p1x, c1x, c2x, p2x),
+ y = this.bezierDim(p1y, c1y, c2y, p2y);
+ return {
+ min: {
+ x: x[0],
+ y: y[0]
+ },
+ max: {
+ x: x[1],
+ y: y[1]
+ }
+ };
+ },
+
+
+ getAnchors: function (prevX, prevY, curX, curY, nextX, nextY, value) {
+ value = value || 4;
+ var M = Math,
+ PI = M.PI,
+ halfPI = PI / 2,
+ abs = M.abs,
+ sin = M.sin,
+ cos = M.cos,
+ atan = M.atan,
+ control1Length, control2Length, control1Angle, control2Angle,
+ control1X, control1Y, control2X, control2Y, alpha;
+
+
+
+ control1Length = (curX - prevX) / value;
+ control2Length = (nextX - curX) / value;
+
+
+
+
+
+ if ((curY >= prevY && curY >= nextY) || (curY <= prevY && curY <= nextY)) {
+ control1Angle = control2Angle = halfPI;
+ } else {
+ control1Angle = atan((curX - prevX) / abs(curY - prevY));
+ if (prevY < curY) {
+ control1Angle = PI - control1Angle;
+ }
+ control2Angle = atan((nextX - curX) / abs(curY - nextY));
+ if (nextY < curY) {
+ control2Angle = PI - control2Angle;
+ }
+ }
+
+
+ alpha = halfPI - ((control1Angle + control2Angle) % (PI * 2)) / 2;
+ if (alpha > halfPI) {
+ alpha -= PI;
+ }
+ control1Angle += alpha;
+ control2Angle += alpha;
+
+
+ control1X = curX - control1Length * sin(control1Angle);
+ control1Y = curY + control1Length * cos(control1Angle);
+ control2X = curX + control2Length * sin(control2Angle);
+ control2Y = curY + control2Length * cos(control2Angle);
+
+
+
+
+
+ if ((curY > prevY && control1Y < prevY) || (curY < prevY && control1Y > prevY)) {
+ control1X += abs(prevY - control1Y) * (control1X - curX) / (control1Y - curY);
+ control1Y = prevY;
+ }
+ if ((curY > nextY && control2Y < nextY) || (curY < nextY && control2Y > nextY)) {
+ control2X -= abs(nextY - control2Y) * (control2X - curX) / (control2Y - curY);
+ control2Y = nextY;
+ }
+
+ return {
+ x1: control1X,
+ y1: control1Y,
+ x2: control2X,
+ y2: control2Y
+ };
+ },
+
+
+ smooth: function (originalPath, value) {
+ var path = this.path2curve(originalPath),
+ newp = [path[0]],
+ x = path[0][1],
+ y = path[0][2],
+ j,
+ points,
+ i = 1,
+ ii = path.length,
+ beg = 1,
+ mx = x,
+ my = y,
+ cx = 0,
+ cy = 0,
+ pathi,
+ pathil,
+ pathim,
+ pathiml,
+ pathip,
+ pathipl,
+ begl;
+
+ for (; i < ii; i++) {
+ pathi = path[i];
+ pathil = pathi.length;
+ pathim = path[i - 1];
+ pathiml = pathim.length;
+ pathip = path[i + 1];
+ pathipl = pathip && pathip.length;
+ if (pathi[0] == "M") {
+ mx = pathi[1];
+ my = pathi[2];
+ j = i + 1;
+ while (path[j][0] != "C") {
+ j++;
+ }
+ cx = path[j][5];
+ cy = path[j][6];
+ newp.push(["M", mx, my]);
+ beg = newp.length;
+ x = mx;
+ y = my;
+ continue;
+ }
+ if (pathi[pathil - 2] == mx && pathi[pathil - 1] == my && (!pathip || pathip[0] == "M")) {
+ begl = newp[beg].length;
+ points = this.getAnchors(pathim[pathiml - 2], pathim[pathiml - 1], mx, my, newp[beg][begl - 2], newp[beg][begl - 1], value);
+ newp[beg][1] = points.x2;
+ newp[beg][2] = points.y2;
+ }
+ else if (!pathip || pathip[0] == "M") {
+ points = {
+ x1: pathi[pathil - 2],
+ y1: pathi[pathil - 1]
+ };
+ } else {
+ points = this.getAnchors(pathim[pathiml - 2], pathim[pathiml - 1], pathi[pathil - 2], pathi[pathil - 1], pathip[pathipl - 2], pathip[pathipl - 1], value);
+ }
+ newp.push(["C", x, y, points.x1, points.y1, pathi[pathil - 2], pathi[pathil - 1]]);
+ x = points.x2;
+ y = points.y2;
+ }
+ return newp;
+ },
+
+ findDotAtSegment: function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
+ var t1 = 1 - t;
+ return {
+ x: Math.pow(t1, 3) * p1x + Math.pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + Math.pow(t, 3) * p2x,
+ y: Math.pow(t1, 3) * p1y + Math.pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + Math.pow(t, 3) * p2y
+ };
+ },
+
+
+ snapEnds: function (from, to, stepsMax, prettyNumbers) {
+ if (Ext.isDate(from)) {
+ return this.snapEndsByDate(from, to, stepsMax);
+ }
+ var step = (to - from) / stepsMax,
+ level = Math.floor(Math.log(step) / Math.LN10) + 1,
+ m = Math.pow(10, level),
+ cur,
+ modulo = Math.round((step % m) * Math.pow(10, 2 - level)),
+ interval = [[0, 15], [20, 4], [30, 2], [40, 4], [50, 9], [60, 4], [70, 2], [80, 4], [100, 15]],
+ stepCount = 0,
+ value,
+ weight,
+ i,
+ topValue,
+ topWeight = 1e9,
+ ln = interval.length;
+ cur = from = Math.floor(from / m) * m;
+
+ if(prettyNumbers){
+ for (i = 0; i < ln; i++) {
+ value = interval[i][0];
+ weight = (value - modulo) < 0 ? 1e6 : (value - modulo) / interval[i][1];
+ if (weight < topWeight) {
+ topValue = value;
+ topWeight = weight;
+ }
+ }
+ step = Math.floor(step * Math.pow(10, -level)) * Math.pow(10, level) + topValue * Math.pow(10, level - 2);
+ while (cur < to) {
+ cur += step;
+ stepCount++;
+ }
+ to = +cur.toFixed(10);
+ }else{
+ stepCount = stepsMax;
+ }
+
+ return {
+ from: from,
+ to: to,
+ power: level,
+ step: step,
+ steps: stepCount
+ };
+ },
+
+
+ snapEndsByDate: function (from, to, stepsMax, lockEnds) {
+ var selectedStep = false,
+ scales = [
+ [Ext.Date.MILLI, [1, 2, 3, 5, 10, 20, 30, 50, 100, 200, 300, 500]],
+ [Ext.Date.SECOND, [1, 2, 3, 5, 10, 15, 30]],
+ [Ext.Date.MINUTE, [1, 2, 3, 5, 10, 20, 30]],
+ [Ext.Date.HOUR, [1, 2, 3, 4, 6, 12]],
+ [Ext.Date.DAY, [1, 2, 3, 7, 14]],
+ [Ext.Date.MONTH, [1, 2, 3, 4, 6]]
+ ],
+ sLen = scales.length,
+ stop = false,
+ scale, j, yearDiff, s;
+
+
+ for (s = 0; s < sLen; s++) {
+ scale = scales[s];
+ if (!stop) {
+ for (j = 0; j < scale[1].length; j++) {
+ if (to < Ext.Date.add(from, scale[0], scale[1][j] * stepsMax)) {
+ selectedStep = [scale[0], scale[1][j]];
+ stop = true;
+ break;
+ }
+ }
+ }
+ }
+
+ if (!selectedStep) {
+ yearDiff = this.snapEnds(from.getFullYear(), to.getFullYear() + 1, stepsMax, lockEnds);
+ selectedStep = [Date.YEAR, Math.round(yearDiff.step)];
+ }
+ return this.snapEndsByDateAndStep(from, to, selectedStep, lockEnds);
+ },
+
+
+
+ snapEndsByDateAndStep: function(from, to, step, lockEnds) {
+ var fromStat = [from.getFullYear(), from.getMonth(), from.getDate(),
+ from.getHours(), from.getMinutes(), from.getSeconds(), from.getMilliseconds()],
+ steps = 0, testFrom, testTo;
+ if (lockEnds) {
+ testFrom = from;
+ } else {
+ switch (step[0]) {
+ case Ext.Date.MILLI:
+ testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+ fromStat[4], fromStat[5], Math.floor(fromStat[6] / step[1]) * step[1]);
+ break;
+ case Ext.Date.SECOND:
+ testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+ fromStat[4], Math.floor(fromStat[5] / step[1]) * step[1], 0);
+ break;
+ case Ext.Date.MINUTE:
+ testFrom = new Date(fromStat[0], fromStat[1], fromStat[2], fromStat[3],
+ Math.floor(fromStat[4] / step[1]) * step[1], 0, 0);
+ break;
+ case Ext.Date.HOUR:
+ testFrom = new Date(fromStat[0], fromStat[1], fromStat[2],
+ Math.floor(fromStat[3] / step[1]) * step[1], 0, 0, 0);
+ break;
+ case Ext.Date.DAY:
+ testFrom = new Date(fromStat[0], fromStat[1],
+ Math.floor(fromStat[2] - 1 / step[1]) * step[1] + 1, 0, 0, 0, 0);
+ break;
+ case Ext.Date.MONTH:
+ testFrom = new Date(fromStat[0], Math.floor(fromStat[1] / step[1]) * step[1], 1, 0, 0, 0, 0);
+ break;
+ default:
+ testFrom = new Date(Math.floor(fromStat[0] / step[1]) * step[1], 0, 1, 0, 0, 0, 0);
+ break;
+ }
+ }
+
+ testTo = testFrom;
+
+ while (testTo < to) {
+ testTo = Ext.Date.add(testTo, step[0], step[1]);
+ steps++;
+ }
+
+ if (lockEnds) {
+ testTo = to;
+ }
+ return {
+ from : +testFrom,
+ to : +testTo,
+ step : (testTo - testFrom) / steps,
+ steps : steps
+ };
+ },
+
+ sorter: function (a, b) {
+ return a.offset - b.offset;
+ },
+
+ rad: function(degrees) {
+ return degrees % 360 * Math.PI / 180;
+ },
+
+ degrees: function(radian) {
+ return radian * 180 / Math.PI % 360;
+ },
+
+ withinBox: function(x, y, bbox) {
+ bbox = bbox || {};
+ return (x >= bbox.x && x <= (bbox.x + bbox.width) && y >= bbox.y && y <= (bbox.y + bbox.height));
+ },
+
+ parseGradient: function(gradient) {
+ var me = this,
+ type = gradient.type || 'linear',
+ angle = gradient.angle || 0,
+ radian = me.radian,
+ stops = gradient.stops,
+ stopsArr = [],
+ stop,
+ vector,
+ max,
+ stopObj;
+
+ if (type == 'linear') {
+ vector = [0, 0, Math.cos(angle * radian), Math.sin(angle * radian)];
+ max = 1 / (Math.max(Math.abs(vector[2]), Math.abs(vector[3])) || 1);
+ vector[2] *= max;
+ vector[3] *= max;
+ if (vector[2] < 0) {
+ vector[0] = -vector[2];
+ vector[2] = 0;
+ }
+ if (vector[3] < 0) {
+ vector[1] = -vector[3];
+ vector[3] = 0;
+ }
+ }
+
+ for (stop in stops) {
+ if (stops.hasOwnProperty(stop) && me.stopsRE.test(stop)) {
+ stopObj = {
+ offset: parseInt(stop, 10),
+ color: Ext.draw.Color.toHex(stops[stop].color) || '#ffffff',
+ opacity: stops[stop].opacity || 1
+ };
+ stopsArr.push(stopObj);
+ }
+ }
+
+ Ext.Array.sort(stopsArr, me.sorter);
+ if (type == 'linear') {
+ return {
+ id: gradient.id,
+ type: type,
+ vector: vector,
+ stops: stopsArr
+ };
+ }
+ else {
+ return {
+ id: gradient.id,
+ type: type,
+ centerX: gradient.centerX,
+ centerY: gradient.centerY,
+ focalX: gradient.focalX,
+ focalY: gradient.focalY,
+ radius: gradient.radius,
+ vector: vector,
+ stops: stopsArr
+ };
+ }
+ }
+});
+
+
+Ext.define('Ext.fx.PropertyHandler', {
+
+
+
+ requires: ['Ext.draw.Draw'],
+
+ statics: {
+ defaultHandler: {
+ pixelDefaultsRE: /width|height|top$|bottom$|left$|right$/i,
+ unitRE: /^(-?\d*\.?\d*){1}(em|ex|px|in|cm|mm|pt|pc|%)*$/,
+ scrollRE: /^scroll/i,
+
+ computeDelta: function(from, end, damper, initial, attr) {
+ damper = (typeof damper == 'number') ? damper : 1;
+ var unitRE = this.unitRE,
+ match = unitRE.exec(from),
+ start, units;
+ if (match) {
+ from = match[1];
+ units = match[2];
+ if (!this.scrollRE.test(attr) && !units && this.pixelDefaultsRE.test(attr)) {
+ units = 'px';
+ }
+ }
+ from = +from || 0;
+
+ match = unitRE.exec(end);
+ if (match) {
+ end = match[1];
+ units = match[2] || units;
+ }
+ end = +end || 0;
+ start = (initial != null) ? initial : from;
+ return {
+ from: from,
+ delta: (end - start) * damper,
+ units: units
+ };
+ },
+
+ get: function(from, end, damper, initialFrom, attr) {
+ var ln = from.length,
+ out = [],
+ i, initial, res, j, len;
+ for (i = 0; i < ln; i++) {
+ if (initialFrom) {
+ initial = initialFrom[i][1].from;
+ }
+ if (Ext.isArray(from[i][1]) && Ext.isArray(end)) {
+ res = [];
+ j = 0;
+ len = from[i][1].length;
+ for (; j < len; j++) {
+ res.push(this.computeDelta(from[i][1][j], end[j], damper, initial, attr));
+ }
+ out.push([from[i][0], res]);
+ }
+ else {
+ out.push([from[i][0], this.computeDelta(from[i][1], end, damper, initial, attr)]);
+ }
+ }
+ return out;
+ },
+
+ set: function(values, easing) {
+ var ln = values.length,
+ out = [],
+ i, val, res, len, j;
+ for (i = 0; i < ln; i++) {
+ val = values[i][1];
+ if (Ext.isArray(val)) {
+ res = [];
+ j = 0;
+ len = val.length;
+ for (; j < len; j++) {
+ res.push(val[j].from + val[j].delta * easing + (val[j].units || 0));
+ }
+ out.push([values[i][0], res]);
+ } else {
+ out.push([values[i][0], val.from + val.delta * easing + (val.units || 0)]);
+ }
+ }
+ return out;
+ }
+ },
+ stringHandler: {
+ computeDelta: function(from, end, damper, initial, attr) {
+ return {
+ from: from,
+ delta: end
+ };
+ },
+
+ get: function(from, end, damper, initialFrom, attr) {
+ var ln = from.length,
+ out = [],
+ i, initial, res, j, len;
+ for (i = 0; i < ln; i++) {
+ out.push([from[i][0], this.computeDelta(from[i][1], end, damper, initial, attr)]);
+ }
+ return out;
+ },
+
+ set: function(values, easing) {
+ var ln = values.length,
+ out = [],
+ i, val, res, len, j;
+ for (i = 0; i < ln; i++) {
+ val = values[i][1];
+ out.push([values[i][0], val.delta]);
+ }
+ return out;
+ }
+ },
+ color: {
+ rgbRE: /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i,
+ hexRE: /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i,
+ hex3RE: /^#?([0-9A-F]{1})([0-9A-F]{1})([0-9A-F]{1})$/i,
+
+ parseColor : function(color, damper) {
+ damper = (typeof damper == 'number') ? damper : 1;
+ var out = false,
+ reList = [this.hexRE, this.rgbRE, this.hex3RE],
+ length = reList.length,
+ match, base, re, i;
+
+ for (i = 0; i < length; i++) {
+ re = reList[i];
+
+ base = (i % 2 === 0) ? 16 : 10;
+ match = re.exec(color);
+ if (match && match.length === 4) {
+ if (i === 2) {
+ match[1] += match[1];
+ match[2] += match[2];
+ match[3] += match[3];
+ }
+ out = {
+ red: parseInt(match[1], base),
+ green: parseInt(match[2], base),
+ blue: parseInt(match[3], base)
+ };
+ break;
+ }
+ }
+
+ return out || color;
+ },
+
+ computeDelta: function(from, end, damper, initial) {
+ from = this.parseColor(from);
+ end = this.parseColor(end, damper);
+ var start = initial ? initial : from,
+ tfrom = typeof start,
+ tend = typeof end;
+
+ if (tfrom == 'string' || tfrom == 'undefined'
+ || tend == 'string' || tend == 'undefined') {
+ return end || start;
+ }
+ return {
+ from: from,
+ delta: {
+ red: Math.round((end.red - start.red) * damper),
+ green: Math.round((end.green - start.green) * damper),
+ blue: Math.round((end.blue - start.blue) * damper)
+ }
+ };
+ },
+
+ get: function(start, end, damper, initialFrom) {
+ var ln = start.length,
+ out = [],
+ i, initial;
+ for (i = 0; i < ln; i++) {
+ if (initialFrom) {
+ initial = initialFrom[i][1].from;
+ }
+ out.push([start[i][0], this.computeDelta(start[i][1], end, damper, initial)]);
+ }
+ return out;
+ },
+
+ set: function(values, easing) {
+ var ln = values.length,
+ out = [],
+ i, val, parsedString, from, delta;
+ for (i = 0; i < ln; i++) {
+ val = values[i][1];
+ if (val) {
+ from = val.from;
+ delta = val.delta;
+
+ val = (typeof val == 'object' && 'red' in val)?
+ 'rgb(' + val.red + ', ' + val.green + ', ' + val.blue + ')' : val;
+ val = (typeof val == 'object' && val.length)? val[0] : val;
+ if (typeof val == 'undefined') {
+ return [];
+ }
+ parsedString = typeof val == 'string'? val :
+ 'rgb(' + [
+ (from.red + Math.round(delta.red * easing)) % 256,
+ (from.green + Math.round(delta.green * easing)) % 256,
+ (from.blue + Math.round(delta.blue * easing)) % 256
+ ].join(',') + ')';
+ out.push([
+ values[i][0],
+ parsedString
+ ]);
+ }
+ }
+ return out;
+ }
+ },
+ object: {
+ interpolate: function(prop, damper) {
+ damper = (typeof damper == 'number') ? damper : 1;
+ var out = {},
+ p;
+ for(p in prop) {
+ out[p] = parseFloat(prop[p]) * damper;
+ }
+ return out;
+ },
+
+ computeDelta: function(from, end, damper, initial) {
+ from = this.interpolate(from);
+ end = this.interpolate(end, damper);
+ var start = initial ? initial : from,
+ delta = {},
+ p;
+
+ for(p in end) {
+ delta[p] = end[p] - start[p];
+ }
+ return {
+ from: from,
+ delta: delta
+ };
+ },
+
+ get: function(start, end, damper, initialFrom) {
+ var ln = start.length,
+ out = [],
+ i, initial;
+ for (i = 0; i < ln; i++) {
+ if (initialFrom) {
+ initial = initialFrom[i][1].from;
+ }
+ out.push([start[i][0], this.computeDelta(start[i][1], end, damper, initial)]);
+ }
+ return out;
+ },
+
+ set: function(values, easing) {
+ var ln = values.length,
+ out = [],
+ outObject = {},
+ i, from, delta, val, p;
+ for (i = 0; i < ln; i++) {
+ val = values[i][1];
+ from = val.from;
+ delta = val.delta;
+ for (p in from) {
+ outObject[p] = from[p] + delta[p] * easing;
+ }
+ out.push([
+ values[i][0],
+ outObject
+ ]);
+ }
+ return out;
+ }
+ },
+
+ path: {
+ computeDelta: function(from, end, damper, initial) {
+ damper = (typeof damper == 'number') ? damper : 1;
+ var start;
+ from = +from || 0;
+ end = +end || 0;
+ start = (initial != null) ? initial : from;
+ return {
+ from: from,
+ delta: (end - start) * damper
+ };
+ },
+
+ forcePath: function(path) {
+ if (!Ext.isArray(path) && !Ext.isArray(path[0])) {
+ path = Ext.draw.Draw.parsePathString(path);
+ }
+ return path;
+ },
+
+ get: function(start, end, damper, initialFrom) {
+ var endPath = this.forcePath(end),
+ out = [],
+ startLn = start.length,
+ startPathLn, pointsLn, i, deltaPath, initial, j, k, path, startPath;
+ for (i = 0; i < startLn; i++) {
+ startPath = this.forcePath(start[i][1]);
+
+ deltaPath = Ext.draw.Draw.interpolatePaths(startPath, endPath);
+ startPath = deltaPath[0];
+ endPath = deltaPath[1];
+
+ startPathLn = startPath.length;
+ path = [];
+ for (j = 0; j < startPathLn; j++) {
+ deltaPath = [startPath[j][0]];
+ pointsLn = startPath[j].length;
+ for (k = 1; k < pointsLn; k++) {
+ initial = initialFrom && initialFrom[0][1][j][k].from;
+ deltaPath.push(this.computeDelta(startPath[j][k], endPath[j][k], damper, initial));
+ }
+ path.push(deltaPath);
+ }
+ out.push([start[i][0], path]);
+ }
+ return out;
+ },
+
+ set: function(values, easing) {
+ var ln = values.length,
+ out = [],
+ i, j, k, newPath, calcPath, deltaPath, deltaPathLn, pointsLn;
+ for (i = 0; i < ln; i++) {
+ deltaPath = values[i][1];
+ newPath = [];
+ deltaPathLn = deltaPath.length;
+ for (j = 0; j < deltaPathLn; j++) {
+ calcPath = [deltaPath[j][0]];
+ pointsLn = deltaPath[j].length;
+ for (k = 1; k < pointsLn; k++) {
+ calcPath.push(deltaPath[j][k].from + deltaPath[j][k].delta * easing);
+ }
+ newPath.push(calcPath.join(','));
+ }
+ out.push([values[i][0], newPath.join(',')]);
+ }
+ return out;
+ }
+ }
+
+ }
+}, function() {
+
+ var props = [
+ 'outlineColor',
+ 'backgroundColor',
+ 'borderColor',
+ 'borderTopColor',
+ 'borderRightColor',
+ 'borderBottomColor',
+ 'borderLeftColor',
+ 'fill',
+ 'stroke'
+ ],
+ length = props.length,
+ i = 0,
+ prop;
+
+ for (; i',
+ '',
+ '
',
+ '{afterLabelTpl}',
+ '- {.}
'); + + + calcHeight = Ext.util.TextMetrics.measure(inputEl, value, curWidth).height + + inputContext.getBorderInfo().height + inputContext.getPaddingInfo().height; + + + calcHeight = Ext.Number.constrain(calcHeight, owner.growMin, owner.growMax); + inputContext.setHeight(calcHeight); + ownerContext.state.growHandled = true; + + + inputContext.domBlock(me, 'height'); + height = NaN; + } + return height; + } +}); + + +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', + 'Ext.util.DelayedTask' + ], + + + + + + + + + fieldSubTpl: [ + '', + { + disableFormats: true + } + ], + + + growMin: 60, + + + growMax: 1000, + + + growAppend: '\n-', + + + cols: 20, + + + rows: 4, + + + enterIsSpecial: false, + + + preventScrollbars: false, + + + componentLayout: 'textareafield', + + setGrowSizePolicy: Ext.emptyFn, + + returnRe: /\r/g, + + + getSubTplData: function() { + var me = this, + fieldStyle = me.getFieldStyle(), + ret = me.callParent(); + + if (me.grow) { + if (me.preventScrollbars) { + ret.fieldStyle = (fieldStyle||'') + ';overflow:hidden;height:' + me.growMin + 'px'; + } + } + + Ext.applyIf(ret, { + cols: me.cols, + rows: me.rows + }); + + return ret; + }, + + afterRender: function () { + var me = this; + + me.callParent(arguments); + + me.needsMaxCheck = me.enforceMaxLength && me.maxLength !== Number.MAX_VALUE && !Ext.supports.TextAreaMaxLength; + if (me.needsMaxCheck) { + me.inputEl.on('paste', me.onPaste, me); + } + }, + + + + + + + + transformRawValue: function(value){ + return this.stripReturns(value); + }, + + transformOriginalValue: function(value){ + return this.stripReturns(value); + }, + + valueToRaw: function(value){ + value = this.stripReturns(value); + return this.callParent([value]); + }, + + stripReturns: function(value){ + if (value) { + value = value.replace(this.returnRe, ''); + } + return value; + }, + + onPaste: function(e){ + var me = this; + if (!me.pasteTask) { + me.pasteTask = new Ext.util.DelayedTask(me.pasteCheck, me); + } + + me.pasteTask.delay(1); + }, + + pasteCheck: function(){ + var me = this, + value = me.getValue(), + max = me.maxLength; + + if (value.length > max) { + value = value.substr(0, max); + me.setValue(value); + } + }, + + + fireKey: function(e) { + var me = this, + key = e.getKey(), + value; + + if (e.isSpecialKey() && (me.enterIsSpecial || (key !== e.ENTER || e.hasModifier()))) { + me.fireEvent('specialkey', me, e); + } + + if (me.needsMaxCheck && key !== e.BACKSPACE && key !== e.DELETE && !e.isNavKeyPress() && !me.isCutCopyPasteSelectAll(e, key)) { + value = me.getValue(); + if (value.length >= me.maxLength) { + e.stopEvent(); + } + } + }, + + isCutCopyPasteSelectAll: function(e, key) { + if (e.CTRL) { + return key === e.A || key === e.C || key === e.V || key === e.X; + } + return false; + }, + + + autoSize: function() { + var me = this, + height; + + if (me.grow && me.rendered) { + me.updateLayout(); + height = me.inputEl.getHeight(); + if (height !== me.lastInputHeight) { + + me.fireEvent('autosize', me, height); + me.lastInputHeight = height; + } + } + }, + + + initAria: function() { + this.callParent(arguments); + this.getActionEl().dom.setAttribute('aria-multiline', true); + }, + + beforeDestroy: function(){ + var task = this.pasteTask; + if (task) { + task.delay(); + } + this.callParent(); + } +}); + + +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: [ + '
style="{fieldStyle}"',
+ ' class="{fieldCls}">{value}
',
+ {
+ compiled: true,
+ disableFormats: true
+ }
+ ],
+
+
+ fieldCls: Ext.baseCSSPrefix + 'form-display-field',
+
+
+ htmlEncode: false,
+
+
+
+
+
+ validateOnChange: false,
+
+ initEvents: Ext.emptyFn,
+
+ submitValue: false,
+
+ isDirty: function(){
+ return false;
+ },
+
+ isValid: function() {
+ return true;
+ },
+
+ validate: function() {
+ return true;
+ },
+
+ getRawValue: function() {
+ return this.rawValue;
+ },
+
+ setRawValue: function(value) {
+ var me = this,
+ display;
+
+ value = Ext.value(value, '');
+ me.rawValue = value;
+ if (me.rendered) {
+ me.inputEl.dom.innerHTML = me.getDisplayValue();
+ me.updateLayout();
+ }
+ return value;
+ },
+
+
+ getDisplayValue: function() {
+ var me = this,
+ value = this.getRawValue(),
+ display;
+ if (me.renderer) {
+ display = me.renderer.call(me.scope || me, value, me);
+ } else {
+ display = me.htmlEncode ? Ext.util.Format.htmlEncode(value) : value;
+ }
+ return display;
+ },
+
+ getSubTplData: function() {
+ var ret = this.callParent(arguments);
+
+ ret.value = this.getDisplayValue();
+
+ return ret;
+ }
+
+
+
+
+
+
+
+});
+
+
+Ext.define('Ext.layout.container.Anchor', {
+
+
+
+ alias: 'layout.anchor',
+ extend: 'Ext.layout.container.Container',
+ alternateClassName: 'Ext.layout.AnchorLayout',
+
+
+
+ type: 'anchor',
+
+ manageOverflow: 2,
+
+ renderTpl: [
+ '{%this.renderBody(out,values);this.renderPadder(out,values)%}'
+ ],
+
+
+
+
+ defaultAnchor: '100%',
+
+ parseAnchorRE: /^(r|right|b|bottom)$/i,
+
+ beginLayout: function (ownerContext) {
+ var me = this,
+ dimensions = 0,
+ anchorSpec, childContext, childItems, i, length, target;
+
+ me.callParent(arguments);
+
+ childItems = ownerContext.childItems;
+ length = childItems.length;
+
+ for (i = 0; i < length; ++i) {
+ childContext = childItems[i];
+ anchorSpec = childContext.target.anchorSpec;
+
+ if (anchorSpec) {
+ if (childContext.widthModel.calculated && anchorSpec.right) {
+ dimensions |= 1;
+ }
+ if (childContext.heightModel.calculated && anchorSpec.bottom) {
+ dimensions |= 2;
+ }
+
+ if (dimensions == 3) {
+ break;
+ }
+ }
+ }
+
+ ownerContext.anchorDimensions = dimensions;
+
+
+
+ if (!Ext.supports.RightMargin && !me.rightMarginCleanerFn) {
+ target = ownerContext.targetContext.el;
+
+ me.rightMarginCleanerFn = Ext.Element.getRightMarginFixCleaner(target);
+ target.addCls(Ext.baseCSSPrefix + 'inline-children');
+ }
+
+ },
+
+ calculate: function (ownerContext) {
+ var me = this,
+ containerSize = me.getContainerSize(ownerContext);
+
+ if (ownerContext.anchorDimensions !== ownerContext.state.calculatedAnchors) {
+ me.calculateAnchors(ownerContext, containerSize);
+ }
+
+ if (ownerContext.hasDomProp('containerChildrenDone')) {
+
+
+ if (!containerSize.gotAll) {
+ me.done = false;
+ }
+
+ me.calculateContentSize(ownerContext, ownerContext.anchorDimensions);
+
+ if (me.done) {
+ me.calculateOverflow(ownerContext, containerSize, ownerContext.anchorDimensions);
+ return;
+ }
+ }
+
+ me.done = false;
+ },
+
+ calculateAnchors: function (ownerContext, containerSize) {
+ var me = this,
+ childItems = ownerContext.childItems,
+ length = childItems.length,
+ gotHeight = containerSize.gotHeight,
+ gotWidth = containerSize.gotWidth,
+ ownerHeight = containerSize.height,
+ ownerWidth = containerSize.width,
+ state = ownerContext.state,
+ calculatedAnchors = (gotWidth ? 1 : 0) | (gotHeight ? 2 : 0),
+ anchorSpec, childContext, childMargins, height, i, width;
+
+ state.calculatedAnchors = (state.calculatedAnchors || 0) | calculatedAnchors;
+
+ for (i = 0; i < length; i++) {
+ childContext = childItems[i];
+ childMargins = childContext.getMarginInfo();
+ anchorSpec = childContext.target.anchorSpec;
+
+
+
+
+
+ if (gotWidth && childContext.widthModel.calculated) {
+ width = anchorSpec.right(ownerWidth) - childMargins.width;
+ width = me.adjustWidthAnchor(width, childContext);
+
+ childContext.setWidth(width);
+ }
+
+
+ if (gotHeight && childContext.heightModel.calculated) {
+ height = anchorSpec.bottom(ownerHeight) - childMargins.height;
+ height = me.adjustHeightAnchor(height, childContext);
+
+ childContext.setHeight(height);
+ }
+ }
+ },
+
+ finishedLayout: function (ownerContext) {
+ var cleanerFn = this.rightMarginCleanerFn;
+
+ if (cleanerFn) {
+ delete this.rightMarginCleanerFn;
+ ownerContext.targetContext.el.removeCls(Ext.baseCSSPrefix + 'inline-children');
+ cleanerFn();
+ }
+ },
+
+
+
+ anchorFactory: {
+ offset: function (delta) {
+ return function(v) {
+ return v + delta;
+ };
+ },
+ ratio: function (ratio) {
+ return function(v) {
+ return Math.floor(v * ratio);
+ };
+ },
+ standard: function (diff) {
+ return function(v) {
+ return v - diff;
+ };
+ }
+ },
+
+ parseAnchor: function(a, start, cstart) {
+ if (a && a != 'none') {
+ var factory = this.anchorFactory,
+ delta;
+
+ if (this.parseAnchorRE.test(a)) {
+ return factory.standard(cstart - start);
+ }
+ if (a.indexOf('%') != -1) {
+ return factory.ratio(parseFloat(a.replace('%', '')) * 0.01);
+ }
+ delta = parseInt(a, 10);
+ if (!isNaN(delta)) {
+ return factory.offset(delta);
+ }
+ }
+ return null;
+ },
+
+
+ adjustWidthAnchor: function(value, childContext) {
+ return value;
+ },
+
+
+ adjustHeightAnchor: function(value, childContext) {
+ return value;
+ },
+
+ configureItem: function(item) {
+ var me = this,
+ owner = me.owner,
+ anchor= item.anchor,
+ anchorsArray,
+ anchorWidth,
+ anchorHeight;
+
+ me.callParent(arguments);
+
+ if (!item.anchor && item.items && !Ext.isNumber(item.width) && !(Ext.isIE6 && Ext.isStrict)) {
+ item.anchor = anchor = me.defaultAnchor;
+ }
+
+
+ if (owner.anchorSize) {
+ if (typeof owner.anchorSize == 'number') {
+ anchorWidth = owner.anchorSize;
+ } else {
+ anchorWidth = owner.anchorSize.width;
+ anchorHeight = owner.anchorSize.height;
+ }
+ } else {
+ anchorWidth = owner.initialConfig.width;
+ anchorHeight = owner.initialConfig.height;
+ }
+
+ if (anchor) {
+
+ anchorsArray = anchor.split(' ');
+ item.anchorSpec = {
+ right: me.parseAnchor(anchorsArray[0], item.initialConfig.width, anchorWidth),
+ bottom: me.parseAnchor(anchorsArray[1], item.initialConfig.height, anchorHeight)
+ };
+ }
+ },
+
+ sizePolicy: {
+ '': {
+ setsWidth: 0,
+ setsHeight: 0
+ },
+ b: {
+ setsWidth: 0,
+ setsHeight: 1
+ },
+ r: {
+ '': {
+ setsWidth: 1,
+ setsHeight: 0
+ },
+ b: {
+ setsWidth: 1,
+ setsHeight: 1
+
+ }
+ }
+ },
+
+ getItemSizePolicy: function (item) {
+ var anchorSpec = item.anchorSpec,
+ key = '',
+ policy = this.sizePolicy,
+ sizeModel;
+
+ if (anchorSpec) {
+ sizeModel = this.owner.getSizeModel();
+ if (anchorSpec.right && !sizeModel.width.shrinkWrap) {
+ policy = policy.r;
+ }
+ if (anchorSpec.bottom && !sizeModel.height.shrinkWrap) {
+ key = 'b';
+ }
+ }
+
+ return policy[key];
+ }
+});
+
+
+Ext.define('Ext.window.MessageBox', {
+ extend: 'Ext.window.Window',
+
+ requires: [
+ 'Ext.toolbar.Toolbar',
+ 'Ext.form.field.Text',
+ 'Ext.form.field.TextArea',
+ 'Ext.form.field.Display',
+ 'Ext.button.Button',
+ 'Ext.layout.container.Anchor',
+ 'Ext.layout.container.HBox',
+ 'Ext.ProgressBar'
+ ],
+
+ alias: 'widget.messagebox',
+
+
+ OK : 1,
+
+ YES : 2,
+
+ NO : 4,
+
+ CANCEL : 8,
+
+ OKCANCEL : 9,
+
+ YESNO : 6,
+
+ YESNOCANCEL : 14,
+
+ INFO : Ext.baseCSSPrefix + 'message-box-info',
+
+ WARNING : Ext.baseCSSPrefix + 'message-box-warning',
+
+ QUESTION : Ext.baseCSSPrefix + 'message-box-question',
+
+ ERROR : Ext.baseCSSPrefix + 'message-box-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: 'vbox',
+ align: 'stretch'
+ },
+
+
+ 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 new 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(arguments);
+ },
+
+ initComponent: function() {
+ var me = this,
+ baseId = me.id,
+ i, button,
+ tbLayout;
+
+ me.title = ' ';
+
+ me.topContainer = new Ext.container.Container({
+ layout: 'hbox',
+ style: {
+ padding: '10px',
+ overflow: 'hidden'
+ },
+ items: [
+ me.iconComponent = new Ext.Component({
+ cls: me.baseCls + '-icon',
+ width: 50,
+ height: me.iconHeight
+ }),
+ me.promptContainer = new Ext.container.Container({
+ flex: 1,
+ layout: {
+ type: 'anchor'
+ },
+ items: [
+ me.msg = new Ext.form.field.Display({
+ id: baseId + '-displayfield',
+ cls: me.baseCls + '-text'
+ }),
+ me.textField = new Ext.form.field.Text({
+ id: baseId + '-testfield',
+ anchor: '100%',
+ enableKeyEvents: true,
+ listeners: {
+ keydown: me.onPromptKey,
+ scope: me
+ }
+ }),
+ me.textArea = new Ext.form.field.TextArea({
+ id: baseId + '-textarea',
+ anchor: '100%',
+ height: 75
+ })
+ ]
+ })
+ ]
+ });
+ me.progressBar = new Ext.ProgressBar({
+ id: baseId + '-progressbar',
+ margins: '0 10 0 10'
+ });
+
+ 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 = new Ext.toolbar.Toolbar({
+ id: baseId + '-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];
+
+
+ tbLayout = me.bottomTb.getLayout();
+ tbLayout.finishedLayout = Ext.Function.createInterceptor(tbLayout.finishedLayout, function(ownerContext) {
+ me.tbWidth = ownerContext.getProp('contentWidth');
+ });
+ me.on('close', me.onClose, me);
+
+ me.callParent();
+ },
+
+ onClose: function(){
+ var btn = this.header.child('[type=close]');
+
+ btn.itemId = 'cancel';
+ this.btnCallback(btn);
+ delete btn.itemId;
+ },
+
+ 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 = 0,
+ hideToolbar = true,
+ initialWidth = me.maxWidth,
+ oldButtonText = me.buttonText,
+ i;
+
+
+ me.updateButtonText();
+
+ 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 (Ext.isObject(cfg.buttons)) {
+ me.buttonText = cfg.buttons;
+ buttons = 0;
+ } else {
+ me.buttonText = cfg.buttonText || me.buttonText;
+ buttons = Ext.isNumber(cfg.buttons) ? cfg.buttons : 0;
+ }
+
+
+
+ buttons = buttons | me.updateButtonText();
+
+
+ me.buttonText = oldButtonText;
+
+
+
+ Ext.suspendLayouts();
+ me.hidden = false;
+ if (!me.rendered) {
+ me.width = initialWidth;
+ me.render(Ext.getBody());
+ } else {
+ me.setSize(initialWidth, me.maxHeight);
+ }
+
+
+ me.closable = cfg.closable && !cfg.wait;
+ me.header.child('[type=close]').setVisible(cfg.closable !== false);
+
+
+ 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.setValue(cfg.msg);
+ me.msg.show();
+ } else {
+ me.msg.hide();
+ }
+
+
+
+ Ext.resumeLayouts(true);
+ Ext.suspendLayouts();
+
+
+ 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();
+ }
+ Ext.resumeLayouts(true);
+ },
+
+
+ updateButtonText: function() {
+ var me = this,
+ buttonText = me.buttonText,
+ buttons = 0,
+ btnId,
+ btn;
+
+ for (btnId in buttonText) {
+ if (buttonText.hasOwnProperty(btnId)) {
+ btn = me.msgButtons[btnId];
+ if (btn) {
+ if (me.cfg && me.cfg.buttonText) {
+ buttons = buttons | Math.pow(2, Ext.Array.indexOf(me.buttonIds, btnId));
+ }
+ if (btn.text != buttonText[btnId]) {
+ btn.setText(buttonText[btnId]);
+ }
+ }
+ }
+ }
+ return buttons;
+ },
+
+
+ show: function(cfg) {
+ var me = this;
+
+ me.reconfigure(cfg);
+ me.addCls(cfg.cls);
+ me.doAutoSize();
+
+
+
+ me.hidden = true;
+ me.callParent();
+ return me;
+ },
+
+ onShow: function() {
+ this.callParent(arguments);
+ this.center();
+ },
+
+ doAutoSize: function() {
+ var me = this,
+ headerVisible = me.header.rendered && me.header.isVisible(),
+ footerVisible = me.bottomTb.rendered && me.bottomTb.isVisible(),
+ width,
+ height;
+
+ if (!Ext.isDefined(me.frameWidth)) {
+ me.frameWidth = me.el.getWidth() - me.body.getWidth();
+ }
+
+
+ me.minWidth = me.cfg.minWidth || Ext.getClass(this).prototype.minWidth;
+
+
+ width = Math.max(
+ headerVisible ? me.header.getMinWidth() : 0,
+ me.cfg.width || me.msg.getWidth() + me.iconComponent.getWidth() + 25,
+ (footerVisible ? me.tbWidth : 0)
+ );
+
+ height = (headerVisible ? me.header.getHeight() : 0) +
+ me.topContainer.getHeight() +
+ me.progressBar.getHeight() +
+ (footerVisible ? me.bottomTb.getHeight() + me.bottomTb.el.getMargin('tb') : 0);
+
+ me.setSize(width + me.frameWidth, height + me.frameWidth);
+ return me;
+ },
+
+ updateText: function(text) {
+ this.msg.setValue(text);
+ return this.doAutoSize(true);
+ },
+
+
+ setIcon : function(icon) {
+ var me = this;
+ me.iconComponent.removeCls(me.messageIconCls);
+ if (icon) {
+ me.iconComponent.show();
+ me.iconComponent.addCls(Ext.baseCSSPrefix + 'dlg-icon');
+ me.iconComponent.addCls(me.messageIconCls = 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: this.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,
+ progress: true,
+ 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,
+ api,
+ fn;
+
+
+ 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,|]/);
+ }
+
+ if (me.api) {
+ api = me.api = Ext.apply({}, me.api);
+ for (fn in api) {
+ if (api.hasOwnProperty(fn)) {
+ api[fn] = Ext.direct.Manager.parseMethod(api[fn]);
+ }
+ }
+ }
+
+ me.checkValidityTask = new Ext.util.DelayedTask(me.checkValidity, me);
+
+ me.addEvents(
+
+ 'beforeaction',
+
+ 'actionfailed',
+
+ 'actioncomplete',
+
+ 'validitychange',
+
+ 'dirtychange'
+ );
+ me.callParent();
+ },
+
+
+ initialize : function() {
+ var me = this;
+ me.initialized = true;
+ me.onValidityChange(!me.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) {
+
+ if (child.isDestroyed || child.destroying) {
+
+
+ delete me._fields;
+ } else {
+ 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 = new Ext.util.MixedCollection();
+ fields.addAll(this.owner.query('[isFormField]'));
+ }
+ return fields;
+ },
+
+
+ getBoundItems: function() {
+ var boundItems = this._boundItems;
+
+ if (!boundItems || boundItems.getCount() === 0) {
+ boundItems = this._boundItems = new 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;
+ Ext.suspendLayouts();
+ invalid = me.getFields().filterBy(function(field) {
+ return !field.validate();
+ });
+ Ext.resumeLayouts(true);
+ 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(),
+ items, i, iLen, cmp;
+
+ if (boundItems) {
+ items = boundItems.items;
+ iLen = items.length;
+
+ for (i = 0; i < iLen; i++) {
+ cmp = items[i];
+
+ 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) {
+ options = options || {};
+ var me = this,
+ action;
+
+ if (options.standardSubmit || me.standardSubmit) {
+ action = 'standardsubmit';
+ } else {
+ action = me.api ? 'directsubmit' : 'submit';
+ }
+
+ return me.doAction(action, options);
+ },
+
+
+ load: function(options) {
+ return this.doAction(this.api ? 'directload' : 'load', options);
+ },
+
+
+ updateRecord: function(record) {
+ record = record || this._record;
+ var fields = record.fields.items,
+ values = this.getFieldValues(),
+ obj = {},
+ i = 0,
+ len = fields.length,
+ name;
+
+ for (; i < len; ++i) {
+ name = fields[i].name;
+
+ if (values.hasOwnProperty(name)) {
+ 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',
+ fields = this.getFields().items,
+ f,
+ fLen = fields.length,
+ field, waitMsgTarget;
+
+
+ for (f = 0; f < fLen; f++) {
+ field = fields[f];
+
+ if (field.isFormField && field.syncValue) {
+ field.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.suspendEvents();
+ messageBox.hide();
+ messageBox.resumeEvents();
+ }
+ }
+ 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,
+ e, eLen, error, value,
+ key;
+
+ function mark(fieldId, msg) {
+ var field = me.findField(fieldId);
+ if (field) {
+ field.markInvalid(msg);
+ }
+ }
+
+ if (Ext.isArray(errors)) {
+ eLen = errors.length;
+
+ for (e = 0; e < eLen; e++) {
+ error = errors[e];
+ mark(error.id, error.msg);
+ }
+ } else if (errors instanceof Ext.data.Errors) {
+ eLen = errors.items.length;
+ for (e = 0; e < eLen; e++) {
+ error = errors.items[e];
+
+ mark(error.field, error.message);
+ }
+ } else {
+ for (key in errors) {
+ if (errors.hasOwnProperty(key)) {
+ value = errors[key];
+ mark(key, value, errors);
+ }
+ }
+ }
+ return this;
+ },
+
+
+ setValues: function(values) {
+ var me = this,
+ v, vLen, val, field;
+
+ function setVal(fieldId, val) {
+ var field = me.findField(fieldId);
+ if (field) {
+ field.setValue(val);
+ if (me.trackResetOnLoad) {
+ field.resetOriginalValue();
+ }
+ }
+ }
+
+ if (Ext.isArray(values)) {
+
+ vLen = values.length;
+
+ for (v = 0; v < vLen; v++) {
+ val = values[v];
+
+ setVal(val.id, val.value);
+ }
+ } else {
+
+ Ext.iterate(values, setVal);
+ }
+ return this;
+ },
+
+
+ getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+ var values = {},
+ fields = this.getFields().items,
+ f,
+ fLen = fields.length,
+ isArray = Ext.isArray,
+ field, data, val, bucket, name;
+
+ for (f = 0; f < fLen; f++) {
+ field = fields[f];
+
+ if (!dirtyOnly || field.isDirty()) {
+ data = field[useDataValues ? 'getModelData' : 'getSubmitData'](includeEmptyText);
+
+ if (Ext.isObject(data)) {
+ for (name in data) {
+ if (data.hasOwnProperty(name)) {
+ val = data[name];
+
+ if (includeEmptyText && val === '') {
+ val = field.emptyText || '';
+ }
+
+ if (values.hasOwnProperty(name)) {
+ bucket = values[name];
+
+ if (!isArray(bucket)) {
+ bucket = values[name] = [bucket];
+ }
+
+ if (isArray(val)) {
+ values[name] = 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() {
+ Ext.suspendLayouts();
+
+ var me = this,
+ fields = me.getFields().items,
+ f,
+ fLen = fields.length;
+
+ for (f = 0; f < fLen; f++) {
+ fields[f].clearInvalid();
+ }
+
+ Ext.resumeLayouts(true);
+ return me;
+ },
+
+
+ reset: function() {
+ Ext.suspendLayouts();
+
+ var me = this,
+ fields = me.getFields().items,
+ f,
+ fLen = fields.length;
+
+ for (f = 0; f < fLen; f++) {
+ fields[f].reset();
+ }
+
+ Ext.resumeLayouts(true);
+ return me;
+ },
+
+
+ applyToFields: function(obj) {
+ var fields = this.getFields().items,
+ f,
+ fLen = fields.length;
+
+ for (f = 0; f < fLen; f++) {
+ Ext.apply(fields[f], obj);
+ }
+
+ return this;
+ },
+
+
+ applyIfToFields: function(obj) {
+ var fields = this.getFields().items,
+ f,
+ fLen = fields.length;
+
+ for (f = 0; f < fLen; f++) {
+ Ext.applyIf(fields[f], obj);
+ }
+
+ return this;
+ }
+});
+
+
+Ext.define('Ext.layout.container.CheckboxGroup', {
+ extend: 'Ext.layout.container.Container',
+ alias: ['layout.checkboxgroup'],
+
+
+ autoFlex: true,
+
+ type: 'checkboxgroup',
+
+ childEls: [
+ 'innerCt'
+ ],
+
+ renderTpl: [
+ '| ', + '{% this.renderColumn(out,parent,xindex-1) %}', + ' | ', + '
',
+ '{%this.renderContainer(out,values);%}',
+ '
'
+ ],
+
+ stateEvents : [ 'collapse', 'expand' ],
+
+ maskOnDisable: false,
+
+ beforeDestroy: function(){
+ var me = this,
+ legend = me.legend;
+
+ if (legend) {
+
+ delete legend.ownerCt;
+ legend.destroy();
+ me.legend = null;
+ }
+ me.callParent();
+ },
+
+ initComponent: function() {
+ var me = this,
+ baseCls = me.baseCls;
+
+ me.callParent();
+
+ me.addEvents(
+
+
+ "beforeexpand",
+
+
+ "beforecollapse",
+
+
+ "expand",
+
+
+ "collapse"
+ );
+
+ if (me.collapsed) {
+ me.addCls(baseCls + '-collapsed');
+ me.collapse();
+ }
+ if (me.title) {
+ me.addCls(baseCls + '-with-title');
+ }
+ if (me.title || me.checkboxToggle || me.collapsible) {
+ me.addCls(baseCls + '-with-legend');
+ me.legend = Ext.widget(me.createLegendCt());
+ }
+ },
+
+
+ initRenderData: function() {
+ var data = this.callParent();
+
+ data.baseCls = this.baseCls;
+
+ return data;
+ },
+
+ getState: function () {
+ var state = this.callParent();
+
+ state = this.addPropertyToState(state, 'collapsed');
+
+ return state;
+ },
+
+ afterCollapse: Ext.emptyFn,
+ afterExpand: Ext.emptyFn,
+
+ collapsedHorizontal: function () {
+ return true;
+ },
+
+ collapsedVertical: function () {
+ return true;
+ },
+
+ createLegendCt: function () {
+ var me = this,
+ items = [],
+ legend = {
+ xtype: 'container',
+ baseCls: me.baseCls + '-header',
+ id: me.id + '-legend',
+ autoEl: 'legend',
+ items: items,
+ ownerCt: me,
+ ownerLayout: me.componentLayout
+ };
+
+
+ if (me.checkboxToggle) {
+ items.push(me.createCheckboxCmp());
+ } else if (me.collapsible) {
+
+ items.push(me.createToggleCmp());
+ }
+
+
+ items.push(me.createTitleCmp());
+
+ return legend;
+ },
+
+
+ createTitleCmp: function() {
+ var me = this,
+ cfg = {
+ xtype : 'component',
+ html : me.title,
+ cls : me.baseCls + '-header-text',
+ id : me.id + '-legendTitle'
+ };
+
+ if (me.collapsible && me.toggleOnTitleClick) {
+ cfg.listeners = {
+ el : {
+ scope : me,
+ click : me.toggle
+ }
+ };
+ cfg.cls += ' ' + me.baseCls + '-header-text-collapsible';
+ }
+
+ return (me.titleCmp = Ext.widget(cfg));
+ },
+
+
+
+
+ createCheckboxCmp: function() {
+ var me = this,
+ suffix = '-checkbox';
+
+ me.checkboxCmp = Ext.widget({
+ xtype: 'checkbox',
+ hideEmptyLabel: true,
+ name: me.checkboxName || me.id + suffix,
+ cls: me.baseCls + '-header' + suffix,
+ id: me.id + '-legendChk',
+ checked: !me.collapsed,
+ listeners: {
+ change: me.onCheckChange,
+ scope: me
+ }
+ });
+ return me.checkboxCmp;
+ },
+
+
+
+
+ createToggleCmp: function() {
+ var me = this;
+ me.toggleCmp = Ext.widget({
+ xtype: 'tool',
+ type: 'toggle',
+ handler: me.toggle,
+ id: me.id + '-legendToggle',
+ scope: me
+ });
+ return me.toggleCmp;
+ },
+
+ doRenderLegend: function (out, renderData) {
+
+
+
+ var me = renderData.$comp,
+ legend = me.legend,
+ tree;
+
+
+ if (legend) {
+ legend.ownerLayout.configureItem(legend);
+ tree = legend.getRenderTree();
+ Ext.DomHelper.generateMarkup(tree, out);
+ }
+ },
+
+ finishRender: function () {
+ var legend = this.legend;
+
+ this.callParent();
+
+ if (legend) {
+ legend.finishRender();
+ }
+ },
+
+ getCollapsed: function () {
+ return this.collapsed ? 'top' : false;
+ },
+
+ getCollapsedDockedItems: function () {
+ var legend = this.legend;
+
+ return legend ? [ legend ] : [];
+ },
+
+
+ setTitle: function(title) {
+ var me = this,
+ legend = me.legend;
+
+ me.title = title;
+ if (me.rendered) {
+ if (!me.legend) {
+ me.legend = legend = Ext.widget(me.createLegendCt());
+ legend.ownerLayout.configureItem(legend);
+ legend.render(me.el, 0);
+ }
+ me.titleCmp.update(title);
+ }
+ return me;
+ },
+
+ getTargetEl : function() {
+ return this.body || this.frameBody || this.el;
+ },
+
+ getContentTarget: function() {
+ return this.body;
+ },
+
+
+ expand : function(){
+ return this.setExpanded(true);
+ },
+
+
+ collapse : function() {
+ return this.setExpanded(false);
+ },
+
+
+ setExpanded: function(expanded) {
+ var me = this,
+ checkboxCmp = me.checkboxCmp,
+ operation = expanded ? 'expand' : 'collapse';
+
+ if (!me.rendered || me.fireEvent('before' + operation, me) !== false) {
+ expanded = !!expanded;
+
+ if (checkboxCmp) {
+ checkboxCmp.setValue(expanded);
+ }
+
+ if (expanded) {
+ me.removeCls(me.baseCls + '-collapsed');
+ } else {
+ me.addCls(me.baseCls + '-collapsed');
+ }
+ me.collapsed = !expanded;
+ if (me.rendered) {
+
+
+
+ me.updateLayout({ isRoot: false });
+ me.fireEvent(operation, me);
+ }
+ }
+ return me;
+ },
+
+ 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;
+ },
+
+
+ toggle: function() {
+ this.setExpanded(!!this.collapsed);
+ },
+
+
+ onCheckChange: function(cmp, checked) {
+ this.setExpanded(checked);
+ },
+
+ setupRenderTpl: function (renderTpl) {
+ this.callParent(arguments);
+
+ renderTpl.renderLegend = this.doRenderLegend;
+ }
+});
+
+
+Ext.define('Ext.form.Label', {
+ extend:'Ext.Component',
+ alias: 'widget.label',
+ requires: ['Ext.util.Format'],
+
+ autoEl: 'label',
+
+
+
+
+
+ maskOnDisable: false,
+
+ getElConfig: function(){
+ var me = this;
+
+ me.html = me.text ? Ext.util.Format.htmlEncode(me.text) : (me.html || '');
+ return Ext.apply(me.callParent(), {
+ htmlFor: me.forId || ''
+ });
+ },
+
+
+ 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;
+ me.updateLayout();
+ }
+ return me;
+ }
+});
+
+
+
+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',
+
+ basicFormConfigs: [
+ 'api',
+ 'baseParams',
+ 'errorReader',
+ 'method',
+ 'paramOrder',
+ 'paramsAsHash',
+ 'reader',
+ 'standardSubmit',
+ 'timeout',
+ 'trackResetOnLoad',
+ 'url',
+ 'waitMsgTarget',
+ 'waitTitle'
+ ],
+
+ 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();
+ },
+
+
+ afterFirstLayout: function() {
+ this.callParent();
+ this.form.initialize();
+ },
+
+
+ createForm: function() {
+ var cfg = {},
+ props = this.basicFormConfigs,
+ len = props.length,
+ i = 0,
+ prop;
+
+ for (; i < len; ++i) {
+ prop = props[i];
+ cfg[prop] = this[prop];
+ }
+ return new Ext.form.Basic(this, cfg);
+ },
+
+
+ getForm: function() {
+ return this.form;
+ },
+
+
+ loadRecord: function(record) {
+ return this.getForm().loadRecord(record);
+ },
+
+
+ getRecord: function() {
+ return this.getForm().getRecord();
+ },
+
+
+ getValues: function(asString, dirtyOnly, includeEmptyText, useDataValues) {
+ return this.getForm().getValues(asString, dirtyOnly, includeEmptyText, useDataValues);
+ },
+
+ beforeDestroy: function() {
+ this.stopPolling();
+ this.form.destroy();
+ this.callParent();
+ },
+
+
+ load: function(options) {
+ this.form.load(options);
+ },
+
+
+ submit: function(options) {
+ this.form.submit(options);
+ },
+
+
+ startPolling: function(interval) {
+ this.stopPolling();
+ var task = new 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() {
+ var fields = this.form.getFields().items,
+ f,
+ fLen = fields.length,
+ field;
+
+ for (f = 0; f < fLen; f++) {
+ fields[f].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(query) {
+ return this.query('[isRadio]' + (query||''));
+ },
+
+ checkChange: function() {
+ var value = this.getValue(),
+ key = Ext.Object.getKeys(value)[0];
+
+
+
+ if (Ext.isArray(value[key])) {
+ return;
+ }
+ this.callParent(arguments);
+ },
+
+
+ setValue: function(value) {
+ var cbValue, first, formId, radios,
+ i, len, name;
+
+ if (Ext.isObject(value)) {
+ for (name in value) {
+ if (value.hasOwnProperty(name)) {
+ cbValue = value[name];
+ first = this.items.first();
+ formId = first ? first.getFormId() : null;
+ radios = Ext.form.RadioManager.getWithValue(name, cbValue, formId).items;
+ len = radios.length;
+
+ for (i = 0; i < len; ++i) {
+ radios[i].setValue(true);
+ }
+ }
+ }
+ }
+ return this;
+ }
+});
+
+
+Ext.define('Ext.form.RadioManager', {
+ extend: 'Ext.util.MixedCollection',
+ singleton: true,
+
+ getByName: function(name, formId) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.getFormId() == formId;
+ });
+ },
+
+ getWithValue: function(name, value, formId) {
+ return this.filterBy(function(item) {
+ return item.name == name && item.inputValue == value && item.getFormId() == formId;
+ });
+ },
+
+ getChecked: function(name, formId) {
+ return this.findBy(function(item) {
+ return item.name == name && item.checked && item.getFormId() == formId;
+ });
+ }
+});
+
+
+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() {
+ var me = this,
+ form = me.form,
+ fn = form.api.load,
+ method = fn.directCfg.method,
+ args = method.getArgs(me.getParams(), form.paramOrder, form.paramsAsHash);
+
+ args.push(me.onComplete, me);
+ fn.apply(window, args);
+ },
+
+
+
+
+ processResponse: function(result) {
+ return (this.result = result);
+ },
+
+ onComplete: function(data, response) {
+ if (data) {
+ this.onSuccess(data);
+ } else {
+ this.onFailure(null);
+ }
+ }
+});
+
+
+
+
+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.onComplete, me),
+ formEl = me.buildForm();
+ me.form.api.submit(formEl, callback, me);
+ Ext.removeNode(formEl);
+ },
+
+
+
+
+ processResponse: function(result) {
+ return (this.result = result);
+ },
+
+ onComplete: function(data, response){
+ if (data) {
+ this.onSuccess(data);
+ } else {
+ this.onFailure(null);
+ }
+ }
+});
+
+
+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' ],
+
+ componentLayout: 'field',
+
+ childEls: [
+
+ 'boxLabelEl'
+ ],
+
+
+ fieldSubTpl: [
+ '| ' + field + ' | ' + + me.getTriggerMarkup() + + '
{1}
| ' + field + ' | ' + + me.getTriggerMarkup() + + '
- ' + me.getInnerTpl(me.displayField) + ' ', + '
',
+ '
',
+ '',
+ '',
+ '',
+ ' ',
+ '
',
+ '',
+ '',
+ '',
+ ' ',
+ '
',
+ '',
+ '',
+ '',
+ '',
+ '
',
+ '',
+ '',
+ '',
+ '
',
+ '',
+ '',
+ ' ',
+ '
',
+ {
+ firstInitial: function(value) {
+ return Ext.picker.Date.prototype.getDayInitial(value);
+ },
+ isEndOfWeek: function(value) {
+
+
+ value--;
+ var end = value % 7 === 0 && value !== 0;
+ return end ? '| {.:this.firstInitial} | ', + '
|---|
| ', + '', + '', + '', + ' | ', + '
' + Ext.DomHelper.markup(this.toolbar.getRenderTree());
+ return Ext.applyIf(this.callParent(), this.getLabelableRenderData());
+ },
+
+ getSubTplData: function() {
+ return {
+ $comp : this,
+ cmpId : this.id,
+ id : this.getInputId(),
+ textareaCls : Ext.baseCSSPrefix + 'hidden',
+ value : this.value,
+ iframeName : Ext.id(),
+ iframeSrc : Ext.SSL_SECURE_URL,
+ size : 'height:100px;width:100%'
+ };
+ },
+
+ getSubTplMarkup: function() {
+ return this.getTpl('fieldSubTpl').apply(this.getSubTplData());
+ },
+
+ 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) {
+ var items = this.getToolbar().items.items,
+ i,
+ iLen = items.length,
+ item;
+
+ for (i = 0; i < iLen; i++) {
+ item = items[i];
+
+ 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();
+ me.inputEl = textarea;
+ }
+ else {
+ if (me.initialized) {
+ me.disableItems(me.readOnly);
+ }
+ me.pushValue();
+ iframe.removeCls(hiddenCls);
+ textarea.addCls(hiddenCls);
+ textarea.dom.setAttribute('tabIndex', -1);
+ me.deferFocus();
+ me.inputEl = iframe;
+ }
+ me.fireEvent('editmodechange', me, sourceEditMode);
+ me.updateLayout();
+ },
+
+
+ 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) === parseInt(this.defaultValue.replace(/\D/g, ''), 10)) {
+ html = html.substring(1);
+ }
+ return html;
+ },
+
+
+ syncValue : function(){
+ var me = this,
+ body, changed, 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 = '
'); + range.collapse(false); + range.select(); + } + } + } + } + }; + } + + if (Ext.isOpera) { + return function(e){ + var me = this; + if (e.getKey() === e.TAB) { + e.stopEvent(); + if (!me.readOnly) { + me.win.focus(); + me.execCmd('InsertHTML',' '); + me.deferFocus(); + } + } + }; + } + + if (Ext.isWebKit) { + return function(e){ + var me = this, + k = e.getKey(), + readOnly = me.readOnly; + + if (k === e.TAB) { + e.stopEvent(); + if (!readOnly) { + me.execCmd('InsertText','\t'); + me.deferFocus(); + } + } + else if (k === e.ENTER) { + e.stopEvent(); + if (!readOnly) { + me.execCmd('InsertHtml','
'); + me.deferFocus(); + } + } + }; + } + + return null; + }()), + + + getToolbar : function(){ + return this.toolbar; + }, + + + + buttonTips : { + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + underline : { + title: 'Underline (Ctrl+U)', + text: 'Underline the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + increasefontsize : { + title: 'Grow Text', + text: 'Increase the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + decreasefontsize : { + title: 'Shrink Text', + text: 'Decrease the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + backcolor : { + title: 'Text Highlight Color', + text: 'Change the background color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + forecolor : { + title: 'Font Color', + text: 'Change the color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyleft : { + title: 'Align Text Left', + text: 'Align text to the left.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifycenter : { + title: 'Center Text', + text: 'Center text in the editor.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyright : { + title: 'Align Text Right', + text: 'Align text to the right.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertunorderedlist : { + title: 'Bullet List', + text: 'Start a bulleted list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertorderedlist : { + title: 'Numbered List', + text: 'Start a numbered list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + createlink : { + title: 'Hyperlink', + text: 'Make the selected text a hyperlink.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + sourceedit : { + title: 'Source Edit', + text: 'Switch to source editing mode.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + } + } + + + + + + + + + + + + + + + + + + +}); + + +Ext.define('Ext.form.field.Radio', { + extend:'Ext.form.field.Checkbox', + alias: ['widget.radiofield', 'widget.radio'], + alternateClassName: 'Ext.form.Radio', + requires: ['Ext.form.RadioManager'], + + + isRadio: true, + + + + + inputType: 'radio', + ariaRole: 'radio', + + formId: null, + + + getGroupValue: function() { + var selected = this.getManager().getChecked(this.name, this.getFormId()); + return selected ? selected.inputValue : null; + }, + + + onBoxClick: function(e) { + var me = this; + if (!me.disabled && !me.readOnly) { + this.setValue(true); + } + }, + + onRemoved: function(){ + this.callParent(arguments); + this.formId = null; + }, + + + setValue: function(v) { + var me = this, + active; + + if (Ext.isBoolean(v)) { + me.callParent(arguments); + } else { + active = me.getManager().getWithValue(me.name, v, me.getFormId()).getAt(0); + if (active) { + active.setValue(true); + } + } + return me; + }, + + + getSubmitValue: function() { + return this.checked ? this.inputValue : null; + }, + + getModelData: function() { + return this.getSubmitData(); + }, + + + onChange: function(newVal, oldVal) { + var me = this, + r, rLen, radio, radios; + + me.callParent(arguments); + + if (newVal) { + radios = me.getManager().getByName(me.name, me.getFormId()).items; + rLen = radios.length; + + for (r = 0; r < rLen; r++) { + radio = radios[r]; + + if (radio !== me) { + radio.setValue(false); + } + } + } + }, + + + getManager: function() { + return Ext.form.RadioManager; + } +}); + + +Ext.define('Ext.picker.Time', { + extend: 'Ext.view.BoundList', + alias: 'widget.timepicker', + requires: ['Ext.data.Store', 'Ext.Date'], + + + + + + + increment: 15, + + + + format : "g:i A", + + + + displayField: 'disp', + + + initDate: [2008,0,1], + + componentCls: Ext.baseCSSPrefix + 'timepicker', + + + loadMask: false, + + initComponent: function() { + var me = this, + dateUtil = Ext.Date, + clearTime = dateUtil.clearTime, + initDate = me.initDate; + + + me.absMin = clearTime(new Date(initDate[0], initDate[1], initDate[2])); + me.absMax = dateUtil.add(clearTime(new Date(initDate[0], initDate[1], initDate[2])), 'mi', (24 * 60) - 1); + + me.store = me.createStore(); + me.updateList(); + + me.callParent(); + }, + + + setMinValue: function(value) { + this.minValue = value; + this.updateList(); + }, + + + setMaxValue: function(value) { + this.maxValue = value; + this.updateList(); + }, + + + normalizeDate: function(date) { + var initDate = this.initDate; + date.setFullYear(initDate[0], initDate[1], initDate[2]); + return date; + }, + + + updateList: function() { + var me = this, + min = me.normalizeDate(me.minValue || me.absMin), + max = me.normalizeDate(me.maxValue || me.absMax); + + me.store.filterBy(function(record) { + var date = record.get('date'); + return date >= min && date <= max; + }); + }, + + + createStore: function() { + var me = this, + utilDate = Ext.Date, + times = [], + min = me.absMin, + max = me.absMax; + + while(min <= max){ + times.push({ + disp: utilDate.dateFormat(min, me.format), + date: min + }); + min = utilDate.add(min, 'mi', me.increment); + } + + return new Ext.data.Store({ + fields: ['disp', 'date'], + data: times + }); + } + +}); + + +Ext.define('Ext.form.field.Time', { + extend:'Ext.form.field.ComboBox', + alias: 'widget.timefield', + requires: ['Ext.form.field.Date', 'Ext.picker.Time', 'Ext.view.BoundListKeyNav', 'Ext.Date'], + alternateClassName: ['Ext.form.TimeField', 'Ext.form.Time'], + + + triggerCls: Ext.baseCSSPrefix + 'form-time-trigger', + + + + + + + + minText : "The time in this field must be equal to or after {0}", + + + + + maxText : "The time in this field must be equal to or before {0}", + + + + + invalidText : "{0} is not a valid time", + + + + + format : "g:i A", + + + + + + + + + altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A", + + + + increment: 15, + + + pickerMaxHeight: 300, + + + selectOnTab: true, + + + snapToIncrement: false, + + + initDate: '1/1/2008', + initDateFormat: 'j/n/Y', + + ignoreSelection: 0, + + queryMode: 'local', + + displayField: 'disp', + + valueField: 'date', + + initComponent: function() { + var me = this, + min = me.minValue, + max = me.maxValue; + if (min) { + me.setMinValue(min); + } + if (max) { + me.setMaxValue(max); + } + me.displayTpl = new Ext.XTemplate( + '' +
+ '{[typeof values === "string" ? values : this.formatDate(values["' + me.displayField + '"])]}' +
+ '' + me.delimiter + ' ' +
+ ' ', {
+ formatDate: Ext.Function.bind(me.formatDate, me)
+ });
+ this.callParent();
+ },
+
+
+ transformOriginalValue: function(value) {
+ if (Ext.isString(value)) {
+ return this.rawToValue(value);
+ }
+ return value;
+ },
+
+
+ isEqual: function(v1, v2) {
+ return Ext.Date.isEqual(v1, v2);
+ },
+
+
+ setMinValue: function(value) {
+ var me = this,
+ picker = me.picker;
+ me.setLimit(value, true);
+ if (picker) {
+ picker.setMinValue(me.minValue);
+ }
+ },
+
+
+ setMaxValue: function(value) {
+ var me = this,
+ picker = me.picker;
+ me.setLimit(value, false);
+ if (picker) {
+ picker.setMaxValue(me.maxValue);
+ }
+ },
+
+
+ setLimit: function(value, isMin) {
+ var me = this,
+ d, val;
+ if (Ext.isString(value)) {
+ d = me.parseDate(value);
+ }
+ else if (Ext.isDate(value)) {
+ d = value;
+ }
+ if (d) {
+ val = Ext.Date.clearTime(new Date(me.initDate));
+ val.setHours(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+ }
+
+ else {
+ val = null;
+ }
+ me[isMin ? 'minValue' : 'maxValue'] = val;
+ },
+
+ rawToValue: function(rawValue) {
+ return this.parseDate(rawValue) || rawValue || null;
+ },
+
+ valueToRaw: function(value) {
+ return this.formatDate(this.parseDate(value));
+ },
+
+
+ getErrors: function(value) {
+ var me = this,
+ format = Ext.String.format,
+ errors = me.callParent(arguments),
+ minValue = me.minValue,
+ maxValue = me.maxValue,
+ date;
+
+ value = me.formatDate(value || me.processRawValue(me.getRawValue()));
+
+ if (value === null || value.length < 1) {
+ return errors;
+ }
+
+ date = me.parseDate(value);
+ if (!date) {
+ errors.push(format(me.invalidText, value, Ext.Date.unescapeFormat(me.format)));
+ return errors;
+ }
+
+ if (minValue && date < minValue) {
+ errors.push(format(me.minText, me.formatDate(minValue)));
+ }
+
+ if (maxValue && date > maxValue) {
+ errors.push(format(me.maxText, me.formatDate(maxValue)));
+ }
+
+ return errors;
+ },
+
+ formatDate: function() {
+ return Ext.form.field.Date.prototype.formatDate.apply(this, arguments);
+ },
+
+
+ parseDate: function(value) {
+ var me = this,
+ val = value,
+ altFormats = me.altFormats,
+ altFormatsArray = me.altFormatsArray,
+ i = 0,
+ len;
+
+ if (value && !Ext.isDate(value)) {
+ val = me.safeParse(value, me.format);
+
+ if (!val && altFormats) {
+ altFormatsArray = altFormatsArray || altFormats.split('|');
+ len = altFormatsArray.length;
+ for (; i < len && !val; ++i) {
+ val = me.safeParse(value, altFormatsArray[i]);
+ }
+ }
+ }
+
+
+ if (val && me.snapToIncrement) {
+ val = new Date(Ext.Number.snap(val.getTime(), me.increment * 60 * 1000));
+ }
+ return val;
+ },
+
+ safeParse: function(value, format){
+ var me = this,
+ utilDate = Ext.Date,
+ parsedDate,
+ result = null;
+
+ if (utilDate.formatContainsDateInfo(format)) {
+
+ result = utilDate.parse(value, format);
+ } else {
+
+ parsedDate = utilDate.parse(me.initDate + ' ' + value, me.initDateFormat + ' ' + format);
+ if (parsedDate) {
+ result = parsedDate;
+ }
+ }
+ return result;
+ },
+
+
+ getSubmitValue: function() {
+ var me = this,
+ format = me.submitFormat || me.format,
+ value = me.getValue();
+
+ return value ? Ext.Date.format(value, format) : null;
+ },
+
+
+ createPicker: function() {
+ var me = this,
+ picker;
+
+ me.listConfig = Ext.apply({
+ xtype: 'timepicker',
+ selModel: {
+ mode: 'SINGLE'
+ },
+ cls: undefined,
+ minValue: me.minValue,
+ maxValue: me.maxValue,
+ increment: me.increment,
+ format: me.format,
+ maxHeight: me.pickerMaxHeight
+ }, me.listConfig);
+ picker = me.callParent();
+ me.store = picker.store;
+ return picker;
+ },
+
+ onItemClick: function(picker, record){
+
+ var me = this,
+ selected = picker.getSelectionModel().getSelection();
+
+ if (selected.length > 0) {
+ selected = selected[0];
+ if (selected && Ext.Date.isEqual(record.get('date'), selected.get('date'))) {
+ me.collapse();
+ }
+ }
+ },
+
+
+ onListSelectionChange: function(list, recordArray) {
+ var me = this,
+ record = recordArray[0],
+ val = record ? record.get('date') : null;
+
+ if (!me.ignoreSelection) {
+ me.skipSync = true;
+ me.setValue(val);
+ me.skipSync = false;
+ me.fireEvent('select', me, val);
+ me.picker.clearHighlight();
+ me.collapse();
+ me.inputEl.focus();
+ }
+ },
+
+
+ syncSelection: function() {
+ var me = this,
+ picker = me.picker,
+ toSelect,
+ selModel,
+ value,
+ data, d, dLen, rec;
+
+ if (picker && !me.skipSync) {
+ picker.clearHighlight();
+ value = me.getValue();
+ selModel = picker.getSelectionModel();
+
+ me.ignoreSelection++;
+ if (value === null) {
+ selModel.deselectAll();
+ } else if(Ext.isDate(value)) {
+
+ data = picker.store.data.items;
+ dLen = data.length;
+
+ for (d = 0; d < dLen; d++) {
+ rec = data[d];
+
+ if (Ext.Date.isEqual(rec.get('date'), value)) {
+ toSelect = rec;
+ break;
+ }
+ }
+
+ selModel.select(toSelect);
+ }
+ me.ignoreSelection--;
+ }
+ },
+
+ postBlur: function() {
+ var me = this;
+
+ me.callParent(arguments);
+ me.setRawValue(me.formatDate(me.getValue()));
+ },
+
+ setValue: function() {
+
+
+ this.getPicker();
+
+ this.callParent(arguments);
+ },
+
+ getValue: function() {
+ return this.parseDate(this.callParent(arguments));
+ }
+});
+
+
+Ext.define('Ext.grid.CellEditor', {
+ extend: 'Ext.Editor',
+ constructor: function(config) {
+ config = Ext.apply({}, config);
+
+ if (config.field) {
+ config.field.monitorTab = false;
+ }
+ this.callParent([config]);
+ },
+
+
+ onShow: function() {
+ var me = this,
+ innerCell = me.boundEl.first(),
+ lastChild,
+ textNode;
+
+ if (innerCell) {
+ lastChild = innerCell.dom.lastChild;
+ if(lastChild && lastChild.nodeType === 3) {
+
+ textNode = me.cellTextNode = innerCell.dom.lastChild;
+
+ me.cellTextValue = textNode.nodeValue;
+
+
+ textNode.nodeValue = '\u00a0';
+ }
+ }
+ me.callParent(arguments);
+ },
+
+
+ onHide: function() {
+ var me = this,
+ innerCell = me.boundEl.first();
+
+ if (innerCell && me.cellTextNode) {
+ me.cellTextNode.nodeValue = me.cellTextValue;
+ delete me.cellTextNode;
+ delete me.cellTextValue;
+ }
+ me.callParent(arguments);
+ },
+
+
+ afterRender: function() {
+ var me = this,
+ field = me.field;
+
+ me.callParent(arguments);
+ if (field.isXType('checkboxfield')) {
+ field.mon(field.inputEl, {
+ mousedown: me.onCheckBoxMouseDown,
+ click: me.onCheckBoxClick,
+ scope: me
+ });
+ }
+ },
+
+
+ onCheckBoxMouseDown: function() {
+ this.completeEdit = Ext.emptyFn;
+ },
+
+
+ onCheckBoxClick: function() {
+ delete this.completeEdit;
+ this.field.focus(false, 10);
+ },
+
+
+ realign: function(autoSize) {
+ var me = this,
+ boundEl = me.boundEl,
+ innerCell = boundEl.first(),
+ children = innerCell.dom.childNodes,
+ childCount = children.length,
+ offsets = Ext.Array.clone(me.offsets),
+ inputEl = me.field.inputEl,
+ lastChild, leftBound, rightBound, width;
+
+
+
+
+
+
+ if(me.isForTree && (childCount > 1 || (childCount === 1 && children[0].nodeType !== 3))) {
+
+ lastChild = innerCell.last();
+
+ leftBound = lastChild.getOffsetsTo(innerCell)[0] + lastChild.getWidth();
+
+
+
+ rightBound = innerCell.getWidth();
+
+
+ width = rightBound - leftBound;
+
+
+ if(!me.editingPlugin.grid.columnLines) {
+ width --;
+ }
+
+ offsets[0] += leftBound;
+
+ me.addCls(Ext.baseCSSPrefix + 'grid-editor-on-text-node');
+ } else {
+ width = boundEl.getWidth() - 1;
+ }
+
+ if (autoSize === true) {
+ me.field.setWidth(width);
+ }
+
+ me.alignTo(boundEl, me.alignment, offsets);
+ },
+
+ onEditorTab: function(e){
+ var field = this.field;
+ if (field.onEditorTab) {
+ field.onEditorTab(e);
+ }
+ },
+
+ alignment: "tl-tl",
+ hideEl : false,
+ cls: Ext.baseCSSPrefix + "small-editor " + Ext.baseCSSPrefix + "grid-editor",
+ shim: false,
+ shadow: false
+});
+
+
+Ext.define('Ext.grid.ColumnComponentLayout', {
+ extend: 'Ext.layout.component.Auto',
+ alias: 'layout.columncomponent',
+
+ type: 'columncomponent',
+
+ setWidthInDom: true,
+
+ getContentHeight : function(ownerContext) {
+
+ return this.owner.isGroupHeader ? ownerContext.getProp('contentHeight') : this.callParent(arguments);
+ },
+
+ calculateOwnerHeightFromContentHeight: function (ownerContext, contentHeight) {
+ var result = this.callParent(arguments);
+ if (this.owner.isGroupHeader) {
+ result += this.owner.titleEl.dom.offsetHeight;
+ }
+ return result;
+ },
+
+ getContentWidth : function(ownerContext) {
+
+ return this.owner.isGroupHeader ? ownerContext.getProp('contentWidth') : this.callParent(arguments);
+ },
+
+ calculateOwnerWidthFromContentWidth: function (ownerContext, contentWidth) {
+ return contentWidth + ownerContext.getPaddingInfo().width;
+ }
+});
+
+
+Ext.define('Ext.grid.ColumnLayout', {
+ extend: 'Ext.layout.container.HBox',
+ alias: 'layout.gridcolumn',
+ type : 'gridcolumn',
+
+ reserveOffset: false,
+
+ firstHeaderCls: Ext.baseCSSPrefix + 'column-header-first',
+ lastHeaderCls: Ext.baseCSSPrefix + 'column-header-last',
+
+ initLayout: function() {
+ this.grid = this.owner.up('[scrollerOwner]');
+ this.callParent();
+ },
+
+
+ beginLayout: function (ownerContext) {
+ var me = this,
+ grid = me.grid,
+ view = grid.view,
+ i = 0,
+ items = me.getVisibleItems(),
+ len = items.length,
+ item;
+
+ ownerContext.gridContext = ownerContext.context.getCmp(me.grid);
+
+
+
+
+ if (grid.lockable) {
+ if (me.owner.up('tablepanel') === view.normalGrid) {
+ view = view.normalGrid.getView();
+ } else {
+ view = null;
+ }
+ }
+
+ me.callParent(arguments);
+
+
+ for (; i < len; i++) {
+ item = items[i];
+ item.removeCls([me.firstHeaderCls, me.lastHeaderCls]);
+ item.el.setStyle({
+ height: 'auto'
+ });
+ item.titleEl.setStyle({
+ height: 'auto',
+ paddingTop: ''
+ });
+ }
+
+
+ if (len > 0) {
+ items[0].addCls(me.firstHeaderCls);
+ items[len - 1].addCls(me.lastHeaderCls);
+ }
+
+
+
+
+ if (!me.owner.isHeader && Ext.getScrollbarSize().width && !grid.collapsed && view &&
+ view.table.dom && (view.autoScroll || view.overflowY)) {
+ ownerContext.viewContext = ownerContext.context.getCmp(view);
+ }
+ },
+
+ roundFlex: function(width) {
+ return Math.floor(width);
+ },
+
+ calculate: function(ownerContext) {
+ var me = this,
+ viewContext = ownerContext.viewContext,
+ tableHeight,
+ viewHeight;
+
+ me.callParent(arguments);
+
+ if (ownerContext.state.parallelDone) {
+ ownerContext.setProp('columnWidthsDone', true);
+ }
+
+
+
+
+
+ if (viewContext && !ownerContext.state.overflowAdjust.width && !ownerContext.gridContext.heightModel.shrinkWrap) {
+ tableHeight = viewContext.tableContext.getProp('height');
+ viewHeight = viewContext.getProp('height');
+
+
+ if (isNaN(tableHeight + viewHeight)) {
+ me.done = false;
+ }
+
+
+ else if (tableHeight >= viewHeight) {
+ ownerContext.gridContext.invalidate({
+ after: function() {
+ ownerContext.state.overflowAdjust = {
+ width: Ext.getScrollbarSize().width,
+ height: 0
+ };
+ }
+ });
+ }
+ }
+ },
+
+ completeLayout: function(ownerContext) {
+ var me = this,
+ owner = me.owner,
+ state = ownerContext.state,
+ needsInvalidate = false,
+ calculated = me.sizeModels.calculated,
+ childItems, len, i, childContext, item;
+
+ me.callParent(arguments);
+
+
+
+
+ if (!state.flexesCalculated && owner.forceFit && !owner.isHeader) {
+ childItems = ownerContext.childItems;
+ len = childItems.length;
+
+ for (i = 0; i < len; i++) {
+ childContext = childItems[i];
+ item = childContext.target;
+
+
+
+ if (item.width) {
+ item.flex = ownerContext.childItems[i].flex = item.width;
+ delete item.width;
+ childContext.widthModel = calculated;
+ needsInvalidate = true;
+ }
+ }
+
+
+
+ if (needsInvalidate) {
+ me.cacheFlexes(ownerContext);
+ ownerContext.invalidate({
+ state: {
+ flexesCalculated: true
+ }
+ });
+ }
+ }
+ },
+
+ finalizeLayout: function() {
+ var me = this,
+ i = 0,
+ items,
+ len,
+ itemsHeight,
+ owner = me.owner,
+ titleEl = owner.titleEl;
+
+
+ items = me.getVisibleItems();
+ len = items.length;
+
+ itemsHeight = owner.el.getViewSize().height;
+ if (titleEl) {
+
+
+ itemsHeight -= titleEl.getHeight();
+ }
+ for (; i < len; i++) {
+ items[i].setPadding(itemsHeight);
+ }
+ },
+
+
+
+ publishInnerCtSize: function(ownerContext) {
+ var me = this,
+ size = ownerContext.state.boxPlan.targetSize,
+ cw = ownerContext.peek('contentWidth'),
+ view;
+
+
+ if ((cw != null) && !me.owner.isHeader) {
+ size.width = cw;
+
+
+ view = me.owner.ownerCt.view;
+ if (view.autoScroll || view.overflowY) {
+ size.width += Ext.getScrollbarSize().width;
+ }
+ }
+
+ return me.callParent(arguments);
+ }
+});
+
+
+Ext.define('Ext.grid.LockingView', {
+
+ mixins: {
+ observable: 'Ext.util.Observable'
+ },
+
+ eventRelayRe: /^(beforeitem|beforecontainer|item|container|cell)/,
+
+ constructor: function(config){
+ var me = this,
+ eventNames = [],
+ eventRe = me.eventRelayRe,
+ locked = config.locked.getView(),
+ normal = config.normal.getView(),
+ events,
+ event;
+
+ Ext.apply(me, {
+ lockedView: locked,
+ normalView: normal,
+ lockedGrid: config.locked,
+ normalGrid: config.normal,
+ panel: config.panel
+ });
+ me.mixins.observable.constructor.call(me, config);
+
+
+ events = locked.events;
+ for (event in events) {
+ if (events.hasOwnProperty(event) && eventRe.test(event)) {
+ eventNames.push(event);
+ }
+ }
+ me.relayEvents(locked, eventNames);
+ me.relayEvents(normal, eventNames);
+
+ normal.on({
+ scope: me,
+ itemmouseleave: me.onItemMouseLeave,
+ itemmouseenter: me.onItemMouseEnter
+ });
+
+ locked.on({
+ scope: me,
+ itemmouseleave: me.onItemMouseLeave,
+ itemmouseenter: me.onItemMouseEnter
+ });
+ },
+
+ getGridColumns: function() {
+ var cols = this.lockedGrid.headerCt.getGridColumns();
+ return cols.concat(this.normalGrid.headerCt.getGridColumns());
+ },
+
+ getEl: function(column){
+ return this.getViewForColumn(column).getEl();
+ },
+
+ getViewForColumn: function(column) {
+ var view = this.lockedView,
+ inLocked;
+
+ view.headerCt.cascade(function(col){
+ if (col === column) {
+ inLocked = true;
+ return false;
+ }
+ });
+
+ return inLocked ? view : this.normalView;
+ },
+
+ onItemMouseEnter: function(view, record){
+ var me = this,
+ locked = me.lockedView,
+ other = me.normalView,
+ item;
+
+ if (view.trackOver) {
+ if (view !== locked) {
+ other = locked;
+ }
+ item = other.getNode(record);
+ other.highlightItem(item);
+ }
+ },
+
+ onItemMouseLeave: function(view, record){
+ var me = this,
+ locked = me.lockedView,
+ other = me.normalView;
+
+ if (view.trackOver) {
+ if (view !== locked) {
+ other = locked;
+ }
+ other.clearHighlight();
+ }
+ },
+
+ relayFn: function(name, args){
+ args = args || [];
+
+ var view = this.lockedView;
+ view[name].apply(view, args || []);
+ view = this.normalView;
+ view[name].apply(view, args || []);
+ },
+
+ getSelectionModel: function(){
+ return this.panel.getSelectionModel();
+ },
+
+ getStore: function(){
+ return this.panel.store;
+ },
+
+ getNode: function(nodeInfo){
+
+ return this.normalView.getNode(nodeInfo);
+ },
+
+ getCell: function(record, column){
+ var view = this.getViewForColumn(column),
+ row;
+
+ row = view.getNode(record);
+ return Ext.fly(row).down(column.getCellSelector());
+ },
+
+ getRecord: function(node){
+ var result = this.lockedView.getRecord(node);
+ if (!node) {
+ result = this.normalView.getRecord(node);
+ }
+ return result;
+ },
+
+ addElListener: function(eventName, fn, scope){
+ this.relayFn('addElListener', arguments);
+ },
+
+ refreshNode: function(){
+ this.relayFn('refreshNode', arguments);
+ },
+
+ refresh: function(){
+ this.relayFn('refresh', arguments);
+ },
+
+ bindStore: function(){
+ this.relayFn('bindStore', arguments);
+ },
+
+ addRowCls: function(){
+ this.relayFn('addRowCls', arguments);
+ },
+
+ removeRowCls: function(){
+ this.relayFn('removeRowCls', arguments);
+ }
+
+});
+
+
+Ext.define('Ext.view.TableLayout', {
+ extend: 'Ext.layout.component.Auto',
+
+ alias: ['layout.tableview'],
+ type: 'tableview',
+
+ beginLayout: function(ownerContext) {
+ var me = this;
+
+ me.callParent(arguments);
+
+
+ if (me.owner.table.dom) {
+ ownerContext.tableContext = ownerContext.getEl(me.owner.table);
+
+
+ ownerContext.headerContext = ownerContext.context.getCmp(me.headerCt);
+ }
+ },
+
+ calculate: function(ownerContext) {
+ var me = this;
+
+ me.callParent(arguments);
+
+ if (ownerContext.tableContext) {
+ if (ownerContext.state.columnWidthsSynced) {
+ if (ownerContext.hasProp('columnWidthsFlushed')) {
+ ownerContext.tableContext.setHeight(ownerContext.tableContext.el.dom.offsetHeight, false);
+ } else {
+ me.done = false;
+ }
+ } else {
+ if (ownerContext.headerContext.hasProp('columnWidthsDone')) {
+ ownerContext.context.queueFlush(me);
+ ownerContext.state.columnWidthsSynced = true;
+ }
+
+
+
+
+ me.done = false;
+ }
+ }
+ },
+
+ measureContentHeight: function(ownerContext) {
+
+ if (!ownerContext.headerContext || ownerContext.hasProp('columnWidthsFlushed')) {
+ return this.callParent(arguments);
+ }
+ },
+
+ flush: function() {
+ var me = this,
+ context = me.ownerContext.context,
+ columns = me.headerCt.getGridColumns(),
+ i = 0, len = columns.length,
+ el = me.owner.el,
+ tableWidth = 0,
+ colWidth;
+
+
+ context.currentLayout = me;
+
+
+ for (i = 0; i < len; i++) {
+ colWidth = columns[i].hidden ? 0 : context.getCmp(columns[i]).props.width;
+ tableWidth += colWidth;
+
+
+
+
+ el.select(me.getColumnSelector(columns[i])).setWidth(colWidth);
+ }
+ el.select('table.' + Ext.baseCSSPrefix + 'grid-table-resizer').setWidth(tableWidth);
+
+
+ me.ownerContext.setProp('columnWidthsFlushed', true);
+ },
+
+ finishedLayout: function(){
+ var me = this,
+ first;
+
+ me.callParent(arguments);
+
+
+
+ if (Ext.isGecko) {
+ first = me.headerCt.getGridColumns()[0];
+ if (first) {
+ first = me.owner.el.down(me.getColumnSelector(first));
+ if (first) {
+ first.setStyle('display', 'none');
+ first.dom.scrollWidth;
+ first.setStyle('display', '');
+ }
+ }
+ }
+ },
+
+ getColumnSelector: function(column) {
+ return 'th.' + Ext.baseCSSPrefix + 'grid-col-resizer-' + column.id;
+ }
+});
+
+
+Ext.define('Ext.view.Table', {
+ extend: 'Ext.view.View',
+ alias: 'widget.tableview',
+ uses: [
+ 'Ext.view.TableLayout',
+ 'Ext.view.TableChunker',
+ 'Ext.util.DelayedTask',
+ 'Ext.util.MixedCollection'
+ ],
+
+ componentLayout: 'tableview',
+
+ baseCls: Ext.baseCSSPrefix + 'grid-view',
+
+
+ itemSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-row',
+
+ cellSelector: 'td.' + Ext.baseCSSPrefix + 'grid-cell',
+
+
+ rowSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-row',
+
+
+ firstCls: Ext.baseCSSPrefix + 'grid-cell-first',
+
+
+ lastCls: Ext.baseCSSPrefix + 'grid-cell-last',
+
+ headerRowSelector: 'tr.' + Ext.baseCSSPrefix + 'grid-header-row',
+
+ selectedItemCls: Ext.baseCSSPrefix + 'grid-row-selected',
+ selectedCellCls: Ext.baseCSSPrefix + 'grid-cell-selected',
+ focusedItemCls: Ext.baseCSSPrefix + 'grid-row-focused',
+ overItemCls: Ext.baseCSSPrefix + 'grid-row-over',
+ altRowCls: Ext.baseCSSPrefix + 'grid-row-alt',
+ rowClsRe: new RegExp('(?:^|\\s*)' + Ext.baseCSSPrefix + 'grid-row-(first|last|alt)(?:\\s+|$)', 'g'),
+ cellRe: new RegExp(Ext.baseCSSPrefix + 'grid-cell-([^\\s]+) ', ''),
+
+
+ trackOver: true,
+
+
+ getRowClass: null,
+
+
+ stripeRows: true,
+
+
+ markDirty : true,
+
+
+
+
+ initialTpl: '',
+
+ initComponent: function() {
+ var me = this,
+ scroll = me.scroll;
+
+
+ me.table = new Ext.dom.Element.Fly();
+ me.table.id = me.id + 'gridTable';
+
+
+
+ me.autoScroll = undefined;
+
+
+ if (scroll === true || scroll === 'both') {
+ me.autoScroll = true;
+ } else if (scroll === 'horizontal') {
+ me.overflowX = 'auto';
+ } else if (scroll === 'vertical') {
+ me.overflowY = 'auto';
+ }
+ me.selModel.view = me;
+ me.headerCt.view = me;
+ me.headerCt.markDirty = me.markDirty;
+
+
+ me.initFeatures(me.grid);
+ delete me.grid;
+
+
+ me.tpl = me.getTpl('initialTpl');
+ me.callParent();
+ },
+
+
+ moveColumn: function(fromIdx, toIdx, colsToMove) {
+ var me = this,
+ fragment = (colsToMove > 1) ? document.createDocumentFragment() : undefined,
+ destinationCellIdx = toIdx,
+ colCount = me.getGridColumns().length,
+ lastIdx = colCount - 1,
+ doFirstLastClasses = (me.firstCls || me.lastCls) && (toIdx === 0 || toIdx == colCount || fromIdx === 0 || fromIdx == lastIdx),
+ i,
+ j,
+ rows, len, tr, headerRows;
+
+ if (me.rendered) {
+
+
+ headerRows = me.el.query(me.headerRowSelector);
+ rows = me.el.query(me.rowSelector);
+
+ if (toIdx > fromIdx && fragment) {
+ destinationCellIdx -= colsToMove;
+ }
+
+
+ for (i = 0, len = headerRows.length; i < len; ++i) {
+ tr = headerRows[i];
+ if (fragment) {
+ for (j = 0; j < colsToMove; j++) {
+ fragment.appendChild(tr.cells[fromIdx]);
+ }
+ tr.insertBefore(fragment, tr.cells[destinationCellIdx] || null);
+ } else {
+ tr.insertBefore(tr.cells[fromIdx], tr.cells[destinationCellIdx] || null);
+ }
+ }
+
+ for (i = 0, len = rows.length; i < len; i++) {
+ tr = rows[i];
+
+
+ if (doFirstLastClasses) {
+
+ if (fromIdx === 0) {
+ Ext.fly(tr.cells[0]).removeCls(me.firstCls);
+ Ext.fly(tr.cells[1]).addCls(me.firstCls);
+ } else if (fromIdx === lastIdx) {
+ Ext.fly(tr.cells[lastIdx]).removeCls(me.lastCls);
+ Ext.fly(tr.cells[lastIdx - 1]).addCls(me.lastCls);
+ }
+ if (toIdx === 0) {
+ Ext.fly(tr.cells[0]).removeCls(me.firstCls);
+ Ext.fly(tr.cells[fromIdx]).addCls(me.firstCls);
+ } else if (toIdx === colCount) {
+ Ext.fly(tr.cells[lastIdx]).removeCls(me.lastCls);
+ Ext.fly(tr.cells[fromIdx]).addCls(me.lastCls);
+ }
+ }
+
+ if (fragment) {
+ for (j = 0; j < colsToMove; j++) {
+ fragment.appendChild(tr.cells[fromIdx]);
+ }
+ tr.insertBefore(fragment, tr.cells[destinationCellIdx] || null);
+ } else {
+ tr.insertBefore(tr.cells[fromIdx], tr.cells[destinationCellIdx] || null);
+ }
+ }
+ me.setNewTemplate();
+ }
+ },
+
+
+ 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(grid) {
+ var me = this,
+ i,
+ features,
+ feature,
+ len;
+
+ me.featuresMC = new Ext.util.MixedCollection();
+ features = me.features = me.constructFeatures();
+ len = features ? features.length : 0;
+ for (i = 0; i < len; i++) {
+ feature = features[i];
+
+
+ feature.view = me;
+ feature.grid = grid;
+ me.featuresMC.add(feature);
+ feature.init();
+ }
+ },
+
+
+ constructFeatures: function() {
+ var me = this,
+ features = me.features,
+ feature,
+ result,
+ i = 0, len;
+
+ if (features) {
+ result = [];
+ len = features.length;
+ for (; i < len; i++) {
+ feature = features[i];
+ if (!feature.isFeature) {
+ feature = Ext.create('feature.' + feature.ftype, feature);
+ }
+ result[i] = feature;
+ }
+ }
+ return result;
+ },
+
+
+ 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();
+
+ if (!me.enableTextSelection) {
+ me.el.unselectable();
+ }
+ me.attachEventsForFeatures();
+ },
+
+
+ onViewScroll: function(e, t) {
+ this.callParent(arguments);
+ this.fireEvent('bodyscroll', e, t);
+ },
+
+
+ prepareData: function(data, idx, record) {
+ var me = this,
+ result = me.headerCt.prepareData(data, idx, record, me, me.ownerCt),
+ features = me.features,
+ ln = features.length,
+ i = 0,
+ feature;
+
+ for (; i < ln; i++) {
+ feature = features[i];
+ if (feature.isFeature) {
+ Ext.apply(result, feature.getAdditionalData(data, idx, record, result, me));
+ }
+ }
+
+ return result;
+ },
+
+
+ collectData: function(records, startIndex) {
+ var me = this,
+ preppedRecords = me.callParent(arguments),
+ headerCt = me.headerCt,
+ fullWidth = headerCt.getFullWidth(),
+ features = me.features,
+ ln = features.length,
+ o = {
+ rows: preppedRecords,
+ fullWidth: fullWidth
+ },
+ i = 0,
+ feature,
+ j = 0,
+ jln,
+ rowParams,
+ rec,
+ cls;
+
+ jln = preppedRecords.length;
+
+
+ if (me.getRowClass) {
+ for (; j < jln; j++) {
+ rowParams = {};
+ rec = preppedRecords[j];
+ cls = rec.rowCls || '';
+ rec.rowCls = this.getRowClass(records[j], j, rowParams, me.store) + ' ' + cls;
+ }
+ }
+
+
+ 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;
+ },
+
+
+
+
+
+
+
+ refreshSize: function() {
+ var me = this,
+ cmp;
+
+
+ me.table.attach(me.el.child('table', true));
+
+ if (!me.hasLoadingHeight) {
+ cmp = me.up('tablepanel');
+
+
+
+ Ext.suspendLayouts();
+
+ me.callParent();
+
+
+
+ if (cmp && Ext.getScrollbarSize().width && (me.autoScroll || me.overflowY)) {
+ cmp.updateLayout();
+ }
+
+ Ext.resumeLayouts(true);
+ }
+ },
+
+
+ setNewTemplate: function() {
+ var me = this,
+ columns = me.headerCt.getColumnsForTpl(true);
+
+
+ me.tpl = me.getTableChunker().getTableTpl({
+ rowCount: me.store.getCount(),
+ columns: columns,
+ features: me.features,
+ enableTextSelection: me.enableTextSelection
+ });
+ },
+
+
+ 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, true);
+ if (cell) {
+ Ext.fly(cell).addCls(this.selectedCellCls);
+ }
+ },
+
+ onCellDeselect: function(position) {
+ var cell = this.getCellByPosition(position, true);
+ if (cell) {
+ Ext.fly(cell).removeCls(this.selectedCellCls);
+ }
+
+ },
+
+ onCellFocus: function(position) {
+ this.focusCell(position);
+ },
+
+ getCellByPosition: function(position, returnDom) {
+ if (position) {
+ var node = this.getNode(position.row),
+ header = this.headerCt.getHeaderAtIndex(position.column);
+
+ if (header && node) {
+ return Ext.fly(node).down(header.getCellSelector(), returnDom);
+ }
+ }
+ return false;
+ },
+
+
+
+ onRowFocus: function(rowIdx, highlight, supressFocus) {
+ var me = this;
+
+ 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,
+ elTop,
+ elBottom,
+ record;
+
+ if (row && el) {
+
+
+ elTop = el.getY();
+ elBottom = elTop + el.dom.clientHeight;
+ rowRegion = Ext.fly(row).getRegion();
+
+ if (rowRegion.top < elTop) {
+ adjustment = rowRegion.top - elTop;
+
+ } else if (rowRegion.bottom > elBottom) {
+ adjustment = rowRegion.bottom - elBottom;
+ }
+ 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;
+
+
+
+ elRegion.bottom = elRegion.top + el.dom.clientHeight;
+ elRegion.right = elRegion.left + el.dom.clientWidth;
+ 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(store, record, operation, changedFieldNames) {
+ var me = this,
+ index,
+ newRow, newAttrs, attLen, i, attName, oldRow, oldRowDom,
+ oldCells, newCells, len, i,
+ columns, overItemCls,
+ isHovered, row,
+
+ isEditing = me.editingPlugin && me.editingPlugin.editing;
+
+ if (me.viewReady) {
+
+ index = me.store.indexOf(record);
+ columns = me.headerCt.getGridColumns();
+ overItemCls = me.overItemCls;
+
+
+
+ if (columns.length && index > -1) {
+ newRow = me.bufferRender([record], index)[0];
+ oldRow = me.all.item(index);
+ if (oldRow) {
+ oldRowDom = oldRow.dom;
+ isHovered = oldRow.hasCls(overItemCls);
+
+
+ if (oldRowDom.mergeAttributes) {
+ oldRowDom.mergeAttributes(newRow, true);
+ } else {
+ newAttrs = newRow.attributes;
+ attLen = newAttrs.length;
+ for (i = 0; i < attLen; i++) {
+ attName = newAttrs[i].name;
+ if (attName !== 'id') {
+ oldRowDom.setAttribute(attName, newAttrs[i].value);
+ }
+ }
+ }
+
+ if (isHovered) {
+ oldRow.addCls(overItemCls);
+ }
+
+
+ oldCells = oldRow.query(me.cellSelector);
+ newCells = Ext.fly(newRow).query(me.cellSelector);
+ len = newCells.length;
+
+ row = oldCells[0].parentNode;
+ for (i = 0; i < len; i++) {
+
+
+ if (me.shouldUpdateCell(columns[i], changedFieldNames)) {
+
+ if (isEditing) {
+ Ext.fly(oldCells[i]).syncContent(newCells[i]);
+ }
+
+ else {
+ row.insertBefore(newCells[i], oldCells[i]);
+ row.removeChild(oldCells[i]);
+ }
+ }
+ }
+ }
+ me.fireEvent('itemupdate', record, index, newRow);
+ }
+ }
+ },
+
+ shouldUpdateCell: function(column, changedFieldNames){
+
+
+ if (column.hasCustomRenderer) {
+ return true;
+ }
+ return !changedFieldNames || Ext.Array.contains(changedFieldNames, column.dataIndex);
+ },
+
+
+ refresh: function() {
+ var me = this;
+ me.setNewTemplate();
+ me.callParent(arguments);
+ me.doStripeRows(0);
+ me.headerCt.setSortState();
+ },
+
+ clearViewEl: function() {
+ this.callParent();
+ delete this.table.dom;
+ },
+
+ 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, record, row);
+
+ if (result === false || me.callParent(arguments) === false) {
+ return false;
+ }
+
+
+ if (type == 'mouseover' || type == 'mouseout') {
+ return true;
+ }
+
+ if(!cell) {
+
+
+ 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) {
+
+
+
+ if (!pos) {
+ return;
+ }
+
+ 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 firstVisibleHeader = this.getHeaderCt().getVisibleGridColumns()[0];
+
+ return firstVisibleHeader ? firstVisibleHeader.getIndex() : -1;
+ },
+
+ getLastVisibleColumnIndex: function() {
+ var visHeaders = this.getHeaderCt().getVisibleGridColumns(),
+ lastHeader = visHeaders[visHeaders.length - 1];
+
+ return lastHeader.getIndex();
+ },
+
+ 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;
+ },
+
+
+ onAdd: function(ds, records, index) {
+ this.callParent(arguments);
+ this.doStripeRows(index);
+ },
+
+
+ onRemove: function(ds, records, index) {
+ this.callParent(arguments);
+ this.doStripeRows(index);
+ },
+
+
+ doStripeRows: function(startRow, endRow) {
+ var me = this,
+ rows,
+ rowsLn,
+ i,
+ row;
+
+
+ if (me.rendered && me.stripeRows) {
+ rows = me.getNodes(startRow, endRow);
+
+ for (i = 0, rowsLn = rows.length; i < rowsLn; i++) {
+ row = rows[i];
+
+ row.className = row.className.replace(me.rowClsRe, ' ');
+ startRow++;
+
+ if (startRow % 2 === 0) {
+ row.className += (' ' + me.altRowCls);
+ }
+ }
+ }
+ }
+
+});
+
+
+Ext.define('Ext.grid.Lockable', {
+
+ requires: [
+ 'Ext.grid.LockingView',
+ 'Ext.view.Table'
+ ],
+
+
+ syncRowHeight: true,
+
+
+
+
+
+
+
+ headerCounter: 0,
+
+
+ scrollDelta: 40,
+
+
+
+
+
+
+
+ unlockText: 'Unlock',
+
+
+ lockText: 'Lock',
+
+
+ determineXTypeToCreate: function() {
+ var me = this,
+ typeToCreate,
+ xtypes, xtypesLn, xtype, superxtype;
+
+ if (me.subGridXType) {
+ typeToCreate = me.subGridXType;
+ } else {
+ xtypes = this.getXTypes().split('/');
+ xtypesLn = xtypes.length;
+ xtype = xtypes[xtypesLn - 1];
+ superxtype = xtypes[xtypesLn - 2];
+
+ if (superxtype !== 'tablepanel') {
+ typeToCreate = superxtype;
+ } else {
+ typeToCreate = xtype;
+ }
+ }
+
+ return typeToCreate;
+ },
+
+
+
+ injectLockable: function() {
+
+ this.lockable = true;
+
+
+ this.hasView = true;
+
+ var me = this,
+
+ scrollLocked = Ext.getScrollbarSize().width === 0,
+ store = me.store = Ext.StoreManager.lookup(me.store),
+
+
+
+ xtype = me.determineXTypeToCreate(),
+
+ selModel = me.getSelectionModel(),
+ lockedFeatures,
+ normalFeatures,
+ lockedPlugins,
+ normalPlugins,
+ lockedGrid,
+ normalGrid,
+ i, len,
+ columns,
+ lockedHeaderCt,
+ normalHeaderCt,
+ lockedView,
+ normalView,
+ listeners;
+
+ lockedFeatures = me.constructFeatures();
+
+
+ me.cloneFeatures();
+ normalFeatures = me.constructFeatures();
+
+ lockedPlugins = me.constructPlugins();
+
+
+ me.clonePlugins();
+ normalPlugins = me.constructPlugins();
+
+
+ delete me.features;
+ delete me.plugins;
+
+
+ for (i = 0, len = (lockedFeatures ? lockedFeatures.length : 0); i < len; i++) {
+ lockedFeatures[i].lockingPartner = normalFeatures[i];
+ normalFeatures[i].lockingPartner = lockedFeatures[i];
+ }
+
+ lockedGrid = Ext.apply({
+ xtype: xtype,
+ store: store,
+ scrollerOwner: false,
+
+ enableAnimations: false,
+ scroll: scrollLocked ? 'vertical' : false,
+ selModel: selModel,
+ border: false,
+ cls: Ext.baseCSSPrefix + 'grid-inner-locked',
+ isLayoutRoot: function() {
+ return false;
+ },
+ features: lockedFeatures,
+ plugins: lockedPlugins
+ }, me.lockedGridConfig);
+
+ normalGrid = Ext.apply({
+ xtype: xtype,
+ store: store,
+ scrollerOwner: false,
+ enableAnimations: false,
+ selModel: selModel,
+ border: false,
+ isLayoutRoot: function() {
+ return false;
+ },
+ features: normalFeatures,
+ plugins: normalPlugins
+ }, me.normalGridConfig);
+
+ me.addCls(Ext.baseCSSPrefix + 'grid-locked');
+
+
+
+
+ Ext.copyTo(normalGrid, me, me.bothCfgCopy);
+ Ext.copyTo(lockedGrid, me, me.bothCfgCopy);
+ Ext.copyTo(normalGrid, me, me.normalCfgCopy);
+ Ext.copyTo(lockedGrid, me, me.lockedCfgCopy);
+ for (i = 0; i < me.normalCfgCopy.length; i++) {
+ delete me[me.normalCfgCopy[i]];
+ }
+ for (i = 0; i < me.lockedCfgCopy.length; i++) {
+ delete me[me.lockedCfgCopy[i]];
+ }
+
+ me.addEvents(
+
+ 'lockcolumn',
+
+
+ 'unlockcolumn'
+ );
+
+ me.addStateEvents(['lockcolumn', 'unlockcolumn']);
+
+ me.lockedHeights = [];
+ me.normalHeights = [];
+
+ columns = me.processColumns(me.columns);
+
+ lockedGrid.width = columns.lockedWidth + Ext.num(selModel.headerWidth, 0);
+ lockedGrid.columns = columns.locked;
+ normalGrid.columns = columns.normal;
+
+
+ normalGrid.flex = 1;
+ lockedGrid.viewConfig = me.lockedViewConfig || {};
+ lockedGrid.viewConfig.loadingUseMsg = false;
+ normalGrid.viewConfig = me.normalViewConfig || {};
+
+ Ext.applyIf(lockedGrid.viewConfig, me.viewConfig);
+ Ext.applyIf(normalGrid.viewConfig, me.viewConfig);
+
+ me.lockedGrid = Ext.ComponentManager.create(lockedGrid);
+ lockedView = me.lockedGrid.getView();
+
+ normalGrid.viewConfig.lockingPartner = lockedView;
+ me.normalGrid = Ext.ComponentManager.create(normalGrid);
+ normalView = me.normalGrid.getView();
+
+ me.view = new Ext.grid.LockingView({
+ locked: me.lockedGrid,
+ normal: me.normalGrid,
+ panel: me
+ });
+
+
+ listeners = {
+ scroll: {
+ fn: me.onLockedViewScroll,
+ element: 'el',
+ scope: me
+ }
+ };
+
+ if (!scrollLocked) {
+ listeners.mousewheel = {
+ fn: me.onLockedViewMouseWheel,
+ element: 'el',
+ scope: me
+ };
+ }
+ if (me.syncRowHeight) {
+ listeners.refresh = me.onLockedViewRefresh;
+ listeners.itemupdate = me.onLockedViewItemUpdate;
+ listeners.scope = me;
+ }
+ lockedView.on(listeners);
+
+
+ listeners = {
+ scroll: {
+ fn: me.onNormalViewScroll,
+ element: 'el',
+ scope: me
+ },
+ refresh: me.syncRowHeight ? me.onNormalViewRefresh : me.updateSpacer,
+ scope: me
+ };
+ normalView.on(listeners);
+
+ lockedHeaderCt = me.lockedGrid.headerCt;
+ normalHeaderCt = me.normalGrid.headerCt;
+
+ lockedHeaderCt.lockedCt = true;
+ lockedHeaderCt.lockableInjected = true;
+ normalHeaderCt.lockableInjected = true;
+
+ lockedHeaderCt.on({
+ columnshow: me.onLockedHeaderShow,
+ columnhide: me.onLockedHeaderHide,
+ columnmove: me.onLockedHeaderMove,
+ sortchange: me.onLockedHeaderSortChange,
+ columnresize: me.onLockedHeaderResize,
+ scope: me
+ });
+
+ normalHeaderCt.on({
+ columnmove: me.onNormalHeaderMove,
+ sortchange: me.onNormalHeaderSortChange,
+ scope: me
+ });
+
+ me.modifyHeaderCt();
+ me.items = [me.lockedGrid, me.normalGrid];
+
+ me.relayHeaderCtEvents(lockedHeaderCt);
+ me.relayHeaderCtEvents(normalHeaderCt);
+
+ me.layout = {
+ type: 'hbox',
+ align: 'stretch'
+ };
+ },
+
+ processColumns: function(columns){
+
+ var i = 0,
+ len = columns.length,
+ lockedWidth = 0,
+ lockedHeaders = [],
+ normalHeaders = [],
+ column;
+
+ for (; i < len; ++i) {
+ column = columns[i];
+
+
+ if (!column.isComponent) {
+ column = Ext.apply({}, columns[i]);
+ }
+
+
+
+ column.processed = true;
+ if (column.locked) {
+ if (!column.hidden) {
+ lockedWidth += column.width || Ext.grid.header.Container.prototype.defaultWidth;
+ }
+ lockedHeaders.push(column);
+ } else {
+ normalHeaders.push(column);
+ }
+ if (!column.headerId) {
+ column.headerId = (column.initialConfig || column).id || ('L' + (++this.headerCounter));
+ }
+ }
+ return {
+ lockedWidth: lockedWidth,
+ locked: {
+ items: lockedHeaders,
+ itemId: 'lockedHeaderCt',
+ stretchMaxPartner: '^^>>#normalHeaderCt'
+ },
+ normal: {
+ items: normalHeaders,
+ itemId: 'normalHeaderCt',
+ stretchMaxPartner: '^^>>#lockedHeaderCt'
+ }
+ };
+ },
+
+
+ onLockedViewMouseWheel: function(e) {
+ var me = this,
+ scrollDelta = -me.scrollDelta,
+ deltaY = scrollDelta * e.getWheelDeltas().y,
+ vertScrollerEl = me.lockedGrid.getView().el.dom,
+ verticalCanScrollDown, verticalCanScrollUp;
+
+ if (vertScrollerEl) {
+ verticalCanScrollDown = vertScrollerEl.scrollTop !== vertScrollerEl.scrollHeight - vertScrollerEl.clientHeight;
+ verticalCanScrollUp = vertScrollerEl.scrollTop !== 0;
+ }
+
+ if ((deltaY < 0 && verticalCanScrollUp) || (deltaY > 0 && verticalCanScrollDown)) {
+ e.stopEvent();
+
+
+
+
+ me.scrolling = true;
+ vertScrollerEl.scrollTop += deltaY;
+ me.normalGrid.getView().el.dom.scrollTop = vertScrollerEl.scrollTop;
+ me.scrolling = false;
+
+
+ me.onNormalViewScroll();
+ }
+ },
+
+ onLockedViewScroll: function() {
+ var me = this,
+ lockedView = me.lockedGrid.getView(),
+ normalView = me.normalGrid.getView(),
+ normalTable,
+ lockedTable;
+
+
+ if (!me.scrolling) {
+ me.scrolling = true;
+ normalView.el.dom.scrollTop = lockedView.el.dom.scrollTop;
+
+
+ if (me.store.buffered) {
+ lockedTable = lockedView.el.child('table', true);
+ normalTable = normalView.el.child('table', true);
+ lockedTable.style.position = 'absolute';
+ }
+ me.scrolling = false;
+ }
+ },
+
+ onNormalViewScroll: function() {
+ var me = this,
+ lockedView = me.lockedGrid.getView(),
+ normalView = me.normalGrid.getView(),
+ normalTable,
+ lockedTable;
+
+
+ if (!me.scrolling) {
+ me.scrolling = true;
+ lockedView.el.dom.scrollTop = normalView.el.dom.scrollTop;
+
+
+ if (me.store.buffered) {
+ lockedTable = lockedView.el.child('table', true);
+ normalTable = normalView.el.child('table', true);
+ lockedTable.style.position = 'absolute';
+ lockedTable.style.top = normalTable.style.top;
+ }
+ me.scrolling = false;
+ }
+ },
+
+
+ onLockedHeaderMove: function() {
+ if (this.syncRowHeight) {
+ this.onNormalViewRefresh();
+ }
+ },
+
+
+ onNormalHeaderMove: function() {
+ if (this.syncRowHeight) {
+ this.onLockedViewRefresh();
+ }
+ },
+
+
+
+
+
+ updateSpacer: function() {
+ var me = this,
+
+
+ lockedViewEl = me.lockedGrid.getView().el,
+ normalViewEl = me.normalGrid.getView().el.dom,
+ spacerId = lockedViewEl.dom.id + '-spacer',
+ spacerHeight = (normalViewEl.offsetHeight - normalViewEl.clientHeight) + 'px';
+
+ me.spacerEl = Ext.getDom(spacerId);
+ if (me.spacerEl) {
+ me.spacerEl.style.height = spacerHeight;
+ } else {
+ Ext.core.DomHelper.append(lockedViewEl, {
+ id: spacerId,
+ style: 'height: ' + spacerHeight
+ });
+ }
+ },
+
+
+ onLockedViewRefresh: function() {
+
+
+ if (this.normalGrid.headerCt.getGridColumns().length) {
+ var me = this,
+ view = me.lockedGrid.getView(),
+ el = view.el,
+ rowEls = el.query(view.getItemSelector()),
+ ln = rowEls.length,
+ i = 0;
+
+
+ me.lockedHeights = [];
+
+ for (; i < ln; i++) {
+ me.lockedHeights[i] = rowEls[i].offsetHeight;
+ }
+ me.syncRowHeights();
+ me.updateSpacer();
+ }
+ },
+
+
+ onNormalViewRefresh: function() {
+
+
+ if (this.lockedGrid.headerCt.getGridColumns().length) {
+ var me = this,
+ view = me.normalGrid.getView(),
+ el = view.el,
+ rowEls = el.query(view.getItemSelector()),
+ ln = rowEls.length,
+ i = 0;
+
+
+ me.normalHeights = [];
+
+ for (; i < ln; i++) {
+ me.normalHeights[i] = rowEls[i].offsetHeight;
+ }
+ me.syncRowHeights();
+ me.updateSpacer();
+ }
+ },
+
+
+ onLockedViewItemUpdate: function(record, index, node) {
+
+
+ if (this.normalGrid.headerCt.getGridColumns().length) {
+ this.lockedHeights[index] = node.offsetHeight;
+ this.syncRowHeights();
+ }
+ },
+
+
+ onNormalViewItemUpdate: function(record, index, node) {
+
+
+ if (this.lockedGrid.headerCt.getGridColumns().length) {
+ this.normalHeights[index] = node.offsetHeight;
+ this.syncRowHeights();
+ }
+ },
+
+
+ syncRowHeights: function() {
+ var me = this,
+ lockedHeights = me.lockedHeights,
+ normalHeights = me.normalHeights,
+ ln = lockedHeights.length,
+ i = 0,
+ lockedView, normalView,
+ lockedRowEls, normalRowEls,
+ scrollTop;
+
+
+
+ if (lockedHeights.length && normalHeights.length) {
+ lockedView = me.lockedGrid.getView();
+ normalView = me.normalGrid.getView();
+ lockedRowEls = lockedView.el.query(lockedView.getItemSelector());
+ normalRowEls = normalView.el.query(normalView.getItemSelector());
+
+
+ for (; i < ln; i++) {
+
+ if (!isNaN(lockedHeights[i]) && !isNaN(normalHeights[i])) {
+ if (lockedHeights[i] > normalHeights[i]) {
+ Ext.fly(normalRowEls[i]).setHeight(lockedHeights[i]);
+ } else if (lockedHeights[i] < normalHeights[i]) {
+ Ext.fly(lockedRowEls[i]).setHeight(normalHeights[i]);
+ }
+ }
+ }
+
+
+ scrollTop = normalView.el.dom.scrollTop;
+ normalView.el.dom.scrollTop = scrollTop;
+ lockedView.el.dom.scrollTop = scrollTop;
+
+
+ me.lockedHeights = [];
+ me.normalHeights = [];
+ }
+ },
+
+
+ modifyHeaderCt: function() {
+ var me = this;
+ me.lockedGrid.headerCt.getMenuItems = me.getMenuItems(me.lockedGrid.headerCt.getMenuItems, true);
+ me.normalGrid.headerCt.getMenuItems = me.getMenuItems(me.normalGrid.headerCt.getMenuItems, false);
+ },
+
+ onUnlockMenuClick: function() {
+ this.unlock();
+ },
+
+ onLockMenuClick: function() {
+ this.lock();
+ },
+
+ getMenuItems: function(getMenuItems, locked) {
+ var me = this,
+ unlockText = me.unlockText,
+ lockText = me.lockText,
+ unlockCls = Ext.baseCSSPrefix + 'hmenu-unlock',
+ lockCls = Ext.baseCSSPrefix + 'hmenu-lock',
+ unlockHandler = Ext.Function.bind(me.onUnlockMenuClick, me),
+ lockHandler = Ext.Function.bind(me.onLockMenuClick, me);
+
+
+ return function() {
+
+
+
+ var o = getMenuItems.call(this);
+ o.push('-', {
+ cls: unlockCls,
+ text: unlockText,
+ handler: unlockHandler,
+ disabled: !locked
+ });
+ o.push({
+ cls: lockCls,
+ text: lockText,
+ handler: lockHandler,
+ disabled: locked
+ });
+ return o;
+ };
+ },
+
+
+
+ lock: function(activeHd, toIdx) {
+ var me = this,
+ normalGrid = me.normalGrid,
+ lockedGrid = me.lockedGrid,
+ normalHCt = normalGrid.headerCt,
+ lockedHCt = lockedGrid.headerCt;
+
+ activeHd = activeHd || normalHCt.getMenu().activeHeader;
+
+
+
+ if (activeHd.flex) {
+ activeHd.width = activeHd.getWidth();
+ delete activeHd.flex;
+ }
+
+ Ext.suspendLayouts();
+ activeHd.ownerCt.remove(activeHd, false);
+ activeHd.locked = true;
+ if (Ext.isDefined(toIdx)) {
+ lockedHCt.insert(toIdx, activeHd);
+ } else {
+ lockedHCt.add(activeHd);
+ }
+ me.syncLockedSection();
+ Ext.resumeLayouts(true);
+ me.updateSpacer();
+
+ me.fireEvent('lockcolumn', me, activeHd);
+ },
+
+ syncLockedSection: function() {
+ var me = this;
+ me.syncLockedWidth();
+ me.lockedGrid.getView().refresh();
+ me.normalGrid.getView().refresh();
+ },
+
+
+
+ syncLockedWidth: function() {
+ var me = this,
+ locked = me.lockedGrid,
+ width = locked.headerCt.getFullWidth(true);
+
+ Ext.suspendLayouts();
+ if (width > 0) {
+ locked.setWidth(width);
+ locked.show();
+ } else {
+ locked.hide();
+ }
+ Ext.resumeLayouts(true);
+
+ return width > 0;
+ },
+
+ onLockedHeaderResize: function() {
+ this.syncLockedWidth();
+ },
+
+ onLockedHeaderHide: function() {
+ this.syncLockedWidth();
+ },
+
+ onLockedHeaderShow: function() {
+ this.syncLockedWidth();
+ },
+
+ onLockedHeaderSortChange: function(headerCt, header, sortState) {
+ if (sortState) {
+
+
+ this.normalGrid.headerCt.clearOtherSortStates(null, true);
+ }
+ },
+
+ onNormalHeaderSortChange: function(headerCt, header, sortState) {
+ if (sortState) {
+
+
+ this.lockedGrid.headerCt.clearOtherSortStates(null, true);
+ }
+ },
+
+
+
+ unlock: function(activeHd, toIdx) {
+ var me = this,
+ normalGrid = me.normalGrid,
+ lockedGrid = me.lockedGrid,
+ normalHCt = normalGrid.headerCt,
+ lockedHCt = lockedGrid.headerCt,
+ refreshLocked = false;
+
+ if (!Ext.isDefined(toIdx)) {
+ toIdx = 0;
+ }
+ activeHd = activeHd || lockedHCt.getMenu().activeHeader;
+
+ Ext.suspendLayouts();
+ activeHd.ownerCt.remove(activeHd, false);
+ if (me.syncLockedWidth()) {
+ refreshLocked = true;
+ }
+ activeHd.locked = false;
+
+
+ normalHCt.insert(toIdx, activeHd);
+ me.normalGrid.getView().refresh();
+
+ if (refreshLocked) {
+ me.lockedGrid.getView().refresh();
+ }
+ Ext.resumeLayouts(true);
+
+ me.fireEvent('unlockcolumn', me, activeHd);
+ },
+
+ applyColumnsState: function (columns) {
+ var me = this,
+ lockedGrid = me.lockedGrid,
+ lockedHeaderCt = lockedGrid.headerCt,
+ normalHeaderCt = me.normalGrid.headerCt,
+ lockedCols = Ext.Array.toMap(lockedHeaderCt.items, 'headerId'),
+ normalCols = Ext.Array.toMap(normalHeaderCt.items, 'headerId'),
+ locked = [],
+ normal = [],
+ lockedWidth = 1,
+ length = columns.length,
+ i, existing,
+ lockedDefault,
+ col;
+
+ for (i = 0; i < length; i++) {
+ col = columns[i];
+
+ lockedDefault = lockedCols[col.id];
+ existing = lockedDefault || normalCols[col.id];
+
+ if (existing) {
+ if (existing.applyColumnState) {
+ existing.applyColumnState(col);
+ }
+ if (existing.locked === undefined) {
+ existing.locked = !!lockedDefault;
+ }
+ if (existing.locked) {
+ locked.push(existing);
+ if (!existing.hidden && typeof existing.width == 'number') {
+ lockedWidth += existing.width;
+ }
+ } else {
+ normal.push(existing);
+ }
+ }
+ }
+
+
+ if (locked.length + normal.length == lockedHeaderCt.items.getCount() + normalHeaderCt.items.getCount()) {
+ lockedHeaderCt.removeAll(false);
+ normalHeaderCt.removeAll(false);
+
+ lockedHeaderCt.add(locked);
+ normalHeaderCt.add(normal);
+
+ lockedGrid.setWidth(lockedWidth);
+ }
+ },
+
+ getColumnsState: function () {
+ var me = this,
+ locked = me.lockedGrid.headerCt.getColumnsState(),
+ normal = me.normalGrid.headerCt.getColumnsState();
+
+ return locked.concat(normal);
+ },
+
+
+ reconfigureLockable: function(store, columns) {
+ var me = this,
+ lockedGrid = me.lockedGrid,
+ normalGrid = me.normalGrid;
+
+ if (columns) {
+ Ext.suspendLayouts();
+ lockedGrid.headerCt.removeAll();
+ normalGrid.headerCt.removeAll();
+
+ columns = me.processColumns(columns);
+ lockedGrid.setWidth(columns.lockedWidth);
+ lockedGrid.headerCt.add(columns.locked.items);
+ normalGrid.headerCt.add(columns.normal.items);
+ Ext.resumeLayouts(true);
+ }
+
+ if (store) {
+ store = Ext.data.StoreManager.lookup(store);
+ me.store = store;
+ lockedGrid.bindStore(store);
+ normalGrid.bindStore(store);
+ } else {
+ lockedGrid.getView().refresh();
+ normalGrid.getView().refresh();
+ }
+ },
+
+
+ cloneFeatures: function() {
+ var me = this,
+ features = me.features,
+ feature,
+ i = 0, len;
+
+ if (features) {
+ len = features.length;
+ for (; i < len; i++) {
+ feature = features[i];
+ if (feature.isFeature) {
+ features[i] = feature.clone();
+ }
+ }
+ }
+ },
+
+
+ clonePlugins: function() {
+ var me = this,
+ plugins = me.plugins,
+ plugin,
+ i = 0, len;
+
+ if (plugins) {
+ len = plugins.length;
+ for (; i < len; i++) {
+ plugin = plugins[i];
+ if (typeof plugin.init === 'function') {
+ plugins[i] = plugin.clone();
+ }
+ }
+ }
+ }
+}, function() {
+ this.borrow(Ext.view.Table, ['constructFeatures']);
+ this.borrow(Ext.AbstractComponent, ['constructPlugins', 'constructPlugin']);
+});
+
+
+Ext.define('Ext.grid.PagingScroller', {
+
+
+ percentageFromEdge: 0.35,
+
+
+ numFromEdge: 2,
+
+
+ trailingBufferZone: 5,
+
+
+ leadingBufferZone: 15,
+
+
+ scrollToLoadBuffer: 200,
+
+
+ viewSize: 0,
+
+ rowHeight: 21,
+
+ tableStart: 0,
+ tableEnd: 0,
+
+ constructor: function(config) {
+ var me = this;
+ me.variableRowHeight = config.variableRowHeight;
+ me.bindView(config.view);
+ Ext.apply(me, config);
+ me.callParent(arguments);
+ },
+
+ bindView: function(view) {
+ var me = this,
+ viewListeners = {
+ scroll: {
+ fn: me.onViewScroll,
+ element: 'el',
+ scope: me
+ },
+ render: me.onViewRender,
+ resize: me.onViewResize,
+ boxready: {
+ fn: me.onViewResize,
+ scope: me,
+ single: true
+ },
+
+
+
+
+ beforerefresh: me.beforeViewRefresh,
+
+ refresh: me.onViewRefresh,
+ scope: me
+ },
+ storeListeners = {
+ guaranteedrange: me.onGuaranteedRange,
+ scope: me
+ },
+ gridListeners = {
+ reconfigure: me.onGridReconfigure,
+ scope: me
+ }, partner;
+
+
+ if (me.view) {
+ if (me.view.el) {
+ me.view.el.un('scroll', me.onViewScroll, me);
+ }
+
+ partner = view.lockingPartner;
+ if (partner) {
+ partner.un('refresh', me.onLockRefresh, me);
+ }
+
+ me.view.un(viewListeners);
+ me.store.un(storeListeners);
+ if (me.grid) {
+ me.grid.un(gridListeners);
+ }
+ delete me.view.refreshSize;
+ }
+
+ me.view = view;
+ me.grid = me.view.up('tablepanel');
+ me.store = view.store;
+ if (view.rendered) {
+ me.viewSize = me.store.viewSize = Math.ceil(view.getHeight() / me.rowHeight) + me.trailingBufferZone + (me.numFromEdge * 2) + me.leadingBufferZone;
+ }
+
+ partner = view.lockingPartner;
+ if (partner) {
+ partner.on('refresh', me.onLockRefresh, me);
+ }
+
+ me.view.mon(me.store.pageMap, {
+ scope: me,
+ clear: me.onCacheClear
+ });
+
+
+
+
+ me.view.refreshSize = Ext.Function.createInterceptor(me.view.refreshSize, me.beforeViewrefreshSize, me);
+
+
+ me.position = 0;
+
+
+ if (me.grid) {
+ me.grid.on(gridListeners);
+ } else {
+ me.view.on({
+ added: function() {
+ me.grid = me.view.up('tablepanel');
+ me.grid.on(gridListeners);
+ },
+ single: true
+ });
+ }
+
+ me.view.on(me.viewListeners = viewListeners);
+ me.store.on(storeListeners);
+ },
+
+ onCacheClear: function() {
+ var me = this;
+
+
+ if (me.view.rendered && !me.store.isDestroyed) {
+
+
+ me.ignoreNextScrollEvent = me.view.el.dom.scrollTop !== 0;
+
+ me.view.el.dom.scrollTop = 0;
+ delete me.lastScrollDirection;
+ delete me.scrollOffset;
+ delete me.scrollProportion;
+ }
+ },
+
+ onGridReconfigure: function (grid) {
+ this.bindView(grid.view);
+ },
+
+
+ onViewRender: function() {
+ var me = this,
+ view = me.view,
+ el = me.view.el,
+ stretcher;
+
+ me.stretcher = me.createStretcher(view);
+
+ view = view.lockingPartner;
+ if (view) {
+ stretcher = me.stretcher;
+ me.stretcher = new Ext.CompositeElement(stretcher);
+ me.stretcher.add(me.createStretcher(view));
+ }
+ },
+
+ createStretcher: function(view) {
+ var el = view.el;
+ el.setStyle('position', 'relative');
+
+ return el.createChild({
+ style:{
+ position: 'absolute',
+ width: '1px',
+ height: 0,
+ top: 0,
+ left: 0
+ }
+ }, el.dom.firstChild);
+ },
+
+ onViewResize: function(view, width, height) {
+ var me = this,
+ newViewSize;
+
+ newViewSize = Math.ceil(height / me.rowHeight) + me.trailingBufferZone + (me.numFromEdge * 2) + me.leadingBufferZone;
+ if (newViewSize > me.viewSize) {
+ me.viewSize = me.store.viewSize = newViewSize;
+ me.handleViewScroll(me.lastScrollDirection || 1);
+ }
+ },
+
+
+ beforeViewRefresh: function() {
+ var me = this,
+ view = me.view,
+ rows,
+ direction;
+
+
+ me.focusOnRefresh = Ext.Element.getActiveElement === view.el.dom;
+
+
+ if (me.variableRowHeight) {
+ direction = me.lastScrollDirection;
+ me.commonRecordIndex = undefined;
+
+
+
+
+ if (direction && (me.previousStart !== undefined) && (me.scrollProportion === undefined) && (rows = view.getNodes()).length) {
+
+
+ if (direction === 1) {
+
+
+ if (me.tableStart <= me.previousEnd) {
+ me.commonRecordIndex = rows.length - 1;
+
+ }
+ }
+
+ else if (direction === -1) {
+
+
+ if (me.tableEnd >= me.previousStart) {
+ me.commonRecordIndex = 0;
+ }
+ }
+
+ me.scrollOffset = -view.el.getOffsetsTo(rows[me.commonRecordIndex])[1];
+
+
+ me.commonRecordIndex -= (me.tableStart - me.previousStart);
+ } else {
+ me.scrollOffset = undefined;
+ }
+ }
+ },
+
+ onLockRefresh: function(view) {
+ view.table.dom.style.position = 'absolute';
+ },
+
+
+
+ onViewRefresh: function() {
+ var me = this,
+ store = me.store,
+ newScrollHeight,
+ view = me.view,
+ viewEl = view.el,
+ viewDom = viewEl.dom,
+ rows,
+ newScrollOffset,
+ scrollDelta,
+ table = view.table.dom,
+ tableTop,
+ scrollTop;
+
+
+ if (me.focusOnRefresh) {
+ viewEl.focus();
+ me.focusOnRefresh = false;
+ }
+
+
+ me.disabled = true;
+
+
+
+
+
+
+ if (store.getCount() === store.getTotalCount() || (store.isFiltered() && !store.remoteFilter)) {
+ me.stretcher.setHeight(0);
+ me.position = viewDom.scrollTop = 0;
+
+
+
+ me.setTablePosition('absolute');
+
+
+ return;
+ }
+
+ me.stretcher.setHeight(newScrollHeight = me.getScrollHeight());
+
+ scrollTop = viewDom.scrollTop;
+
+
+ me.isScrollRefresh = (scrollTop > 0);
+
+
+
+ if (me.scrollProportion !== undefined) {
+ me.setTablePosition('absolute');
+ me.setTableTop((me.scrollProportion ? (newScrollHeight * me.scrollProportion) - (table.offsetHeight * me.scrollProportion) : 0) + 'px');
+ } else {
+ me.setTablePosition('absolute');
+ me.setTableTop((tableTop = (me.tableStart||0) * me.rowHeight) + 'px');
+
+
+ if (me.scrollOffset) {
+ rows = view.getNodes();
+ newScrollOffset = -viewEl.getOffsetsTo(rows[me.commonRecordIndex])[1];
+ scrollDelta = newScrollOffset - me.scrollOffset;
+ me.position = (viewDom.scrollTop += scrollDelta);
+ }
+
+
+
+
+
+
+
+ else if ((tableTop > scrollTop) || ((tableTop + table.offsetHeight) < scrollTop + viewDom.clientHeight)) {
+ me.lastScrollDirection = -1;
+ me.position = viewDom.scrollTop = tableTop;
+ }
+ }
+
+
+ me.disabled = false;
+ },
+
+ setTablePosition: function(position) {
+ this.setViewTableStyle(this.view, 'position', position);
+ },
+
+ setTableTop: function(top){
+ this.setViewTableStyle(this.view, 'top', top);
+ },
+
+ setViewTableStyle: function(view, prop, value) {
+ view.el.child('table', true).style[prop] = value;
+ view = view.lockingPartner;
+
+ if (view) {
+ view.el.child('table', true).style[prop] = value;
+ }
+ },
+
+ beforeViewrefreshSize: function() {
+
+ if (this.isScrollRefresh) {
+
+ this.view.table.attach(this.view.el.child('table', true));
+ return (this.isScrollRefresh = false);
+ }
+ },
+
+ onGuaranteedRange: function(range, start, end) {
+ var me = this,
+ ds = me.store;
+
+
+ if (range.length && me.visibleStart < range[0].index) {
+ return;
+ }
+
+
+
+ me.previousStart = me.tableStart;
+ me.previousEnd = me.tableEnd;
+
+ me.tableStart = start;
+ me.tableEnd = end;
+ ds.loadRecords(range, {
+ start: start
+ });
+ },
+
+ onViewScroll: function(e, t) {
+ var me = this,
+ view = me.view,
+ lastPosition = me.position;
+
+ me.position = view.el.dom.scrollTop;
+
+
+
+ if (me.ignoreNextScrollEvent) {
+ me.ignoreNextScrollEvent = false;
+ return;
+ }
+
+
+
+ if (!me.disabled) {
+ me.lastScrollDirection = me.position > lastPosition ? 1 : -1;
+
+ if (lastPosition !== me.position) {
+ me.handleViewScroll(me.lastScrollDirection);
+ }
+ }
+ },
+
+ handleViewScroll: function(direction) {
+ var me = this,
+ store = me.store,
+ view = me.view,
+ viewSize = me.viewSize,
+ totalCount = store.getTotalCount(),
+ highestStartPoint = totalCount - viewSize,
+ visibleStart = me.getFirstVisibleRowIndex(),
+ visibleEnd = me.getLastVisibleRowIndex(),
+ el = view.el.dom,
+ requestStart,
+ requestEnd;
+
+
+ if (totalCount >= viewSize) {
+
+
+
+
+
+ me.scrollProportion = undefined;
+
+
+ if (direction == -1) {
+
+
+ if (me.tableStart) {
+ if (visibleStart !== undefined) {
+ if (visibleStart < (me.tableStart + me.numFromEdge)) {
+ requestStart = Math.max(0, visibleEnd + me.trailingBufferZone - viewSize);
+ }
+ }
+
+
+
+ else {
+
+ me.scrollProportion = el.scrollTop / (el.scrollHeight - el.clientHeight);
+ requestStart = Math.max(0, totalCount * me.scrollProportion - (viewSize / 2) - me.numFromEdge - ((me.leadingBufferZone + me.trailingBufferZone) / 2));
+ }
+ }
+ }
+
+ else {
+ if (visibleStart !== undefined) {
+ if (visibleEnd > (me.tableEnd - me.numFromEdge)) {
+ requestStart = Math.max(0, visibleStart - me.trailingBufferZone);
+ }
+ }
+
+
+
+ else {
+
+ me.scrollProportion = el.scrollTop / (el.scrollHeight - el.clientHeight);
+ requestStart = totalCount * me.scrollProportion - (viewSize / 2) - me.numFromEdge - ((me.leadingBufferZone + me.trailingBufferZone) / 2);
+ }
+ }
+
+
+ if (requestStart !== undefined) {
+
+ if (requestStart > highestStartPoint) {
+ requestStart = highestStartPoint & ~1;
+ requestEnd = totalCount - 1;
+ }
+
+ else {
+ requestStart = requestStart & ~1;
+ requestEnd = requestStart + viewSize - 1;
+ }
+
+
+ if (store.rangeCached(requestStart, requestEnd)) {
+ me.cancelLoad();
+ store.guaranteeRange(requestStart, requestEnd);
+ }
+
+
+
+ else {
+ me.attemptLoad(requestStart, requestEnd);
+ }
+ }
+ }
+ },
+
+ getFirstVisibleRowIndex: function() {
+ var me = this,
+ view = me.view,
+ scrollTop = view.el.dom.scrollTop,
+ rows,
+ count,
+ i,
+ rowBottom;
+
+ if (me.variableRowHeight) {
+ rows = view.getNodes();
+ count = rows.length;
+ if (!count) {
+ return;
+ }
+ rowBottom = Ext.fly(rows[0]).getOffsetsTo(view.el)[1];
+ for (i = 0; i < count; i++) {
+ rowBottom += rows[i].offsetHeight;
+
+
+ if (rowBottom > view.el.dom.clientHeight) {
+ return;
+ }
+
+
+
+ if (rowBottom > 0) {
+ return view.getRecord(rows[i]).index;
+ }
+ }
+ } else {
+ return Math.floor(scrollTop / me.rowHeight);
+ }
+ },
+
+ getLastVisibleRowIndex: function() {
+ var me = this,
+ store = me.store,
+ view = me.view,
+ clientHeight = view.el.dom.clientHeight,
+ rows,
+ count,
+ i,
+ rowTop;
+
+ if (me.variableRowHeight) {
+ rows = view.getNodes();
+ if (!rows.length) {
+ return;
+ }
+ count = store.getCount() - 1;
+ rowTop = Ext.fly(rows[count]).getOffsetsTo(view.el)[1] + rows[count].offsetHeight;
+ for (i = count; i >= 0; i--) {
+ rowTop -= rows[i].offsetHeight;
+
+
+ if (rowTop < 0) {
+ return;
+ }
+
+
+
+ if (rowTop < clientHeight) {
+ return view.getRecord(rows[i]).index;
+ }
+ }
+ } else {
+ return me.getFirstVisibleRowIndex() + Math.ceil(clientHeight / me.rowHeight) + 1;
+ }
+ },
+
+ getScrollHeight: function() {
+ var me = this,
+ view = me.view,
+ table,
+ firstRow,
+ store = me.store,
+ deltaHeight = 0,
+ doCalcHeight = !me.hasOwnProperty('rowHeight');
+
+ if (me.variableRowHeight) {
+ table = me.view.table.dom;
+ if (doCalcHeight) {
+ me.initialTableHeight = table.offsetHeight;
+ me.rowHeight = me.initialTableHeight / me.store.getCount();
+ } else {
+ deltaHeight = table.offsetHeight - me.initialTableHeight;
+
+
+ if (store.getCount() > me.viewSize) {
+ deltaHeight -= me.rowHeight;
+ }
+ }
+ } else if (doCalcHeight) {
+ firstRow = view.el.down(view.getItemSelector());
+ if (firstRow) {
+ me.rowHeight = firstRow.getHeight(false, true);
+ }
+ }
+
+ return Math.floor(store.getTotalCount() * me.rowHeight) + deltaHeight;
+ },
+
+ attemptLoad: function(start, end) {
+ var me = this;
+ if (me.scrollToLoadBuffer) {
+ if (!me.loadTask) {
+ me.loadTask = new Ext.util.DelayedTask(me.doAttemptLoad, me, []);
+ }
+ me.loadTask.delay(me.scrollToLoadBuffer, me.doAttemptLoad, me, [start, end]);
+ } else {
+ me.store.guaranteeRange(start, end);
+ }
+ },
+
+ cancelLoad: function() {
+ if (this.loadTask) {
+ this.loadTask.cancel();
+ }
+ },
+
+ doAttemptLoad: function(start, end) {
+ this.store.guaranteeRange(start, end);
+ },
+
+ destroy: function() {
+ var me = this,
+ scrollListener = me.viewListeners.scroll;
+
+ me.store.un({
+ guaranteedrange: me.onGuaranteedRange,
+ scope: me
+ });
+ me.view.un(me.viewListeners);
+ if (me.view.rendered) {
+ me.stretcher.remove();
+ me.view.el.un('scroll', scrollListener.fn, scrollListener.scope);
+ }
+ }
+});
+
+
+Ext.define('Ext.layout.container.Fit', {
+
+
+ extend: 'Ext.layout.container.Container',
+ alternateClassName: 'Ext.layout.FitLayout',
+
+ alias: 'layout.fit',
+
+
+
+ itemCls: Ext.baseCSSPrefix + 'fit-item',
+ targetCls: Ext.baseCSSPrefix + 'layout-fit',
+ type: 'fit',
+
+
+ defaultMargins: {
+ top: 0,
+ right: 0,
+ bottom: 0,
+ left: 0
+ },
+
+ manageMargins: true,
+
+ sizePolicies: {
+ 0: { setsWidth: 0, setsHeight: 0 },
+ 1: { setsWidth: 1, setsHeight: 0 },
+ 2: { setsWidth: 0, setsHeight: 1 },
+ 3: { setsWidth: 1, setsHeight: 1 }
+ },
+
+ getItemSizePolicy: function (item, ownerSizeModel) {
+
+ var sizeModel = ownerSizeModel || this.owner.getSizeModel(),
+ mode = (sizeModel.width.shrinkWrap ? 0 : 1) |
+ (sizeModel.height.shrinkWrap ? 0 : 2);
+
+ return this.sizePolicies[mode];
+ },
+
+ beginLayoutCycle: function (ownerContext, firstCycle) {
+ var me = this,
+
+ resetHeight = me.lastHeightModel && me.lastHeightModel.calculated,
+ resetWidth = me.lastWidthModel && me.lastWidthModel.calculated,
+ resetSizes = resetWidth || resetHeight,
+ maxChildMinHeight = 0, maxChildMinWidth = 0,
+ c, childItems, i, item, length, margins, minHeight, minWidth, style, undef;
+
+ me.callParent(arguments);
+
+
+
+
+
+ if (resetSizes && ownerContext.targetContext.el.dom.tagName.toUpperCase() != 'TD') {
+ resetSizes = resetWidth = resetHeight = false;
+ }
+
+ childItems = ownerContext.childItems;
+ length = childItems.length;
+
+ for (i = 0; i < length; ++i) {
+ item = childItems[i];
+
+
+
+
+ if (firstCycle) {
+ c = item.target;
+ minHeight = c.minHeight;
+ minWidth = c.minWidth;
+
+ if (minWidth || minHeight) {
+ margins = item.marginInfo || item.getMarginInfo();
+
+
+ minHeight += margins.height;
+ minWidth += margins.height;
+
+
+
+ if (maxChildMinHeight < minHeight) {
+ maxChildMinHeight = minHeight;
+ }
+ if (maxChildMinWidth < minWidth) {
+ maxChildMinWidth = minWidth;
+ }
+ }
+ }
+
+ if (resetSizes) {
+ style = item.el.dom.style;
+
+ if (resetHeight) {
+ style.height = '';
+ }
+ if (resetWidth) {
+ style.width = '';
+ }
+ }
+ }
+
+ if (firstCycle) {
+ ownerContext.maxChildMinHeight = maxChildMinHeight;
+ ownerContext.maxChildMinWidth = maxChildMinWidth;
+ }
+
+
+
+
+ c = ownerContext.target;
+ ownerContext.overflowX = (!ownerContext.widthModel.shrinkWrap &&
+ ownerContext.maxChildMinWidth &&
+ (c.autoScroll || c.overflowX)) || undef;
+
+ ownerContext.overflowY = (!ownerContext.heightModel.shrinkWrap &&
+ ownerContext.maxChildMinHeight &&
+ (c.autoScroll || c.overflowY)) || undef;
+ },
+
+ calculate : function (ownerContext) {
+ var me = this,
+ childItems = ownerContext.childItems,
+ length = childItems.length,
+ containerSize = me.getContainerSize(ownerContext),
+ info = {
+ length: length,
+ ownerContext: ownerContext,
+ targetSize: containerSize
+ },
+ shrinkWrapWidth = ownerContext.widthModel.shrinkWrap,
+ shrinkWrapHeight = ownerContext.heightModel.shrinkWrap,
+ overflowX = ownerContext.overflowX,
+ overflowY = ownerContext.overflowY,
+ scrollbars, scrollbarSize, padding, i, contentWidth, contentHeight;
+
+ if (overflowX || overflowY) {
+
+
+
+ scrollbars = me.getScrollbarsNeeded(
+ overflowX && containerSize.width, overflowY && containerSize.height,
+ ownerContext.maxChildMinWidth, ownerContext.maxChildMinHeight);
+
+ if (scrollbars) {
+ scrollbarSize = Ext.getScrollbarSize();
+ if (scrollbars & 1) {
+ containerSize.height -= scrollbarSize.height;
+ }
+ if (scrollbars & 2) {
+ containerSize.width -= scrollbarSize.width;
+ }
+ }
+ }
+
+
+ for (i = 0; i < length; ++i) {
+ info.index = i;
+ me.fitItem(childItems[i], info);
+ }
+
+ if (shrinkWrapHeight || shrinkWrapWidth) {
+ padding = ownerContext.targetContext.getPaddingInfo();
+
+ if (shrinkWrapWidth) {
+ if (overflowY && !containerSize.gotHeight) {
+
+
+
+ me.done = false;
+ } else {
+ contentWidth = info.contentWidth + padding.width;
+
+
+
+ if (scrollbars & 2) {
+ contentWidth += scrollbarSize.width;
+ }
+ if (!ownerContext.setContentWidth(contentWidth)) {
+ me.done = false;
+ }
+ }
+ }
+
+ if (shrinkWrapHeight) {
+ if (overflowX && !containerSize.gotWidth) {
+
+
+
+ me.done = false;
+ } else {
+ contentHeight = info.contentHeight + padding.height;
+
+
+
+ if (scrollbars & 1) {
+ contentHeight += scrollbarSize.height;
+ }
+ if (!ownerContext.setContentHeight(contentHeight)) {
+ me.done = false;
+ }
+ }
+ }
+ }
+ },
+
+ fitItem: function (itemContext, info) {
+ var me = this;
+
+ if (itemContext.invalid) {
+ me.done = false;
+ return;
+ }
+
+ info.margins = itemContext.getMarginInfo();
+ info.needed = info.got = 0;
+
+ me.fitItemWidth(itemContext, info);
+ me.fitItemHeight(itemContext, info);
+
+
+ if (info.got != info.needed) {
+ me.done = false;
+ }
+ },
+
+ fitItemWidth: function (itemContext, info) {
+ var contentWidth, width;
+
+ if (info.ownerContext.widthModel.shrinkWrap) {
+
+ width = itemContext.getProp('width') + info.margins.width;
+
+
+ contentWidth = info.contentWidth;
+ if (contentWidth === undefined) {
+ info.contentWidth = width;
+ } else {
+ info.contentWidth = Math.max(contentWidth, width);
+ }
+ } else if (itemContext.widthModel.calculated) {
+ ++info.needed;
+ if (info.targetSize.gotWidth) {
+ ++info.got;
+ this.setItemWidth(itemContext, info);
+ }
+ }
+
+ this.positionItemX(itemContext, info);
+ },
+
+ fitItemHeight: function (itemContext, info) {
+ var contentHeight, height;
+ if (info.ownerContext.heightModel.shrinkWrap) {
+
+ height = itemContext.getProp('height') + info.margins.height;
+
+
+ contentHeight = info.contentHeight;
+ if (contentHeight === undefined) {
+ info.contentHeight = height;
+ } else {
+ info.contentHeight = Math.max(contentHeight, height);
+ }
+ } else if (itemContext.heightModel.calculated) {
+ ++info.needed;
+ if (info.targetSize.gotHeight) {
+ ++info.got;
+ this.setItemHeight(itemContext, info);
+ }
+ }
+
+ this.positionItemY(itemContext, info);
+ },
+
+ positionItemX: function (itemContext, info) {
+ var margins = info.margins;
+
+
+
+ if (info.index || margins.left) {
+ itemContext.setProp('x', margins.left);
+ }
+
+ if (margins.width) {
+
+ itemContext.setProp('margin-right', margins.width);
+ }
+ },
+
+ positionItemY: function (itemContext, info) {
+ var margins = info.margins;
+
+ if (info.index || margins.top) {
+ itemContext.setProp('y', margins.top);
+ }
+
+ if (margins.height) {
+
+ itemContext.setProp('margin-bottom', margins.height);
+ }
+ },
+
+ setItemHeight: function (itemContext, info) {
+ itemContext.setHeight(info.targetSize.height - info.margins.height);
+ },
+
+ setItemWidth: function (itemContext, info) {
+ itemContext.setWidth(info.targetSize.width - info.margins.width);
+ }
+});
+
+
+Ext.define('Ext.panel.Table', {
+ extend: 'Ext.panel.Panel',
+
+ alias: 'widget.tablepanel',
+
+ uses: [
+ 'Ext.selection.RowModel',
+ 'Ext.selection.CellModel',
+ 'Ext.selection.CheckboxModel',
+ 'Ext.grid.PagingScroller',
+ 'Ext.grid.header.Container',
+ 'Ext.grid.Lockable'
+ ],
+
+ extraBaseCls: Ext.baseCSSPrefix + 'grid',
+ extraBodyCls: Ext.baseCSSPrefix + 'grid-body',
+
+ layout: 'fit',
+
+ hasView: false,
+
+
+
+ viewType: null,
+
+
+
+
+
+
+ selType: 'rowmodel',
+
+
+
+
+
+
+
+
+
+
+ scroll: true,
+
+
+
+
+
+
+
+
+
+
+
+
+
+ deferRowRender: true,
+
+
+ sortableColumns: true,
+
+
+ enableLocking: false,
+
+
+
+ scrollerOwner: true,
+
+
+ enableColumnMove: true,
+
+
+ sealedColumns: false,
+
+
+ enableColumnResize: true,
+
+
+ enableColumnHide: true,
+
+
+
+
+ rowLines: true,
+
+
+
+
+
+
+
+
+
+ initComponent: function() {
+
+ var me = this,
+ scroll = me.scroll,
+ vertical = false,
+ horizontal = false,
+ headerCtCfg = me.columns || me.colModel,
+ view,
+ border = me.border,
+ i, len;
+
+ if (me.columnLines) {
+ me.addCls(Ext.baseCSSPrefix + 'grid-with-col-lines');
+ }
+
+ if (me.rowLines) {
+ me.addCls(Ext.baseCSSPrefix + 'grid-with-row-lines');
+ }
+
+
+ me.store = Ext.data.StoreManager.lookup(me.store || 'ext-empty-store');
+
+
+
+
+ if (headerCtCfg instanceof Ext.grid.header.Container) {
+ me.headerCt = headerCtCfg;
+ me.headerCt.border = border;
+ me.columns = me.headerCt.items.items;
+ } else {
+ if (Ext.isArray(headerCtCfg)) {
+ headerCtCfg = {
+ items: headerCtCfg,
+ border: border
+ };
+ }
+ Ext.apply(headerCtCfg, {
+ forceFit: me.forceFit,
+ sortable: me.sortableColumns,
+ enableColumnMove: me.enableColumnMove,
+ enableColumnResize: me.enableColumnResize,
+ enableColumnHide: me.enableColumnHide,
+ border: border,
+ sealed: me.sealedColumns
+ });
+ me.columns = headerCtCfg.items;
+
+
+
+ if (me.enableLocking || Ext.ComponentQuery.query('{locked !== undefined}{processed != true}', me.columns).length) {
+ me.self.mixin('lockable', Ext.grid.Lockable);
+ me.injectLockable();
+ }
+ }
+
+ me.scrollTask = new Ext.util.DelayedTask(me.syncHorizontalScroll, me);
+
+ me.addEvents(
+
+ 'reconfigure',
+
+ 'viewready'
+ );
+
+ me.bodyCls = me.bodyCls || '';
+ me.bodyCls += (' ' + me.extraBodyCls);
+
+ me.cls = me.cls || '';
+ me.cls += (' ' + me.extraBaseCls);
+
+
+ delete me.autoScroll;
+
+
+
+ if (!me.hasView) {
+
+
+
+ if (!me.headerCt) {
+ me.headerCt = new Ext.grid.header.Container(headerCtCfg);
+ }
+
+
+ me.columns = me.headerCt.items.items;
+
+
+ if (me.store.buffered && !me.store.remoteSort) {
+ for (i = 0, len = me.columns.length; i < len; i++) {
+ me.columns[i].sortable = false;
+ }
+ }
+
+ if (me.hideHeaders) {
+ me.headerCt.height = 0;
+ me.headerCt.addCls(Ext.baseCSSPrefix + 'grid-header-ct-hidden');
+ me.addCls(Ext.baseCSSPrefix + 'grid-header-hidden');
+
+
+ if (Ext.isIEQuirks) {
+ me.headerCt.style = {
+ display: 'none'
+ };
+ }
+ }
+
+
+ if (scroll === true || scroll === 'both') {
+ vertical = horizontal = true;
+ } else if (scroll === 'horizontal') {
+ horizontal = true;
+ } else if (scroll === 'vertical') {
+ vertical = true;
+ }
+
+ me.relayHeaderCtEvents(me.headerCt);
+ me.features = me.features || [];
+ if (!Ext.isArray(me.features)) {
+ me.features = [me.features];
+ }
+ me.dockedItems = [].concat(me.dockedItems || []);
+ me.dockedItems.unshift(me.headerCt);
+ me.viewConfig = me.viewConfig || {};
+
+
+ if (me.store && me.store.buffered) {
+ me.viewConfig.preserveScrollOnRefresh = true;
+ } else if (me.invalidateScrollerOnRefresh !== undefined) {
+ me.viewConfig.preserveScrollOnRefresh = !me.invalidateScrollerOnRefresh;
+ }
+
+
+
+ view = me.getView();
+
+ me.items = [view];
+ me.hasView = true;
+
+ if (vertical) {
+
+
+ if (me.store.buffered) {
+ me.verticalScroller = new Ext.grid.PagingScroller(Ext.apply({
+ panel: me,
+ store: me.store,
+ view: me.view
+ }, me.verticalScroller));
+ }
+ }
+
+ if (horizontal) {
+
+
+ if (!me.hideHeaders) {
+ view.on({
+ scroll: {
+ fn: me.onHorizontalScroll,
+ element: 'el',
+ scope: me
+ }
+ });
+ }
+ }
+
+ me.mon(view.store, {
+ load: me.onStoreLoad,
+ scope: me
+ });
+ me.mon(view, {
+ viewready: me.onViewReady,
+ refresh: me.onRestoreHorzScroll,
+ scope: me
+ });
+ }
+
+
+ this.relayEvents(me.view, [
+
+ 'beforeitemmousedown',
+
+ 'beforeitemmouseup',
+
+ 'beforeitemmouseenter',
+
+ 'beforeitemmouseleave',
+
+ 'beforeitemclick',
+
+ 'beforeitemdblclick',
+
+ 'beforeitemcontextmenu',
+
+ 'itemmousedown',
+
+ 'itemmouseup',
+
+ 'itemmouseenter',
+
+ 'itemmouseleave',
+
+ 'itemclick',
+
+ 'itemdblclick',
+
+ 'itemcontextmenu',
+
+ 'beforecontainermousedown',
+
+ 'beforecontainermouseup',
+
+ 'beforecontainermouseover',
+
+ 'beforecontainermouseout',
+
+ 'beforecontainerclick',
+
+ 'beforecontainerdblclick',
+
+ 'beforecontainercontextmenu',
+
+ 'containermouseup',
+
+ 'containermouseover',
+
+ 'containermouseout',
+
+ 'containerclick',
+
+ 'containerdblclick',
+
+ 'containercontextmenu',
+
+ 'selectionchange',
+
+ 'beforeselect',
+
+ 'select',
+
+ 'beforedeselect',
+
+ 'deselect'
+ ]);
+
+ me.callParent(arguments);
+ me.addStateEvents(['columnresize', 'columnmove', 'columnhide', 'columnshow', 'sortchange']);
+
+ if (me.headerCt) {
+ me.headerCt.on('afterlayout', me.onRestoreHorzScroll, me);
+ }
+ },
+
+ relayHeaderCtEvents: function (headerCt) {
+ this.relayEvents(headerCt, [
+
+ 'columnresize',
+
+ 'columnmove',
+
+ 'columnhide',
+
+ 'columnshow',
+
+ 'sortchange'
+ ]);
+ },
+
+ getState: function(){
+ var me = this,
+ state = me.callParent(),
+ sorter = me.store.sorters.first();
+
+ state = me.addPropertyToState(state, 'columns', (me.headerCt || me).getColumnsState());
+
+ if (sorter) {
+ state = me.addPropertyToState(state, 'sort', {
+ property: sorter.property,
+ direction: sorter.direction,
+ root: sorter.root
+ });
+ }
+ return state;
+ },
+
+ applyState: function(state) {
+ var me = this,
+ sorter = state.sort,
+ store = me.store,
+ columns = state.columns;
+
+ delete state.columns;
+
+
+
+ me.callParent(arguments);
+
+ if (columns) {
+ (me.headerCt || me).applyColumnsState(columns);
+ }
+
+ if (sorter) {
+ if (store.remoteSort) {
+
+ store.sort({
+ property: sorter.property,
+ direction: sorter.direction,
+ root: sorter.root
+ }, null, false);
+ } else {
+ store.sort(sorter.property, sorter.direction);
+ }
+ }
+ },
+
+
+ getStore: function(){
+ return this.store;
+ },
+
+
+ getView: function() {
+ var me = this,
+ sm;
+
+ if (!me.view) {
+ sm = me.getSelectionModel();
+ me.view = Ext.widget(Ext.apply({}, me.viewConfig, {
+
+
+ grid: me,
+ deferInitialRefresh: me.deferRowRender !== false,
+ scroll: me.scroll,
+ xtype: me.viewType,
+ store: me.store,
+ headerCt: me.headerCt,
+ selModel: sm,
+ features: me.features,
+ panel: me,
+ emptyText : me.emptyText ? '
' : '', + errors = [], + fields = me.query('>[isFormField]'), + length = fields.length, + i; + + function createListItem(e) { + return '' + e + ' ';
+ }
+
+ for (i = 0; i < length; i++) {
+ errors = errors.concat(
+ Ext.Array.map(fields[i].getErrors(), createListItem)
+ );
+ }
+
+ return dirtyText + ' +
+ ')
';
+ }
+ return v;
+ },
+
+
+ enableAction: function(index, silent) {
+ var me = this;
+
+ if (!index) {
+ index = 0;
+ } else if (!Ext.isNumber(index)) {
+ index = Ext.Array.indexOf(me.items, index);
+ }
+ me.items[index].disabled = false;
+ me.up('tablepanel').el.select('.' + Ext.baseCSSPrefix + 'action-col-' + index).removeCls(me.disabledCls);
+ if (!silent) {
+ me.fireEvent('enable', me);
+ }
+ },
+
+
+ disableAction: function(index, silent) {
+ var me = this;
+
+ if (!index) {
+ index = 0;
+ } else if (!Ext.isNumber(index)) {
+ index = Ext.Array.indexOf(me.items, index);
+ }
+ me.items[index].disabled = true;
+ me.up('tablepanel').el.select('.' + Ext.baseCSSPrefix + 'action-col-' + index).addCls(me.disabledCls);
+ if (!silent) {
+ me.fireEvent('disable', me);
+ }
+ },
+
+ destroy: function() {
+ delete this.items;
+ delete this.renderer;
+ return this.callParent(arguments);
+ },
+
+
+ processEvent : function(type, view, cell, recordIndex, cellIndex, e, record, row){
+ var me = this,
+ target = e.getTarget(),
+ match,
+ item, fn,
+ key = type == 'keydown' && e.getKey();
+
+
+
+
+ if (key && !Ext.fly(target).findParent(view.cellSelector)) {
+ target = Ext.fly(cell).down('.' + Ext.baseCSSPrefix + 'action-col-icon', true);
+ }
+
+
+ if (target && (match = target.className.match(me.actionIdRe))) {
+ item = me.items[parseInt(match[1], 10)];
+ if (item) {
+ if (type == 'click' || (key == e.ENTER || key == e.SPACE)) {
+ fn = item.handler || me.handler;
+ if (fn && !item.disabled) {
+ fn.call(item.scope || me.origScope || me, view, recordIndex, cellIndex, item, e, record, row);
+ }
+ } else if (type == 'mousedown' && item.stopSelection !== false) {
+ return false;
+ }
+ }
+ }
+ return me.callParent(arguments);
+ },
+
+ cascade: function(fn, scope) {
+ fn.call(scope||this, this);
+ },
+
+
+ getRefItems: function() {
+ return [];
+ }
+});
+
+
+Ext.define('Ext.grid.column.Boolean', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.booleancolumn'],
+ alternateClassName: 'Ext.grid.BooleanColumn',
+
+
+
+ trueText: 'true',
+
+
+
+
+ falseText: 'false',
+
+
+
+ undefinedText: ' ',
+
+
+
+
+ defaultRenderer: function(value){
+ if (value === undefined) {
+ return this.undefinedText;
+ }
+
+ if (!value || value === 'false') {
+ return this.falseText;
+ }
+ return this.trueText;
+ }
+});
+
+
+Ext.define('Ext.grid.column.Date', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.datecolumn'],
+ requires: ['Ext.Date'],
+ alternateClassName: 'Ext.grid.DateColumn',
+
+
+
+
+
+ initComponent: function(){
+ if (!this.format) {
+ this.format = Ext.Date.defaultFormat;
+ }
+
+ this.callParent(arguments);
+ },
+
+ defaultRenderer: function(value){
+ return Ext.util.Format.date(value, this.format);
+ }
+});
+
+
+Ext.define('Ext.grid.column.Number', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.numbercolumn'],
+ requires: ['Ext.util.Format'],
+ alternateClassName: 'Ext.grid.NumberColumn',
+
+
+
+ format : '0,000.00',
+
+
+
+
+
+ defaultRenderer: function(value){
+ return Ext.util.Format.number(value, this.format);
+ }
+});
+
+
+Ext.define('Ext.grid.column.Template', {
+ extend: 'Ext.grid.column.Column',
+ alias: ['widget.templatecolumn'],
+ requires: ['Ext.XTemplate'],
+ alternateClassName: 'Ext.grid.TemplateColumn',
+
+
+
+
+
+ initComponent: function(){
+ var me = this;
+ me.tpl = (!Ext.isPrimitive(me.tpl) && me.tpl.compile) ? me.tpl : new Ext.XTemplate(me.tpl);
+
+
+ me.hasCustomRenderer = true;
+ me.callParent(arguments);
+ },
+
+ defaultRenderer: function(value, meta, record) {
+ var data = Ext.apply({}, record.data, record.getAssociatedData());
+ return this.tpl.apply(data);
+ }
+});
+
+
+Ext.define('Ext.grid.feature.Feature', {
+ extend: 'Ext.util.Observable',
+ alias: 'feature.feature',
+
+
+ isFeature: true,
+
+
+ disabled: false,
+
+
+ hasFeatureEvent: true,
+
+
+ eventPrefix: null,
+
+
+ eventSelector: null,
+
+
+ view: null,
+
+
+ grid: null,
+
+
+ collectData: false,
+
+ constructor: function(config) {
+ this.initialConfig = config;
+ this.callParent(arguments);
+ },
+
+ clone: function() {
+ return new this.self(this.initialConfig);
+ },
+
+ init: Ext.emptyFn,
+
+ getFeatureTpl: function() {
+ return '';
+ },
+
+
+ getFireEventArgs: function(eventName, view, featureTarget, e) {
+ return [eventName, view, featureTarget, e];
+ },
+
+
+ attachEvents: function() {
+
+ },
+
+ getFragmentTpl: Ext.emptyFn,
+
+
+ mutateMetaRowTpl: Ext.emptyFn,
+
+
+ getMetaRowTplFragments: function() {
+ return {};
+ },
+
+ getTableFragments: function() {
+ return {};
+ },
+
+
+ getAdditionalData: function(data, idx, record, orig) {
+ return {};
+ },
+
+
+ enable: function() {
+ this.disabled = false;
+ },
+
+
+ disable: function() {
+ this.disabled = true;
+ }
+
+});
+
+
+Ext.define('Ext.grid.feature.AbstractSummary', {
+
+
+
+ extend: 'Ext.grid.feature.Feature',
+
+ alias: 'feature.abstractsummary',
+
+
+
+
+ showSummaryRow: true,
+
+
+ nestedIdRe: /\{\{id\}([\w\-]*)\}/g,
+
+
+ init: function() {
+ var me = this;
+
+
+ me.grid.optimizedColumnMove = false;
+
+ me.view.mon(me.view.store, {
+ update: me.onStoreUpdate,
+ scope: me
+ });
+ },
+
+
+ onStoreUpdate: function() {
+ var v = this.view;
+ if (this.showSummaryRow) {
+ v.saveScrollState();
+ v.refresh();
+ v.restoreScrollState();
+ }
+ },
+
+
+ toggleSummaryRow: function(visible){
+ this.showSummaryRow = !!visible;
+ },
+
+
+ getSummaryFragments: function(){
+ var fragments = {};
+ if (this.showSummaryRow) {
+ Ext.apply(fragments, {
+ printSummaryRow: Ext.bind(this.printSummaryRow, this)
+ });
+ }
+ return fragments;
+ },
+
+
+ printSummaryRow: function(index){
+ var inner = this.view.getTableChunker().metaRowTpl.join(''),
+ prefix = Ext.baseCSSPrefix;
+
+ inner = inner.replace(prefix + 'grid-row', prefix + 'grid-row-summary');
+ inner = inner.replace('{{id}}', '{gridSummaryValue}');
+ inner = inner.replace(this.nestedIdRe, '{id$1}');
+ inner = inner.replace('{[this.embedRowCls()]}', '{rowCls}');
+ inner = inner.replace('{[this.embedRowAttr()]}', '{rowAttr}');
+ inner = new Ext.XTemplate(inner, {
+ firstOrLastCls: Ext.view.TableChunker.firstOrLastCls
+ });
+
+ return inner.applyTemplate({
+ columns: this.getPrintData(index)
+ });
+ },
+
+
+ getColumnValue: function(column, summaryData){
+ var comp = Ext.getCmp(column.id),
+ value = summaryData[column.id],
+ renderer = comp.summaryRenderer;
+
+ if (!value && value !== 0) {
+ value = '\u00a0';
+ }
+
+ if (renderer) {
+ value = renderer.call(
+ comp.scope || this,
+ value,
+ summaryData,
+ column.dataIndex
+ );
+ }
+ return value;
+ },
+
+
+ getSummary: function(store, type, field, group){
+ if (type) {
+ if (Ext.isFunction(type)) {
+ return store.aggregate(type, null, group);
+ }
+
+ switch (type) {
+ case 'count':
+ return store.count(group);
+ case 'min':
+ return store.min(field, group);
+ case 'max':
+ return store.max(field, group);
+ case 'sum':
+ return store.sum(field, group);
+ case 'average':
+ return store.average(field, group);
+ default:
+ return group ? {} : '';
+
+ }
+ }
+ }
+
+});
+
+
+Ext.define('Ext.grid.feature.Chunking', {
+ extend: 'Ext.grid.feature.Feature',
+ alias: 'feature.chunking',
+
+ chunkSize: 20,
+ rowHeight: Ext.isIE ? 27 : 26,
+ visibleChunk: 0,
+ hasFeatureEvent: false,
+ attachEvents: function() {
+ this.view.el.on('scroll', this.onBodyScroll, this, {buffer: 300});
+ },
+
+ onBodyScroll: function(e, t) {
+ var view = this.view,
+ top = t.scrollTop,
+ nextChunk = Math.floor(top / this.rowHeight / this.chunkSize);
+ if (nextChunk !== this.visibleChunk) {
+
+ this.visibleChunk = nextChunk;
+ view.refresh();
+ view.el.dom.scrollTop = top;
+
+ view.el.dom.scrollTop = top;
+ }
+ },
+
+ collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
+
+
+ var me = this,
+ recordCount = o.rows.length,
+ start = 0,
+ i = 0,
+ visibleChunk = me.visibleChunk,
+ rows,
+ chunkLength,
+ origRows = o.rows;
+
+ delete o.rows;
+ o.chunks = [];
+ for (; start < recordCount; start += me.chunkSize, i++) {
+ if (start + me.chunkSize > recordCount) {
+ chunkLength = recordCount - start;
+ } else {
+ chunkLength = me.chunkSize;
+ }
+
+ if (i >= visibleChunk - 1 && i <= visibleChunk + 1) {
+ rows = origRows.slice(start, start + me.chunkSize);
+ } else {
+ rows = [];
+ }
+ o.chunks.push({
+ rows: rows,
+ fullWidth: fullWidth,
+ chunkHeight: chunkLength * me.rowHeight
+ });
+ }
+
+ return o;
+ },
+
+ getTableFragments: function() {
+ return {
+ openTableWrap: function() {
+ return '',
+
+ '{[this.recurse(values)]} '
+ ].join('');
+ },
+
+ getFragmentTpl: function() {
+ var me = this;
+ return {
+ indentByDepth: me.indentByDepth,
+ depthToIndent: me.depthToIndent,
+ renderGroupHeaderTpl: function(values, parent) {
+ return Ext.XTemplate.getTpl(me, 'groupHeaderTpl').apply(values, parent);
+ }
+ };
+ },
+
+ indentByDepth: function(values) {
+ return 'style="padding-left:'+ ((values.depth || 0) * this.depthToIndent) + 'px;"';
+ },
+
+
+
+ destroy: function() {
+ delete this.view;
+ delete this.prunedHeader;
+ },
+
+
+ attachEvents: function() {
+ var me = this,
+ view = me.view;
+
+ view.on({
+ scope: me,
+ groupclick: me.onGroupClick,
+ rowfocus: me.onRowFocus
+ });
+
+ view.mon(view.store, {
+ scope: me,
+ groupchange: me.onGroupChange,
+ remove: me.onRemove,
+ add: me.onAdd,
+ update: me.onUpdate
+ });
+
+ if (me.enableGroupingMenu) {
+ me.injectGroupingMenu();
+ }
+
+ me.pruneGroupedHeader();
+
+ me.lastGroupField = me.getGroupField();
+ me.block();
+ me.onGroupChange();
+ me.unblock();
+ },
+
+
+ onAdd: function(store, records){
+ var me = this,
+ view = me.view,
+ groupField = me.getGroupField(),
+ i = 0,
+ len = records.length,
+ activeGroups,
+ addedGroups,
+ groups,
+ needsRefresh,
+ group;
+
+ if (view.rendered) {
+ addedGroups = {};
+ activeGroups = {};
+
+ for (; i < len; ++i) {
+ group = records[i].get(groupField);
+ if (addedGroups[group] === undefined) {
+ addedGroups[group] = 0;
+ }
+ addedGroups[group] += 1;
+ }
+ groups = store.getGroups();
+ for (i = 0, len = groups.length; i < len; ++i) {
+ group = groups[i];
+ activeGroups[group.name] = group.children.length;
+ }
+
+ for (group in addedGroups) {
+ if (addedGroups[group] === activeGroups[group]) {
+ needsRefresh = true;
+ break;
+ }
+ }
+
+ if (needsRefresh) {
+ view.refresh();
+ }
+ }
+ },
+
+ onUpdate: function(store, record, type, changedFields){
+ var view = this.view;
+ if (view.rendered && !changedFields || Ext.Array.contains(changedFields, this.getGroupField())) {
+ view.refresh();
+ }
+ },
+
+ onRemove: function(store, record) {
+ var me = this,
+ groupField = me.getGroupField(),
+ removedGroup = record.get(groupField),
+ view = me.view;
+
+ if (view.rendered) {
+
+ if (store.findExact(groupField, removedGroup) === -1) {
+ me.view.refresh();
+ }
+ }
+ },
+
+ injectGroupingMenu: function() {
+ var me = this,
+ headerCt = me.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 || !me.getGroupField(),
+ showGroupsText = me.showGroupsText,
+ enableNoGroups = me.enableNoGroups,
+ getMenuItems = me.view.headerCt.getMenuItems;
+
+
+ return function() {
+
+
+
+ var o = getMenuItems.call(this);
+ o.push('-', {
+ iconCls: Ext.baseCSSPrefix + 'group-by-icon',
+ itemId: 'groupMenuItem',
+ text: groupByText,
+ handler: me.onGroupMenuItemClick,
+ scope: me
+ });
+ if (enableNoGroups) {
+ o.push({
+ itemId: 'groupToggleMenuItem',
+ text: showGroupsText,
+ checked: !disabled,
+ checkHandler: me.onGroupToggleMenuItemClick,
+ scope: me
+ });
+ }
+ return o;
+ };
+ },
+
+
+ onGroupMenuItemClick: function(menuItem, e) {
+ var me = this,
+ menu = menuItem.parentMenu,
+ hdr = menu.activeHeader,
+ view = me.view,
+ store = view.store;
+
+ delete me.lastGroupIndex;
+ me.block();
+ me.enable();
+ store.group(hdr.dataIndex);
+ me.pruneGroupedHeader();
+ me.unblock();
+ me.refreshIf();
+ },
+
+ block: function(){
+ this.blockRefresh = this.view.blockRefresh = true;
+ },
+
+ unblock: function(){
+ this.blockRefresh = this.view.blockRefresh = false;
+ },
+
+
+ onGroupToggleMenuItemClick: function(menuItem, checked) {
+ this[checked ? 'enable' : 'disable']();
+ },
+
+
+ pruneGroupedHeader: function() {
+ var me = this,
+ header = me.getGroupedHeader();
+
+ if (me.hideGroupedHeader && header) {
+ if (me.prunedHeader) {
+ me.prunedHeader.show();
+ }
+ me.prunedHeader = header;
+ header.hide();
+ }
+ },
+
+ getGroupedHeader: function(){
+ var groupField = this.getGroupField(),
+ headerCt = this.view.headerCt;
+
+ return groupField ? headerCt.down('[dataIndex=' + groupField + ']') : null;
+ },
+
+ 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);
+ }
+ },
+
+
+ isExpanded: function(groupName) {
+ return (this.collapsedState[groupName] === false);
+ },
+
+
+ expand: function(groupName, focus, preventSizeCalculation) {
+ var me = this,
+ view = me.view,
+ groupHeader,
+ groupBody,
+ lockingPartner = me.lockingPartner;
+
+
+ if (Ext.isString(groupName)) {
+ groupBody = Ext.fly(me.getGroupBodyId(groupName), '_grouping');
+ }
+
+ else {
+ groupBody = Ext.fly(groupName, '_grouping')
+ groupName = me.getGroupName(groupBody);
+ }
+ groupHeader = Ext.get(me.getGroupHeaderId(groupName));
+
+
+ if (me.collapsedState[groupName]) {
+ groupBody.removeCls(me.collapsedCls);
+ groupBody.prev().removeCls(me.hdCollapsedCls);
+
+ if (preventSizeCalculation !== true) {
+ view.refreshSize();
+ }
+ view.fireEvent('groupexpand', view, groupHeader, groupName);
+ me.collapsedState[groupName] = false;
+
+
+ if (lockingPartner) {
+ lockingPartner.expand(groupName, focus, preventSizeCalculation);
+ }
+ if (focus) {
+ groupBody.scrollIntoView(view.el, null, true);
+ }
+ }
+ },
+
+
+ expandAll: function(){
+ var me = this,
+ view = me.view,
+ els = view.el.select(me.eventSelector).elements,
+ e,
+ eLen = els.length;
+
+ for (e = 0; e < eLen; e++) {
+ me.expand(Ext.fly(els[e]).next(), false, true);
+ }
+
+ view.refreshSize();
+ },
+
+
+ collapse: function(groupName, focus, preventSizeCalculation) {
+ var me = this,
+ view = me.view,
+ groupHeader,
+ groupBody,
+ lockingPartner = me.lockingPartner;
+
+
+ if (Ext.isString(groupName)) {
+ groupBody = Ext.fly(me.getGroupBodyId(groupName), '_grouping');
+ }
+
+ else {
+ groupBody = Ext.fly(groupName, '_grouping')
+ groupName = me.getGroupName(groupBody);
+ }
+ groupHeader = Ext.get(me.getGroupHeaderId(groupName));
+
+
+ if (!me.collapsedState[groupName]) {
+ groupBody.addCls(me.collapsedCls);
+ groupBody.prev().addCls(me.hdCollapsedCls);
+
+ if (preventSizeCalculation !== true) {
+ view.refreshSize();
+ }
+ view.fireEvent('groupcollapse', view, groupHeader, groupName);
+ me.collapsedState[groupName] = true;
+
+
+ if (lockingPartner) {
+ lockingPartner.collapse(groupName, focus, preventSizeCalculation);
+ }
+ if (focus) {
+ groupHeader.scrollIntoView(view.el, null, true);
+ }
+ }
+ },
+
+
+ collapseAll: function() {
+ var me = this,
+ view = me.view,
+ els = view.el.select(me.eventSelector).elements,
+ e,
+ eLen = els.length;
+
+ for (e = 0; e < eLen; e++) {
+ me.collapse(Ext.fly(els[e]).next(), false, true);
+ }
+
+ view.refreshSize();
+ },
+
+ onGroupChange: function(){
+ var me = this,
+ field = me.getGroupField(),
+ menuItem,
+ visibleGridColumns,
+ groupingByLastVisibleColumn;
+
+ if (me.hideGroupedHeader) {
+ if (me.lastGroupField) {
+ menuItem = me.getMenuItem(me.lastGroupField);
+ if (menuItem) {
+ menuItem.setChecked(true);
+ }
+ }
+ if (field) {
+ visibleGridColumns = me.view.headerCt.getVisibleGridColumns();
+
+
+
+ groupingByLastVisibleColumn = ((visibleGridColumns.length === 1) && (visibleGridColumns[0].dataIndex == field));
+ menuItem = me.getMenuItem(field);
+ if (menuItem && !groupingByLastVisibleColumn) {
+ menuItem.setChecked(false);
+ }
+ }
+ }
+ me.refreshIf();
+ me.lastGroupField = field;
+ },
+
+
+ getMenuItem: function(dataIndex){
+ var view = this.view,
+ header = view.headerCt.down('gridcolumn[dataIndex=' + dataIndex + ']'),
+ menu = view.headerCt.getMenu();
+
+ return header ? menu.down('menuitem[headerId='+ header.id +']') : null;
+ },
+
+
+ onGroupClick: function(view, rowElement, groupName, e) {
+ var me = this;
+
+ if (me.collapsible) {
+ if (me.collapsedState[groupName]) {
+ me.expand(groupName);
+ } else {
+ me.collapse(groupName);
+ }
+ }
+ },
+
+
+ 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;
+
+
+
+
+ if (col) {
+ tdAttrKey = col.id + '-tdAttr';
+ o[tdAttrKey] = this.indentByDepth(data) + " " + (orig[tdAttrKey] ? orig[tdAttrKey] : '');
+ o.collapsed = 'true';
+ o.data = record.getData();
+ }
+ return o;
+ },
+
+
+ getGroupRows: function(group, records, preppedRecords, fullWidth) {
+ var me = this,
+ children = group.children,
+ rows = group.rows = [],
+ view = me.view,
+ header = me.getGroupedHeader(),
+ groupField = me.getGroupField(),
+ index = -1,
+ r,
+ rLen = records.length,
+ record;
+
+
+ if (view.store.buffered) {
+ me.collapsible = false;
+ }
+
+ group.viewId = view.id;
+
+ for (r = 0; r < rLen; r++) {
+ record = records[r];
+
+ if (record.get(groupField) == group.name) {
+ index = r;
+ }
+ if (Ext.Array.indexOf(children, record) != -1) {
+ rows.push(Ext.apply(preppedRecords[r], {
+ depth : 1
+ }));
+ }
+ }
+
+ group.groupField = groupField,
+ group.groupHeaderId = me.getGroupHeaderId(group.name);
+ group.groupBodyId = me.getGroupBodyId(group.name);
+ group.fullWidth = fullWidth;
+ group.columnName = header ? header.text : groupField;
+ group.groupValue = group.name;
+
+
+
+ if (header && index > -1) {
+ group.name = group.renderedValue = preppedRecords[index][header.id];
+ }
+ if (me.collapsedState[group.name]) {
+ group.collapsedCls = me.collapsedCls;
+ group.hdCollapsedCls = me.hdCollapsedCls;
+ } else {
+ group.collapsedCls = group.hdCollapsedCls = '';
+ }
+
+
+ if (me.collapsible) {
+ group.collapsibleClass = me.hdCollapsibleCls;
+ } else {
+ group.collapsibleClass = '';
+ }
+
+ return group;
+ },
+
+
+ getGroupHeaderId: function(groupName) {
+ return this.view.id + '-hd-' + groupName;
+ },
+
+
+ getGroupBodyId: function(groupName) {
+ return this.view.id + '-bd-' + groupName;
+ },
+
+
+ getGroupName: function(element) {
+ var me = this,
+ targetEl;
+
+
+ targetEl = Ext.fly(element).findParent(me.eventSelector);
+ if (targetEl) {
+ return targetEl.id.split(this.view.id + '-hd-')[1];
+ }
+
+
+ targetEl = Ext.fly(element).findParent(me.bodySelector);
+ if (targetEl) {
+ return targetEl.id.split(this.view.id + '-bd-')[1];
+ }
+ },
+
+
+ collectData: function(records, preppedRecords, startIndex, fullWidth, o) {
+ var me = this,
+ store = me.view.store,
+ collapsedState = me.collapsedState,
+ collapseGroups,
+ g,
+ groups, gLen, group;
+
+ if (me.startCollapsed) {
+
+
+
+ me.startCollapsed = false;
+ collapseGroups = true;
+ }
+
+ if (!me.disabled && store.isGrouped()) {
+ o.rows = groups = store.getGroups();
+ gLen = groups.length;
+
+ for (g = 0; g < gLen; g++) {
+ group = groups[g];
+
+ if (collapseGroups) {
+ collapsedState[group.name] = true;
+ }
+
+ me.getGroupRows(group, records, preppedRecords, fullWidth);
+ }
+ }
+ return o;
+ },
+
+
+
+
+
+ getFireEventArgs: function(type, view, targetEl, e) {
+ return [type, view, targetEl, this.getGroupName(targetEl), e];
+ }
+});
+
+
+Ext.define('Ext.grid.feature.GroupingSummary', {
+
+
+
+ extend: 'Ext.grid.feature.Grouping',
+
+ alias: 'feature.groupingsummary',
+
+ mixins: {
+ summary: 'Ext.grid.feature.AbstractSummary'
+ },
+
+
+
+ init: function() {
+ this.mixins.summary.init.call(this);
+ },
+
+
+ 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,
+ summaryRows,
+ s,
+ sLen,
+ convertedSummaryRow;
+
+ 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);
+ summaryRows = reader.getRoot(reader.rawData);
+ sLen = summaryRows.length;
+
+
+ if (!reader.convertRecordData) {
+ reader.buildExtractors();
+ }
+
+ for (s = 0; s < sLen; s++) {
+ convertedSummaryRow = {};
+
+
+ reader.convertRecordData(convertedSummaryRow, summaryRows[s]);
+ remoteData[convertedSummaryRow[groupField]] = convertedSummaryRow;
+ }
+
+
+ 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] !== 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 [
+ '',
+ '',
+ ' ',
+ ' '
+ ].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,
+
+ init: function() {
+ if (!this.disabled) {
+ this.enable();
+ }
+ },
+
+ getRowSelector: function(){
+ return 'tr:has(> ' + this.view.cellSelector + ')';
+ },
+
+ enable: function(){
+ var me = this,
+ view = me.view;
+
+ me.callParent();
+
+ me.savedRowSelector = view.rowSelector;
+ view.rowSelector = me.getRowSelector();
+
+
+
+
+ view.getComponentLayout().getColumnSelector = me.getColumnSelector;
+ },
+
+ disable: function(){
+ var me = this,
+ view = me.view,
+ saved = me.savedRowSelector;
+
+ me.callParent();
+ if (saved) {
+ view.rowSelector = saved;
+ }
+ delete me.savedRowSelector;
+ },
+
+ mutateMetaRowTpl: function(metaRowTpl) {
+ var prefix = Ext.baseCSSPrefix;
+
+
+ metaRowTpl[0] = metaRowTpl[0].replace(prefix + 'grid-row', '');
+ metaRowTpl[0] = metaRowTpl[0].replace("{[this.embedRowCls()]}", "");
+
+ metaRowTpl.unshift('');
+
+ metaRowTpl.unshift('
');
+
+ metaRowTpl.push('
' + html + '
';
+ }
+ }
+ html = me.cleanHtml(html);
+ if (me.fireEvent('beforesync', me, html) !== false) {
+ if (me.textareaEl.dom.value != html) {
+ me.textareaEl.dom.value = html;
+ changed = true;
+ }
+
+ me.fireEvent('sync', me, html);
+
+ if (changed) {
+
+
+ me.checkChange();
+ }
+ }
+ }
+ },
+
+
+ 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.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(Ext.fly(doc));
+ for (prop in doc) {
+ if (doc.hasOwnProperty && doc.hasOwnProperty(prop)) {
+ delete doc[prop];
+ }
+ }
+ }
+ } catch(e) {
+
+ }
+ Ext.destroyMembers(me, 'toolbar', '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() {
+ for (var i = 0, l = arguments.length, name; i < l; i++) {
+ name = arguments[i];
+ 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(),
+ readOnly = me.readOnly,
+ range, target;
+
+ if (k === e.TAB) {
+ e.stopEvent();
+ if (!readOnly) {
+ range = doc.selection.createRange();
+ if(range){
+ range.collapse(true);
+ range.pasteHTML(' ');
+ me.deferFocus();
+ }
+ }
+ }
+ else if (k === e.ENTER) {
+ if (!readOnly) {
+ range = doc.selection.createRange();
+ if (range) {
+ target = range.parentElement();
+ if(!target || target.tagName.toLowerCase() !== 'li'){
+ e.stopEvent();
+ range.pasteHTML(''); + range.collapse(false); + range.select(); + } + } + } + } + }; + } + + if (Ext.isOpera) { + return function(e){ + var me = this; + if (e.getKey() === e.TAB) { + e.stopEvent(); + if (!me.readOnly) { + me.win.focus(); + me.execCmd('InsertHTML',' '); + me.deferFocus(); + } + } + }; + } + + if (Ext.isWebKit) { + return function(e){ + var me = this, + k = e.getKey(), + readOnly = me.readOnly; + + if (k === e.TAB) { + e.stopEvent(); + if (!readOnly) { + me.execCmd('InsertText','\t'); + me.deferFocus(); + } + } + else if (k === e.ENTER) { + e.stopEvent(); + if (!readOnly) { + me.execCmd('InsertHtml','
'); + me.deferFocus(); + } + } + }; + } + + return null; + }()), + + + getToolbar : function(){ + return this.toolbar; + }, + + + + buttonTips : { + bold : { + title: 'Bold (Ctrl+B)', + text: 'Make the selected text bold.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + italic : { + title: 'Italic (Ctrl+I)', + text: 'Make the selected text italic.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + underline : { + title: 'Underline (Ctrl+U)', + text: 'Underline the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + increasefontsize : { + title: 'Grow Text', + text: 'Increase the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + decreasefontsize : { + title: 'Shrink Text', + text: 'Decrease the font size.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + backcolor : { + title: 'Text Highlight Color', + text: 'Change the background color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + forecolor : { + title: 'Font Color', + text: 'Change the color of the selected text.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyleft : { + title: 'Align Text Left', + text: 'Align text to the left.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifycenter : { + title: 'Center Text', + text: 'Center text in the editor.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + justifyright : { + title: 'Align Text Right', + text: 'Align text to the right.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertunorderedlist : { + title: 'Bullet List', + text: 'Start a bulleted list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + insertorderedlist : { + title: 'Numbered List', + text: 'Start a numbered list.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + createlink : { + title: 'Hyperlink', + text: 'Make the selected text a hyperlink.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + }, + sourceedit : { + title: 'Source Edit', + text: 'Switch to source editing mode.', + cls: Ext.baseCSSPrefix + 'html-editor-tip' + } + } + + + + + + + + + + + + + + + + + + +}); + + +Ext.define('Ext.form.field.Radio', { + extend:'Ext.form.field.Checkbox', + alias: ['widget.radiofield', 'widget.radio'], + alternateClassName: 'Ext.form.Radio', + requires: ['Ext.form.RadioManager'], + + + isRadio: true, + + + + + inputType: 'radio', + ariaRole: 'radio', + + formId: null, + + + getGroupValue: function() { + var selected = this.getManager().getChecked(this.name, this.getFormId()); + return selected ? selected.inputValue : null; + }, + + + onBoxClick: function(e) { + var me = this; + if (!me.disabled && !me.readOnly) { + this.setValue(true); + } + }, + + onRemoved: function(){ + this.callParent(arguments); + this.formId = null; + }, + + + setValue: function(v) { + var me = this, + active; + + if (Ext.isBoolean(v)) { + me.callParent(arguments); + } else { + active = me.getManager().getWithValue(me.name, v, me.getFormId()).getAt(0); + if (active) { + active.setValue(true); + } + } + return me; + }, + + + getSubmitValue: function() { + return this.checked ? this.inputValue : null; + }, + + getModelData: function() { + return this.getSubmitData(); + }, + + + onChange: function(newVal, oldVal) { + var me = this, + r, rLen, radio, radios; + + me.callParent(arguments); + + if (newVal) { + radios = me.getManager().getByName(me.name, me.getFormId()).items; + rLen = radios.length; + + for (r = 0; r < rLen; r++) { + radio = radios[r]; + + if (radio !== me) { + radio.setValue(false); + } + } + } + }, + + + getManager: function() { + return Ext.form.RadioManager; + } +}); + + +Ext.define('Ext.picker.Time', { + extend: 'Ext.view.BoundList', + alias: 'widget.timepicker', + requires: ['Ext.data.Store', 'Ext.Date'], + + + + + + + increment: 15, + + + + format : "g:i A", + + + + displayField: 'disp', + + + initDate: [2008,0,1], + + componentCls: Ext.baseCSSPrefix + 'timepicker', + + + loadMask: false, + + initComponent: function() { + var me = this, + dateUtil = Ext.Date, + clearTime = dateUtil.clearTime, + initDate = me.initDate; + + + me.absMin = clearTime(new Date(initDate[0], initDate[1], initDate[2])); + me.absMax = dateUtil.add(clearTime(new Date(initDate[0], initDate[1], initDate[2])), 'mi', (24 * 60) - 1); + + me.store = me.createStore(); + me.updateList(); + + me.callParent(); + }, + + + setMinValue: function(value) { + this.minValue = value; + this.updateList(); + }, + + + setMaxValue: function(value) { + this.maxValue = value; + this.updateList(); + }, + + + normalizeDate: function(date) { + var initDate = this.initDate; + date.setFullYear(initDate[0], initDate[1], initDate[2]); + return date; + }, + + + updateList: function() { + var me = this, + min = me.normalizeDate(me.minValue || me.absMin), + max = me.normalizeDate(me.maxValue || me.absMax); + + me.store.filterBy(function(record) { + var date = record.get('date'); + return date >= min && date <= max; + }); + }, + + + createStore: function() { + var me = this, + utilDate = Ext.Date, + times = [], + min = me.absMin, + max = me.absMax; + + while(min <= max){ + times.push({ + disp: utilDate.dateFormat(min, me.format), + date: min + }); + min = utilDate.add(min, 'mi', me.increment); + } + + return new Ext.data.Store({ + fields: ['disp', 'date'], + data: times + }); + } + +}); + + +Ext.define('Ext.form.field.Time', { + extend:'Ext.form.field.ComboBox', + alias: 'widget.timefield', + requires: ['Ext.form.field.Date', 'Ext.picker.Time', 'Ext.view.BoundListKeyNav', 'Ext.Date'], + alternateClassName: ['Ext.form.TimeField', 'Ext.form.Time'], + + + triggerCls: Ext.baseCSSPrefix + 'form-time-trigger', + + + + + + + + minText : "The time in this field must be equal to or after {0}", + + + + + maxText : "The time in this field must be equal to or before {0}", + + + + + invalidText : "{0} is not a valid time", + + + + + format : "g:i A", + + + + + + + + + altFormats : "g:ia|g:iA|g:i a|g:i A|h:i|g:i|H:i|ga|ha|gA|h a|g a|g A|gi|hi|gia|hia|g|H|gi a|hi a|giA|hiA|gi A|hi A", + + + + increment: 15, + + + pickerMaxHeight: 300, + + + selectOnTab: true, + + + snapToIncrement: false, + + + initDate: '1/1/2008', + initDateFormat: 'j/n/Y', + + ignoreSelection: 0, + + queryMode: 'local', + + displayField: 'disp', + + valueField: 'date', + + initComponent: function() { + var me = this, + min = me.minValue, + max = me.maxValue; + if (min) { + me.setMinValue(min); + } + if (max) { + me.setMaxValue(max); + } + me.displayTpl = new Ext.XTemplate( + '
' + me.emptyText + '
' : ''
+ }));
+
+
+ me.view.getComponentLayout().headerCt = me.headerCt;
+
+ me.mon(me.view, {
+ uievent: me.processEvent,
+ scope: me
+ });
+ sm.view = me.view;
+ me.headerCt.view = me.view;
+ me.relayEvents(me.view, [
+
+ 'cellclick',
+
+ 'celldblclick'
+ ]);
+ }
+ return me.view;
+ },
+
+
+ setAutoScroll: Ext.emptyFn,
+
+
+ processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+ var me = this,
+ header;
+
+ if (cellIndex !== -1) {
+ header = me.headerCt.getGridColumns()[cellIndex];
+ return header.processEvent.apply(header, arguments);
+ }
+ },
+
+
+ determineScrollbars: function () {
+ },
+
+
+ invalidateScroller: function () {
+ },
+
+ scrollByDeltaY: function(yDelta, animate) {
+ this.getView().scrollBy(0, yDelta, animate);
+ },
+
+ scrollByDeltaX: function(xDelta, animate) {
+ this.getView().scrollBy(xDelta, 0, animate);
+ },
+
+ afterCollapse: function() {
+ var me = this;
+ me.saveScrollPos();
+ me.saveScrollPos();
+ me.callParent(arguments);
+ },
+
+ afterExpand: function() {
+ var me = this;
+ me.callParent(arguments);
+ me.restoreScrollPos();
+ me.restoreScrollPos();
+ },
+
+ saveScrollPos: Ext.emptyFn,
+
+ restoreScrollPos: Ext.emptyFn,
+
+ onHeaderResize: function(){
+ this.delayScroll();
+ },
+
+
+ onHeaderMove: function(headerCt, header, colsToMove, fromIdx, toIdx) {
+ var me = this;
+
+
+
+ if (me.optimizedColumnMove === false) {
+ me.view.refresh();
+ }
+
+
+ else {
+ me.view.moveColumn(fromIdx, toIdx, colsToMove);
+ }
+ me.delayScroll();
+ },
+
+
+ onHeaderHide: function(headerCt, header) {
+ this.delayScroll();
+ },
+
+ onHeaderShow: function(headerCt, header) {
+ this.delayScroll();
+ },
+
+ delayScroll: function(){
+ var target = this.getScrollTarget().el;
+ if (target) {
+ this.scrollTask.delay(10, null, null, [target.dom.scrollLeft]);
+ }
+ },
+
+
+ onViewReady: function() {
+ this.fireEvent('viewready', this);
+ },
+
+
+ onRestoreHorzScroll: function() {
+ var left = this.scrollLeftPos;
+ if (left) {
+
+ this.syncHorizontalScroll(left, true);
+ }
+ },
+
+ getScrollerOwner: function() {
+ var rootCmp = this;
+ if (!this.scrollerOwner) {
+ rootCmp = this.up('[scrollerOwner]');
+ }
+ return rootCmp;
+ },
+
+
+ getLhsMarker: function() {
+ var me = this;
+ return me.lhsMarker || (me.lhsMarker = Ext.DomHelper.append(me.el, {
+ cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+ }, true));
+ },
+
+
+ getRhsMarker: function() {
+ var me = this;
+
+ return me.rhsMarker || (me.rhsMarker = Ext.DomHelper.append(me.el, {
+ cls: Ext.baseCSSPrefix + 'grid-resize-marker'
+ }, true));
+ },
+
+
+ getSelectionModel: function(){
+ if (!this.selModel) {
+ this.selModel = {};
+ }
+
+ var mode = 'SINGLE',
+ type;
+ if (this.simpleSelect) {
+ mode = 'SIMPLE';
+ } else if (this.multiSelect) {
+ mode = 'MULTI';
+ }
+
+ Ext.applyIf(this.selModel, {
+ allowDeselect: this.allowDeselect,
+ mode: mode
+ });
+
+ if (!this.selModel.events) {
+ type = this.selModel.selType || this.selType;
+ this.selModel = Ext.create('selection.' + type, this.selModel);
+ }
+
+ if (!this.selModel.hasRelaySetup) {
+ this.relayEvents(this.selModel, [
+ 'selectionchange', 'beforeselect', 'beforedeselect', 'select', 'deselect'
+ ]);
+ this.selModel.hasRelaySetup = true;
+ }
+
+
+
+ if (this.disableSelection) {
+ this.selModel.locked = true;
+ }
+ return this.selModel;
+ },
+
+ getScrollTarget: function(){
+ var owner = this.getScrollerOwner(),
+ items = owner.query('tableview');
+
+ return items[1] || items[0];
+ },
+
+ onHorizontalScroll: function(event, target) {
+ this.syncHorizontalScroll(target.scrollLeft);
+ },
+
+ syncHorizontalScroll: function(left, setBody) {
+ var me = this,
+ scrollTarget;
+
+ setBody = setBody === true;
+
+
+ if (me.rendered && (setBody || left !== me.scrollLeftPos)) {
+
+
+ if (setBody) {
+ scrollTarget = me.getScrollTarget();
+ scrollTarget.el.dom.scrollLeft = left;
+ }
+ me.headerCt.el.dom.scrollLeft = left;
+ me.scrollLeftPos = left;
+ }
+ },
+
+
+ onStoreLoad: Ext.emptyFn,
+
+ getEditorParent: function() {
+ return this.body;
+ },
+
+ bindStore: function(store) {
+ var me = this;
+ me.store = store;
+ me.getView().bindStore(store);
+ },
+
+ beforeDestroy: function(){
+ Ext.destroy(this.verticalScroller);
+ this.callParent();
+ },
+
+
+ reconfigure: function(store, columns) {
+ var me = this,
+ headerCt = me.headerCt;
+
+ if (me.lockable) {
+ me.reconfigureLockable(store, columns);
+ } else {
+ Ext.suspendLayouts();
+ if (columns) {
+
+ delete me.scrollLeftPos;
+ headerCt.removeAll();
+ headerCt.add(columns);
+ }
+ if (store) {
+ store = Ext.StoreManager.lookup(store);
+ me.bindStore(store);
+ } else {
+ me.getView().refresh();
+ }
+ headerCt.setSortState();
+ Ext.resumeLayouts(true);
+ }
+ me.fireEvent('reconfigure', me, store, columns);
+ }
+});
+
+
+Ext.define('Ext.grid.View', {
+ extend: 'Ext.view.Table',
+ alias: 'widget.gridview',
+
+
+ stripeRows: true,
+
+ autoScroll: true
+});
+
+
+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,
+
+
+
+ bothCfgCopy: [
+ 'invalidateScrollerOnRefresh',
+ 'hideHeaders',
+ 'enableColumnHide',
+ 'enableColumnMove',
+ 'enableColumnResize',
+ 'sortableColumns'
+ ],
+ normalCfgCopy: [
+ 'verticalScroller',
+ 'verticalScrollDock',
+ 'verticalScrollerType',
+ 'scroll'
+ ],
+ lockedCfgCopy: [],
+
+
+ rowLines: true
+
+
+
+
+
+
+
+});
+
+
+
+
+
+
+
+
+
+
+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 = new 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;
+ }
+
+ me.mon(Ext.container.Container.hierarchyEventSource, {
+ scope: me,
+ show: me.repositionIfVisible
+ });
+
+ 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']();
+ }
+ me.updateButton(valid);
+ me.isValid = valid;
+ },
+
+ updateButton: function(valid){
+ var buttons = this.floatingButtons;
+ if (buttons) {
+ buttons.child('#update').setDisabled(!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 = new Ext.util.KeyNav(me.el, {
+ enter: plugin.completeEdit,
+ esc: plugin.onEscKey,
+ scope: plugin
+ });
+
+ me.mon(plugin.view, {
+ beforerefresh: me.onBeforeViewRefresh,
+ refresh: me.onViewRefresh,
+ itemremove: me.onViewItemRemove,
+ 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();
+ }
+ },
+
+ onViewItemRemove: function(record, index) {
+ var context = this.context;
+ if (context && record === context.record) {
+
+ this.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) {
+ if (!column.isGroupHeader) {
+ this.setField(column);
+ }
+ },
+
+ onColumnRemove: function(column) {
+ this.columns.remove(column);
+ },
+
+ onColumnResize: function(column, width) {
+ if (!column.isGroupHeader) {
+ column.getEditor().setWidth(width - 2);
+ this.repositionIfVisible();
+ }
+ },
+
+ onColumnHide: function(column) {
+ if (!column.isGroupHeader) {
+ column.getEditor().hide();
+ this.repositionIfVisible();
+ }
+ },
+
+ onColumnShow: function(column) {
+ var field = column.getEditor();
+ field.setWidth(column.getWidth() - 2).show();
+ this.repositionIfVisible();
+ },
+
+ onColumnMove: function(column, fromIdx, toIdx) {
+ if (!column.isGroupHeader) {
+ var field = column.getEditor();
+ if (this.items.indexOf(field) != toIdx) {
+ this.move(fromIdx, toIdx);
+ }
+ }
+ },
+
+ onFieldAdd: function(map, fieldId, column) {
+ var me = this,
+ colIdx,
+ field;
+
+ if (!column.isGroupHeader) {
+ 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,
+ fieldEl;
+
+ if (!column.isGroupHeader) {
+ field = column.getEditor();
+ fieldEl = field.el;
+ me.remove(field, false);
+ if (fieldEl) {
+ fieldEl.remove();
+ }
+ }
+ },
+
+ onFieldReplace: function(map, fieldId, column, oldColumn) {
+ this.onFieldRemove(map, fieldId, oldColumn);
+ },
+
+ clearFields: function() {
+ var map = this.columns,
+ key;
+
+ for (key in map) {
+ if (map.hasOwnProperty(key)) {
+ map.removeAtKey(key);
+ }
+ }
+ },
+
+ getFloatingButtons: function() {
+ var me = this,
+ cssPrefix = Ext.baseCSSPrefix,
+ btnsCss = cssPrefix + 'grid-row-editor-buttons',
+ plugin = me.editingPlugin,
+ minWidth = Ext.panel.Panel.prototype.minButtonWidth,
+ btns;
+
+ if (!me.floatingButtons) {
+ btns = me.floatingButtons = new Ext.Container({
+ renderTpl: [
+ '',
+ '',
+ '',
+ '',
+ '',
+ '{%this.renderContainer(out,values)%}'
+ ],
+ width: 200,
+ renderTo: me.el,
+ baseCls: btnsCss,
+ layout: {
+ type: 'hbox',
+ align: 'middle'
+ },
+ defaults: {
+ flex: 1,
+ margins: '0 1 0 1'
+ },
+ items: [{
+ itemId: 'update',
+ xtype: 'button',
+ handler: plugin.completeEdit,
+ scope: plugin,
+ text: me.saveBtnText,
+ minWidth: minWidth
+ }, {
+ xtype: 'button',
+ handler: plugin.cancelEdit,
+ scope: plugin,
+ text: me.cancelBtnText,
+ minWidth: minWidth
+ }]
+ });
+
+
+ me.mon(btns.el, {
+
+
+ mousedown: Ext.emptyFn,
+ click: Ext.emptyFn,
+ stopEvent: true
+ });
+ }
+ return me.floatingButtons;
+ },
+
+ repositionIfVisible: function(c){
+ var me = this,
+ view = me.view;
+
+
+
+ if (c && (c == me || !view.isDescendantOf(c))) {
+ return;
+ }
+
+ if (me.isVisible() && view.isVisible(true)) {
+ me.reposition();
+ }
+ },
+
+ 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,
+
+
+
+ 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() {
+ btnEl.scrollIntoView(viewEl, false);
+ if (animateConfig && animateConfig.callback) {
+ animateConfig.callback.call(animateConfig.scope || me);
+ }
+ },
+
+ animObj;
+
+
+ if (row && Ext.isElement(row.dom)) {
+
+
+ row.scrollIntoView(viewEl, false);
+
+
+
+
+ y = row.getXY()[1] - 5;
+ rowH = row.getHeight();
+ newHeight = rowH + (me.editingPlugin.grid.rowLines ? 9 : 10);
+
+
+ if (me.getHeight() != newHeight) {
+ me.setHeight(newHeight);
+ me.el.setLeft(0);
+ }
+
+ if (animateConfig) {
+ animObj = {
+ to: {
+ y: y
+ },
+ duration: animateConfig.duration || 125,
+ listeners: {
+ afteranimate: function() {
+ invalidateScroller();
+ y = row.getXY()[1] - 5;
+ }
+ }
+ };
+ me.el.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.isHeader && !fieldInfo.isGroupHeader) {
+ return fieldInfo.getEditor();
+ }
+ },
+
+ removeField: function(field) {
+ var me = this;
+
+
+ field = me.getEditor(field);
+ me.mun(field, 'validitychange', me.onValidityChange, me);
+
+
+
+ me.columns.removeAtKey(field.id);
+ Ext.destroy(field);
+ },
+
+ setField: function(column) {
+ var me = this,
+ i,
+ length, field;
+
+ if (Ext.isArray(column)) {
+ length = column.length;
+
+ for (i = 0; i < length; i++) {
+ me.setField(column[i]);
+ }
+
+ return;
+ }
+
+
+ field = column.getEditor(null, {
+ xtype: 'displayfield',
+
+
+ getModelData: function() {
+ return null;
+ }
+ });
+ field.margins = '0 0 0 2';
+ me.mon(field, 'change', me.onFieldChange, me);
+
+ if (me.isVisible() && me.context) {
+ if (field.is('displayfield')) {
+ me.renderColumnData(field, me.context.record, column);
+ } else {
+ field.suspendEvents();
+ field.setValue(me.context.record.get(column.dataIndex));
+ field.resumeEvents();
+ }
+ }
+
+
+
+
+ me.columns.add(field.id, column);
+ if (column.hidden) {
+ me.onColumnHide(column);
+ } else if (column.rendered) {
+
+ me.onColumnShow(column);
+ }
+ },
+
+ loadRecord: function(record) {
+ var me = this,
+ form = me.getForm(),
+ fields = form.getFields(),
+ items = fields.items,
+ length = items.length,
+ i, displayFields,
+ isValid;
+
+
+ for (i = 0; i < length; i++) {
+ items[i].suspendEvents();
+ }
+
+ form.loadRecord(record);
+
+ for (i = 0; i < length; i++) {
+ items[i].resumeEvents();
+ }
+
+ isValid = form.isValid();
+ if (me.errorSummary) {
+ if (isValid) {
+ me.hideToolTip();
+ } else {
+ me.showToolTip();
+ }
+ }
+
+ me.updateButton(isValid);
+
+
+ displayFields = me.query('>displayfield');
+ length = displayFields.length;
+
+ for (i = 0; i < length; i++) {
+ me.renderColumnData(displayFields[i], record);
+ }
+ },
+
+ renderColumnData: function(field, record, activeColumn) {
+ var me = this,
+ grid = me.editingPlugin.grid,
+ headerCt = grid.headerCt,
+ view = grid.view,
+ store = view.store,
+ column = activeColumn || me.columns.get(field.id),
+ value = record.get(column.dataIndex),
+ renderer = column.editRenderer || column.renderer,
+ metaData,
+ rowIdx,
+ colIdx;
+
+
+ if (renderer) {
+ metaData = { tdCls: '', style: '' };
+ rowIdx = store.indexOf(record);
+ colIdx = headerCt.getHeaderIndex(column);
+
+ value = 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.errorSummary && !me.autoCancel && me.isDirty()) {
+ me.showToolTip();
+ return false;
+ }
+ },
+
+
+ startEdit: function(record, columnHeader) {
+ var me = this,
+ grid = me.editingPlugin.grid,
+ 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(),
+ fields = form.getFields(),
+ items = fields.items,
+ length = items.length,
+ i;
+
+ me.hide();
+ form.clearInvalid();
+
+
+ for (i = 0; i < length; i++) {
+ items[i].suspendEvents();
+ }
+
+ form.reset();
+
+ for (i = 0; i < length; i++) {
+ items[i].resumeEvents();
+ }
+ },
+
+ completeEdit: function() {
+ var me = this,
+ form = me.getForm();
+
+ if (!form.isValid()) {
+ return;
+ }
+
+ form.updateRecord(me.context.record);
+ me.hide();
+ return true;
+ },
+
+ onShow: function() {
+ this.callParent(arguments);
+ this.reposition();
+ },
+
+ onHide: function() {
+ var me = this;
+ me.callParent(arguments);
+ if (me.tooltip) {
+ me.hideToolTip();
+ }
+ if (me.context) {
+ me.context.view.focus();
+ me.context = null;
+ }
+ },
+
+ isDirty: function() {
+ var me = this,
+ form = me.getForm();
+ return form.isDirty();
+ },
+
+ getToolTip: function() {
+ return this.tooltip || (this.tooltip = new Ext.tip.ToolTip({
+ cls: Ext.baseCSSPrefix + 'grid-row-editor-errors',
+ title: this.errorsText,
+ autoHide: false,
+ closable: true,
+ closeAction: 'disable',
+ anchor: 'left'
+ }));
+ },
+
+ 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.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 + '' : '', + errors = [], + fields = me.query('>[isFormField]'), + length = fields.length, + i; + + function createListItem(e) { + return '
- ' + errors.join('') + '
' +
+ '' +
+ '{text}' +
+ '' +
+ ''+
+ ''+
+ ' ' +
+ '
' +
+ '{%this.renderContainer(out,values)%}',
+
+
+
+
+
+
+ dataIndex: null,
+
+
+ text: ' ',
+
+
+
+
+ menuText: null,
+
+
+ emptyCellText: ' ',
+
+
+ sortable: true,
+
+
+
+
+
+
+
+
+ resizable: true,
+
+
+ hideable: true,
+
+
+ menuDisabled: false,
+
+
+ renderer: false,
+
+
+
+
+
+
+ editRenderer: false,
+
+
+ align: 'left',
+
+
+ draggable: true,
+
+
+
+
+ tooltipType: 'qtip',
+
+
+
+ initDraggable: Ext.emptyFn,
+
+
+
+
+
+
+
+
+
+
+
+
+ isHeader: true,
+
+ componentLayout: 'columncomponent',
+
+
+ initResizable: Ext.emptyFn,
+
+ initComponent: function() {
+ var me = this,
+ renderer;
+
+ if (Ext.isDefined(me.header)) {
+ me.text = me.header;
+ delete me.header;
+ }
+
+ if (!me.triStateSort) {
+ me.possibleSortStates.length = 2;
+ }
+
+
+ if (Ext.isDefined(me.columns)) {
+ me.isGroupHeader = true;
+
+
+
+ me.items = me.columns;
+ delete me.columns;
+ delete me.flex;
+ delete me.width;
+ me.cls = (me.cls||'') + ' ' + Ext.baseCSSPrefix + 'group-header';
+ me.sortable = false;
+ me.resizable = false;
+ me.align = 'center';
+ } else {
+
+
+ me.isContainer = false;
+
+
+
+
+ if (me.flex) {
+ me.minWidth = me.minWidth || Ext.grid.plugin.HeaderResizer.prototype.minColWidth;
+ }
+ }
+ me.addCls(Ext.baseCSSPrefix + 'column-header-align-' + me.align);
+
+ renderer = me.renderer;
+ if (renderer) {
+
+
+ if (typeof renderer == 'string') {
+ me.renderer = Ext.util.Format[renderer];
+ }
+ me.hasCustomRenderer = true;
+ } else if (me.defaultRenderer) {
+ me.scope = me;
+ me.renderer = me.defaultRenderer;
+ }
+
+
+ me.callParent(arguments);
+
+ me.on({
+ element: 'el',
+ click: me.onElClick,
+ dblclick: me.onElDblClick,
+ scope: me
+ });
+ me.on({
+ element: 'titleEl',
+ mouseenter: me.onTitleMouseOver,
+ mouseleave: me.onTitleMouseOut,
+ scope: me
+ });
+ },
+
+ onAdd: function(childHeader) {
+ childHeader.isSubHeader = true;
+ childHeader.addCls(Ext.baseCSSPrefix + 'group-sub-header');
+ this.callParent(arguments);
+ },
+
+ onRemove: function(childHeader) {
+ childHeader.isSubHeader = false;
+ childHeader.removeCls(Ext.baseCSSPrefix + 'group-sub-header');
+ this.callParent(arguments);
+ },
+
+ initRenderData: function() {
+ var me = this,
+ tipMarkup = '',
+ tip = me.tooltip,
+ attr = me.tooltipType == 'qtip' ? 'data-qtip' : 'title';
+
+ if (!Ext.isEmpty(tip)) {
+ tipMarkup = attr + '="' + tip + '" ';
+ }
+
+ return Ext.applyIf(me.callParent(arguments), {
+ text: me.text,
+ menuDisabled: me.menuDisabled,
+ tipMarkup: tipMarkup
+ });
+ },
+
+ applyColumnState: function (state) {
+ var me = this,
+ defined = Ext.isDefined;
+
+
+ me.applyColumnsState(state.columns);
+
+
+
+ if (defined(state.hidden)) {
+ me.hidden = state.hidden;
+ }
+ if (defined(state.locked)) {
+ me.locked = state.locked;
+ }
+ if (defined(state.sortable)) {
+ me.sortable = state.sortable;
+ }
+ if (defined(state.width)) {
+ delete me.flex;
+ me.width = state.width;
+ } else if (defined(state.flex)) {
+ delete me.width;
+ me.flex = state.flex;
+ }
+ },
+
+ getColumnState: function () {
+ var me = this,
+ items = me.items.items,
+
+ iLen = items ? items.length : 0,
+ i,
+ columns = [],
+ state = {
+ id: me.getStateId()
+ };
+
+ me.savePropsToState(['hidden', 'sortable', 'locked', 'flex', 'width'], state);
+
+ if (me.isGroupHeader) {
+ for (i = 0; i < iLen; i++) {
+ columns.push(items[i].getColumnState());
+ }
+
+ if (columns.length) {
+ state.columns = columns;
+ }
+ } else if (me.isSubHeader && me.ownerCt.hidden) {
+
+ delete me.hidden;
+ }
+
+ if ('width' in state) {
+ delete state.flex;
+ }
+ return state;
+ },
+
+ getStateId: function () {
+ return this.stateId || this.headerId;
+ },
+
+
+ setText: function(text) {
+ this.text = text;
+ if (this.rendered) {
+ this.textEl.update(text);
+ }
+ },
+
+
+
+ getOwnerHeaderCt: function() {
+ return this.up(':not([isHeader])');
+ },
+
+
+ getIndex: function() {
+ return this.isGroupColumn ? false : this.getOwnerHeaderCt().getHeaderIndex(this);
+ },
+
+
+ getVisibleIndex: function() {
+ return this.isGroupColumn ? false : Ext.Array.indexOf(this.getOwnerHeaderCt().getVisibleGridColumns(), this);
+ },
+
+ beforeRender: function() {
+ var me = this,
+ grid = me.up('tablepanel');
+
+ me.callParent();
+
+
+
+ if (grid && (!me.sortable || grid.sortableColumns === false) && !me.groupable &&
+ !me.lockable && (grid.enableColumnHide === false ||
+ !me.getOwnerHeaderCt().getHideableColumns().length)) {
+ me.menuDisabled = true;
+ }
+ },
+
+ afterRender: function() {
+ var me = this,
+ el = me.el;
+
+ me.callParent(arguments);
+
+ if (me.overCls) {
+ el.addClsOnOver(me.overCls);
+ }
+
+
+
+ if (!Ext.isIE8 || !Ext.isStrict) {
+ me.mon(me.getFocusEl(), {
+ focus: me.onTitleMouseOver,
+ blur: me.onTitleMouseOut,
+ scope: me
+ });
+ }
+
+ me.keyNav = new Ext.util.KeyNav(el, {
+ enter: me.onEnterKey,
+ down: me.onDownKey,
+ scope: me
+ });
+ },
+
+
+
+ afterComponentLayout: function(width, height, oldWidth, oldHeight) {
+ var me = this,
+ ownerHeaderCt = me.getOwnerHeaderCt();
+
+ me.callParent(arguments);
+
+ if (ownerHeaderCt && (oldWidth != null || me.flex) && width !== oldWidth) {
+ ownerHeaderCt.onHeaderResize(me, width, true);
+ }
+ },
+
+
+
+
+ setPadding: function(headerHeight) {
+ var me = this,
+ lineHeight = parseInt(me.textEl.getStyle('line-height'), 10),
+ textHeight = me.textEl.dom.offsetHeight,
+ titleEl = me.titleEl,
+ availableHeight = headerHeight - me.el.getBorderWidth('tb'),
+ titleElHeight;
+
+
+ if (!me.isGroupHeader) {
+ if (titleEl.getHeight() < availableHeight) {
+ titleEl.setHeight(availableHeight);
+
+
+
+ me.ownerCt.layout.innerCt.setHeight(headerHeight);
+ }
+ }
+ titleElHeight = titleEl.getViewSize().height;
+
+
+ if (textHeight) {
+ if(lineHeight) {
+ textHeight = Math.ceil(textHeight / lineHeight) * lineHeight;
+ }
+ titleEl.setStyle({
+ paddingTop: Math.floor(Math.max(((titleElHeight - textHeight) / 2), 0)) + 'px'
+ });
+ }
+
+
+ if (Ext.isIE && me.triggerEl) {
+ me.triggerEl.setHeight(titleElHeight);
+ }
+ },
+
+ onDestroy: function() {
+ var me = this;
+
+ Ext.destroy(me.textEl, me.keyNav, me.field);
+ delete me.keyNav;
+ me.callParent(arguments);
+ },
+
+ onTitleMouseOver: function() {
+ this.titleEl.addCls(this.hoverCls);
+ },
+
+ onTitleMouseOut: function() {
+ this.titleEl.removeCls(this.hoverCls);
+ },
+
+ onDownKey: function(e) {
+ if (this.triggerEl) {
+ this.onElClick(e, this.triggerEl.dom || this.el.dom);
+ }
+ },
+
+ onEnterKey: function(e) {
+ this.onElClick(e, this.el.dom);
+ },
+
+
+ onElDblClick: function(e, t) {
+ var me = this,
+ ownerCt = me.ownerCt;
+ if (ownerCt && Ext.Array.indexOf(ownerCt.items, me) !== 0 && me.isOnLeftEdge(e) ) {
+ ownerCt.expandToFit(me.previousSibling('gridcolumn'));
+ }
+ },
+
+ onElClick: function(e, t) {
+
+
+ var me = this,
+ ownerHeaderCt = me.getOwnerHeaderCt();
+
+ if (ownerHeaderCt && !ownerHeaderCt.ddLock) {
+
+
+ if (me.triggerEl && (e.target === me.triggerEl.dom || t === me.triggerEl.dom || e.within(me.triggerEl))) {
+ ownerHeaderCt.onHeaderTriggerClick(me, e, t);
+
+ } else if (e.getKey() || (!me.isOnLeftEdge(e) && !me.isOnRightEdge(e))) {
+ me.toggleSortState();
+ ownerHeaderCt.onHeaderClick(me, e, t);
+ }
+ }
+ },
+
+
+ processEvent: function(type, view, cell, recordIndex, cellIndex, e) {
+ return this.fireEvent.apply(this, arguments);
+ },
+
+ toggleSortState: function() {
+ var me = this,
+ idx,
+ nextIdx;
+
+ if (me.sortable) {
+ idx = Ext.Array.indexOf(me.possibleSortStates, me.sortState);
+
+ nextIdx = (idx + 1) % me.possibleSortStates.length;
+ me.setSortState(me.possibleSortStates[nextIdx]);
+ }
+ },
+
+ doSort: function(state) {
+ var ds = this.up('tablepanel').store;
+ ds.sort({
+ property: this.getSortParam(),
+ direction: state
+ });
+ },
+
+
+ getSortParam: function() {
+ return this.dataIndex;
+ },
+
+
+
+ setSortState: function(state, skipClear, initial) {
+ var me = this,
+ colSortClsPrefix = Ext.baseCSSPrefix + 'column-header-sort-',
+ ascCls = colSortClsPrefix + 'ASC',
+ descCls = colSortClsPrefix + 'DESC',
+ nullCls = colSortClsPrefix + 'null',
+ ownerHeaderCt = me.getOwnerHeaderCt(),
+ oldSortState = me.sortState;
+
+ if (oldSortState !== state && me.getSortParam()) {
+ me.addCls(colSortClsPrefix + state);
+
+ if (state && !initial) {
+ me.doSort(state);
+ }
+ switch (state) {
+ case 'DESC':
+ me.removeCls([ascCls, nullCls]);
+ break;
+ case 'ASC':
+ me.removeCls([descCls, nullCls]);
+ break;
+ case null:
+ me.removeCls([ascCls, descCls]);
+ break;
+ }
+ if (ownerHeaderCt && !me.triStateSort && !skipClear) {
+ ownerHeaderCt.clearOtherSortStates(me);
+ }
+ me.sortState = state;
+
+ if (me.triStateSort || state != null) {
+ ownerHeaderCt.fireEvent('sortchange', ownerHeaderCt, me, state);
+ }
+ }
+ },
+
+ hide: function(fromOwner) {
+ var me = this,
+ ownerHeaderCt = me.getOwnerHeaderCt(),
+ owner = me.ownerCt,
+ ownerIsGroup = owner.isGroupHeader,
+ item, items, len, i;
+
+
+ if (ownerIsGroup && !fromOwner) {
+ items = owner.query('>:not([hidden])');
+
+ if (items.length === 1 && items[0] == me) {
+ me.ownerCt.hide();
+ return;
+ }
+ }
+
+ Ext.suspendLayouts();
+
+ if (me.isGroupHeader) {
+ items = me.items.items;
+ for (i = 0, len = items.length; i < len; i++) {
+ item = items[i];
+ if (!item.hidden) {
+ item.hide(true);
+ }
+ }
+ }
+
+ me.callParent();
+
+ ownerHeaderCt.onHeaderHide(me);
+
+ Ext.resumeLayouts(true);
+ },
+
+ show: function(fromOwner, fromChild) {
+ var me = this,
+ ownerCt = me.ownerCt,
+ items,
+ len, i,
+ item;
+
+ Ext.suspendLayouts();
+
+
+ if (me.isSubHeader && ownerCt.hidden) {
+ ownerCt.show(false, true);
+ }
+
+ me.callParent(arguments);
+
+
+ if (me.isGroupHeader && fromChild !== true && !me.query(':not([hidden])').length) {
+ items = me.query('>*');
+ for (i = 0, len = items.length; i < len; i++) {
+ item = items[i];
+ if (item.hidden) {
+ item.show(true);
+ }
+ }
+ }
+
+ Ext.resumeLayouts(true);
+
+
+ ownerCt = me.getOwnerHeaderCt();
+ if (ownerCt) {
+ ownerCt.onHeaderShow(me);
+ }
+ },
+
+ getDesiredWidth: function() {
+ var me = this;
+ if (me.rendered && me.componentLayout && me.componentLayout.lastComponentSize) {
+
+
+
+
+
+
+ return me.componentLayout.lastComponentSize.width;
+
+
+
+ }
+ else if (me.flex) {
+
+ return me.width;
+ }
+ else {
+ return me.width;
+ }
+ },
+
+ getCellSelector: function() {
+ return '.' + Ext.baseCSSPrefix + 'grid-cell-' + this.getItemId();
+ },
+
+ getCellInnerSelector: function() {
+ return this.getCellSelector() + ' .' + Ext.baseCSSPrefix + 'grid-cell-inner';
+ },
+
+ isOnLeftEdge: function(e) {
+ return (e.getXY()[0] - this.el.getLeft() <= this.handleWidth);
+ },
+
+ isOnRightEdge: function(e) {
+ return (this.el.getRight() - e.getXY()[0] <= this.handleWidth);
+ }
+
+
+
+
+
+
+});
+
+
+Ext.define('Ext.grid.RowNumberer', {
+ extend: 'Ext.grid.column.Column',
+ alias: 'widget.rownumberer',
+
+
+ text: " ",
+
+
+ width: 23,
+
+
+ sortable: false,
+
+
+ draggable: false,
+
+ align: 'right',
+
+ constructor : function(config){
+
+
+
+ this.width = this.width;
+
+ this.callParent(arguments);
+ if (this.rowspan) {
+ this.renderer = Ext.Function.bind(this.renderer, this);
+ }
+ },
+
+
+ resizable: false,
+ hideable: false,
+ menuDisabled: true,
+ dataIndex: '',
+ cls: Ext.baseCSSPrefix + 'row-numberer',
+ rowspan: undefined,
+
+
+ renderer: function(value, metaData, record, rowIdx, colIdx, store) {
+ if (this.rowspan){
+ metaData.cellAttr = 'rowspan="'+this.rowspan+'"';
+ }
+
+ metaData.tdCls = Ext.baseCSSPrefix + 'grid-cell-special';
+ return store.indexOfTotal(record) + 1;
+ }
+});
+
+
+
+Ext.define('Ext.view.DropZone', {
+ extend: 'Ext.dd.DropZone',
+
+ indicatorHtml: '',
+ indicatorCls: Ext.baseCSSPrefix + '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 = new Ext.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,
+ 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,
+ dropHandled = false,
+
+
+
+
+
+
+ dropHandlers = {
+ wait: false,
+ processDrop: function () {
+ me.invalidateDrop();
+ me.handleNodeDrop(data, me.overRecord, me.currentPosition);
+ dropHandled = true;
+ me.fireViewEvent('drop', node, data, me.overRecord, me.currentPosition);
+ },
+
+ cancelDrop: function() {
+ me.invalidateDrop();
+ dropHandled = true;
+ }
+ },
+ performOperation = false;
+
+ if (me.valid) {
+ performOperation = me.fireViewEvent('beforedrop', node, data, me.overRecord, me.currentPosition, dropHandlers);
+ if (dropHandlers.wait) {
+ return;
+ }
+
+ if (performOperation !== false) {
+
+ if (!dropHandled) {
+ dropHandlers.processDrop();
+ }
+ }
+ }
+ return performOperation;
+ },
+
+ destroy: function(){
+ Ext.destroy(this.indicator);
+ delete this.indicator;
+ this.callParent();
+ }
+});
+
+
+Ext.define('Ext.grid.ViewDropZone', {
+ extend: 'Ext.view.DropZone',
+
+ indicatorHtml: '',
+ indicatorCls: Ext.baseCSSPrefix + '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',
+
+
+
+
+
+
+
+
+
+
+
+
+ actionIdRe: new RegExp(Ext.baseCSSPrefix + 'action-col-(\\d+)'),
+
+
+ altText: '',
+
+
+ menuText: 'Actions',
+
+ sortable: false,
+
+ constructor: function(config) {
+ var me = this,
+ cfg = Ext.apply({}, config),
+ items = cfg.items || [me],
+ hasGetClass,
+ i,
+ len;
+
+
+ me.origRenderer = cfg.renderer || me.renderer;
+ me.origScope = cfg.scope || me.scope;
+
+ delete me.renderer;
+ delete me.scope;
+ delete cfg.renderer;
+ delete cfg.scope;
+
+
+ delete cfg.items;
+ me.callParent([cfg]);
+
+
+ me.items = items;
+
+ for (i = 0, len = items.length; i < len; ++i) {
+ if (items[i].getClass) {
+ hasGetClass = true;
+ break;
+ }
+ }
+
+
+ if (me.origRenderer || hasGetClass) {
+ me.hasCustomRenderer = true;
+ }
+ },
+
+
+
+ defaultRenderer: function(v, meta){
+ var me = this,
+ prefix = Ext.baseCSSPrefix,
+ scope = me.origScope || me,
+ items = me.items,
+ len = items.length,
+ i = 0,
+ item;
+
+
+ v = Ext.isFunction(me.origRenderer) ? me.origRenderer.apply(scope, arguments) || '' : '';
+
+ meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
+ for (; i < len; i++) {
+ item = items[i];
+
+
+ if (!item.hasActionConfiguration) {
+
+
+ item.stopSelection = me.stopSelection;
+ item.disable = Ext.Function.bind(me.disableAction, me, [i], 0);
+ item.enable = Ext.Function.bind(me.enableAction, me, [i], 0);
+ item.hasActionConfiguration = true;
+ }
+
+ v += '';
+ },
+ closeTableWrap: function() {
+ return '
{collapsed}{[this.renderGroupHeaderTpl(values, parent)]}
{rowBody}
',
+ '');
+
+
+ metaRowTpl.push(' |
',
+ '{%this.renderBody(out,values)%}',
+ '',
+ '
',
+ '{%this.renderPadder(out,values)%}'
+ ],
+
+ getItemSizePolicy: function (item) {
+ if (item.columnWidth) {
+ return this.columnWidthSizePolicy;
+ }
+ return this.autoSizePolicy;
+ },
+
+ beginLayout: function() {
+ this.callParent(arguments);
+ this.innerCt.dom.style.width = '';
+ },
+
+ calculate: function (ownerContext) {
+ var me = this,
+ containerSize = me.getContainerSize(ownerContext),
+ state = ownerContext.state;
+
+ if (state.calculatedColumns || (state.calculatedColumns = me.calculateColumns(ownerContext))) {
+ if (me.calculateHeights(ownerContext)) {
+ me.calculateOverflow(ownerContext, containerSize);
+ return;
+ }
+ }
+
+ me.done = false;
+ },
+
+ calculateColumns: function (ownerContext) {
+ var me = this,
+ containerSize = me.getContainerSize(ownerContext),
+ innerCtContext = ownerContext.getEl('innerCt', me),
+ items = ownerContext.childItems,
+ len = items.length,
+ contentWidth = 0,
+ blocked, availableWidth, i, itemContext, itemMarginWidth, itemWidth;
+
+
+
+
+ if (!ownerContext.heightModel.shrinkWrap && !ownerContext.targetContext.hasProp('height')) {
+ return false;
+ }
+
+
+ if (!containerSize.gotWidth) {
+ ownerContext.targetContext.block(me, 'width');
+ blocked = true;
+ } else {
+ availableWidth = containerSize.width;
+
+ innerCtContext.setWidth(availableWidth);
+ }
+
+
+
+ for (i = 0; i < len; ++i) {
+ itemContext = items[i];
+
+
+
+
+ itemMarginWidth = itemContext.getMarginInfo().width;
+
+ if (!itemContext.widthModel.calculated) {
+ itemWidth = itemContext.getProp('width');
+ if (typeof itemWidth != 'number') {
+ itemContext.block(me, 'width');
+ blocked = true;
+ }
+
+ contentWidth += itemWidth + itemMarginWidth;
+ }
+ }
+
+ if (!blocked) {
+ availableWidth = (availableWidth < contentWidth) ? 0 : availableWidth - contentWidth;
+
+ for (i = 0; i < len; ++i) {
+ itemContext = items[i];
+ if (itemContext.widthModel.calculated) {
+ itemMarginWidth = itemContext.marginInfo.width;
+ itemWidth = itemContext.target.columnWidth;
+ itemWidth = Math.floor(itemWidth * availableWidth) - itemMarginWidth;
+ itemWidth = itemContext.setWidth(itemWidth);
+ contentWidth += itemWidth + itemMarginWidth;
+ }
+ }
+
+ ownerContext.setContentWidth(contentWidth);
+ }
+
+
+ return !blocked;
+ },
+
+ calculateHeights: function (ownerContext) {
+ var me = this,
+ items = ownerContext.childItems,
+ len = items.length,
+ blocked, i, itemContext;
+
+
+
+ blocked = false;
+ for (i = 0; i < len; ++i) {
+ itemContext = items[i];
+
+ if (!itemContext.hasDomProp('height')) {
+ itemContext.domBlock(me, 'height');
+ blocked = true;
+ }
+ }
+
+ if (!blocked) {
+ ownerContext.setContentHeight(me.innerCt.getHeight() + ownerContext.targetContext.getPaddingInfo().height);
+ }
+
+ return !blocked;
+ },
+
+ finishedLayout: function (ownerContext) {
+ var bc = ownerContext.bodyContext;
+
+
+ if (bc && (Ext.isIE6 || Ext.isIE7 || Ext.isIEQuirks)) {
+
+ bc.el.repaint();
+ }
+
+ this.callParent(arguments);
+ },
+
+ getRenderTarget : function() {
+ return this.innerCt;
+ }
+});
+
+
+Ext.define('Ext.layout.container.Form', {
+
+
+
+ alias: 'layout.form',
+ extend: 'Ext.layout.container.Auto',
+ alternateClassName: 'Ext.layout.FormLayout',
+
+
+
+ tableCls: Ext.baseCSSPrefix + 'form-layout-table',
+
+ type: 'form',
+
+ manageOverflow: 2,
+
+ childEls: ['formTable'],
+
+ padRow: ' {baseCls}-body-{ui} {parent.baseCls}-body-{parent.ui}-{.} " style="{bodyStyle}" >',
+ '{%this.renderContainer(out,values)%}',
+ '
',
+ ' {baseCls}-strip-{ui} {parent.baseCls}-strip-{parent.ui}-{.} ">
'
+ ],
+
+
+
+
+
+
+ initComponent: function() {
+ var me = this;
+
+ if (me.plain) {
+ me.setUI(me.ui + '-plain');
+ }
+
+ me.addClsWithUI(me.dock);
+
+ me.addEvents(
+
+ 'change'
+ );
+
+
+ me.callParent(arguments);
+
+
+ me.layout.align = (me.orientation == 'vertical') ? 'left' : 'top';
+ me.layout.overflowHandler = new Ext.layout.container.boxOverflow.Scroller(me.layout);
+
+ me.remove(me.titleCmp);
+ delete me.titleCmp;
+
+ Ext.apply(me.renderData, {
+ bodyCls: me.bodyCls
+ });
+ },
+
+ getLayout: function() {
+ var me = this;
+ me.layout.type = (me.dock === 'top' || me.dock === 'bottom') ? 'hbox' : 'vbox';
+ return me.callParent(arguments);
+ },
+
+
+ onAdd: function(tab) {
+ tab.position = this.dock;
+ this.callParent(arguments);
+ },
+
+ onRemove: function(tab) {
+ var me = this;
+
+ if (tab === me.previousTab) {
+ me.previousTab = null;
+ }
+ me.callParent(arguments);
+ },
+
+ afterComponentLayout : function(width) {
+ this.callParent(arguments);
+ this.strip.setWidth(width);
+ },
+
+
+ onClick: function(e, target) {
+
+ var me = this,
+ tabEl = e.getTarget('.' + Ext.tab.Tab.prototype.baseCls),
+ tab = tabEl && Ext.getCmp(tabEl.id),
+ tabPanel = me.tabPanel,
+ isCloseClick = tab && tab.closeEl && (target === tab.closeEl.dom);
+
+ if (isCloseClick) {
+ e.preventDefault();
+ }
+ if (tab && tab.isDisabled && !tab.isDisabled()) {
+ if (tab.closable && isCloseClick) {
+ tab.onCloseClick();
+ } else {
+ if (tabPanel) {
+
+ tabPanel.setActiveTab(tab.card);
+ } else {
+ me.setActiveTab(tab);
+ }
+ tab.focus();
+ }
+ }
+ },
+
+
+ closeTab: function(toClose) {
+ var me = this,
+ card = toClose.card,
+ tabPanel = me.tabPanel,
+ toActivate;
+
+ if (card && card.fireEvent('beforeclose', card) === false) {
+ return false;
+ }
+
+
+
+
+ toActivate = me.findNextActivatable(toClose);
+
+
+
+ Ext.suspendLayouts();
+
+ if (tabPanel && card) {
+
+
+ delete toClose.ownerCt;
+
+
+
+ card.fireEvent('close', card);
+ tabPanel.remove(card);
+
+
+ if (!tabPanel.getComponent(card)) {
+
+ toClose.fireClose();
+ me.remove(toClose);
+ } else {
+
+ toClose.ownerCt = me;
+ Ext.resumeLayouts(true);
+ return false;
+ }
+ }
+
+
+ if (toActivate) {
+
+
+ if (tabPanel) {
+ tabPanel.setActiveTab(toActivate.card);
+ } else {
+ me.setActiveTab(toActivate);
+ }
+ toActivate.focus();
+ }
+ Ext.resumeLayouts(true);
+ },
+
+
+
+ findNextActivatable: function(toClose) {
+ var me = this;
+ if (toClose.active && me.items.getCount() > 1) {
+ return (me.previousTab && me.previousTab !== toClose && !me.previousTab.disabled) ? me.previousTab : (toClose.next('tab[disabled=false]') || toClose.prev('tab[disabled=false]'));
+ }
+ },
+
+
+ setActiveTab: function(tab) {
+ var me = this;
+
+ if (!tab.disabled && tab !== me.activeTab) {
+ if (me.activeTab) {
+ if (me.activeTab.isDestroyed) {
+ me.previousTab = null;
+ } else {
+ me.previousTab = me.activeTab;
+ me.activeTab.deactivate();
+ }
+ }
+ tab.activate();
+
+ me.activeTab = tab;
+ me.fireEvent('change', me, tab, tab.card);
+
+
+ me.on({
+ afterlayout: me.afterTabActivate,
+ scope: me,
+ single: true
+ });
+ me.updateLayout();
+ }
+ },
+
+ afterTabActivate: function() {
+ this.layout.overflowHandler.scrollToItem(this.activeTab);
+ }
+});
+
+
+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: Ext.baseCSSPrefix + 'tabpanel-child',
+
+
+ minTabWidth: undefined,
+
+
+ maxTabWidth: undefined,
+
+
+ deferredRender : true,
+
+
+ initComponent: function() {
+ var me = this,
+ dockedItems = [].concat(me.dockedItems || []),
+ activeTab = me.activeTab || (me.activeTab = 0);
+
+
+ me.layout = new Ext.layout.container.Card(Ext.apply({
+ owner: me,
+ deferredRender: me.deferredRender,
+ itemCls: me.itemCls,
+ activeItem: me.activeTab
+ }, me.layout));
+
+
+ me.tabBar = new Ext.tab.Bar(Ext.apply({
+ dock: me.tabPosition,
+ plain: me.plain,
+ border: me.border,
+ cardLayout: me.layout,
+ tabPanel: me
+ }, me.tabBar));
+
+ dockedItems.push(me.tabBar);
+ me.dockedItems = dockedItems;
+
+ me.addEvents(
+
+ 'beforetabchange',
+
+
+ 'tabchange'
+ );
+
+ me.callParent(arguments);
+
+
+ me.activeTab = me.getComponent(activeTab);
+
+
+ if (me.activeTab) {
+ me.activeTab.tab.activate(true);
+
+
+ me.tabBar.activeTab = me.activeTab.tab;
+ }
+ },
+
+
+ setActiveTab: function(card) {
+ var me = this,
+ previous;
+
+ card = me.getComponent(card);
+ if (card) {
+ previous = me.getActiveTab();
+
+ if (previous !== card && me.fireEvent('beforetabchange', me, card, previous) === false) {
+ return false;
+ }
+
+
+
+ if (!card.isComponent) {
+ Ext.suspendLayouts();
+ card = me.add(card);
+ Ext.resumeLayouts();
+ }
+
+
+
+ me.activeTab = card;
+
+
+
+
+ Ext.suspendLayouts();
+ me.layout.setActiveItem(card);
+
+
+ card = me.activeTab = me.layout.getActiveItem();
+
+
+ if (card && card !== previous) {
+
+
+ me.tabBar.setActiveTab(card.tab);
+ Ext.resumeLayouts(true);
+
+
+ if (previous !== card) {
+ me.fireEvent('tabchange', me, card, previous);
+ }
+ }
+
+ else {
+ Ext.resumeLayouts(true);
+ }
+ return card;
+ }
+ },
+
+
+ getActiveTab: function() {
+ var me = this,
+
+ result = me.getComponent(me.activeTab);
+
+
+ if (result && me.items.indexOf(result) != -1) {
+ me.activeTab = result;
+ } else {
+ me.activeTab = null;
+ }
+
+ return me.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 && !item.hiddenByLayout,
+ tooltip: item.tooltip,
+ tabBar: me.tabBar,
+ 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,
+ iconclschange: me.onItemIconClsChange,
+ titlechange: me.onItemTitleChange
+ });
+
+ if (item.isPanel) {
+ if (me.removePanelHeader) {
+ if (item.rendered) {
+ if (item.header) {
+ item.header.hide();
+ }
+ } else {
+ item.header = false;
+ }
+ }
+ if (item.isPanel && me.border) {
+ item.setBorder(false);
+ }
+ }
+ },
+
+
+ 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, newIcon) {
+ item.tab.setIcon(newIcon);
+ },
+
+
+ onItemIconClsChange: function(item, newIconCls) {
+ item.tab.setIconCls(newIconCls);
+ },
+
+
+ onItemTitleChange: function(item, newTitle) {
+ item.tab.setText(newTitle);
+ },
+
+
+ doRemove: function(item, autoDestroy) {
+ var me = this,
+ toActivate;
+
+
+ if (me.destroying || me.items.getCount() == 1) {
+ me.activeTab = null;
+ }
+
+
+
+ else if ((toActivate = me.tabBar.items.indexOf(me.tabBar.findNextActivatable(item.tab))) !== -1) {
+ me.setActiveTab(toActivate);
+ }
+ this.callParent(arguments);
+
+
+ delete item.tab.card;
+ delete item.tab;
+ },
+
+
+ onRemove: function(item, destroying) {
+ 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',
+
+ tdCls: Ext.baseCSSPrefix + 'grid-cell-treecolumn',
+
+ treePrefix: Ext.baseCSSPrefix + 'tree-',
+ elbowPrefix: Ext.baseCSSPrefix + 'tree-elbow-',
+ expanderCls: Ext.baseCSSPrefix + 'tree-expander',
+ imgText: '',
+ '',
+ thHtml,
+ '
',
+ '
',
+ '' +
+ Ext.util.Format.htmlEncode(token) +
+ '
',
+ doc;
+
+ try {
+ 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,
+ doc, elem, oldToken, oldHash;
+
+ if (!contentWindow || !contentWindow.document) {
+ Ext.Function.defer(this.checkIFrame, 10, this);
+ return;
+ }
+
+ 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);
+ me.setHash(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,
+ hash;
+
+ me.currentToken = me.hiddenField.value || this.getHash();
+
+ if (me.oldIEMode) {
+ me.checkIFrame();
+ } else {
+ 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);
+ }
+
+ },
+
+
+ init: function (onReady, scope) {
+ var me = this,
+ DomHelper = Ext.DomHelper;
+
+ 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.hiddenField) {
+ me.hiddenField = Ext.getBody().createChild({
+ id: Ext.id(),
+ tag: 'form',
+ cls: Ext.baseCSSPrefix + 'hide-display',
+ children: [{
+ tag: 'input',
+ type: 'hidden',
+ id: me.fieldId
+ }]
+ }, false, true).firstChild;
+ }
+
+ if (me.oldIEMode) {
+ me.iframe = Ext.getDom(me.iframeId);
+ if (!me.iframe) {
+ me.iframe = DomHelper.append(me.hiddenField.parentNode, {
+ tag: 'iframe',
+ id: me.iframeId,
+ src: Ext.SSL_SECURE_URL
+ });
+ }
+ }
+
+ 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 {
+ me.setHash(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.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.TableChunker', {
+ singleton: true,
+ requires: ['Ext.XTemplate'],
+ metaTableTpl: [
+ '{%if (this.openTableWrap)out.push(this.openTableWrap())%}',
+ '| ', + ' |
|---|
{{id}}
',
+ '