)((\n|\r|.)*?)(?:<\/script>)/ig,
srcRe = /\ssrc=([\'\"])(.*?)\1/i,
nonSpaceRe = /\S/,
typeRe = /\stype=([\'\"])(.*?)\1/i,
msRe = /^-ms-/,
camelRe = /(-[a-z])/gi,
camelReplaceFn = function(m, a) {
return a.charAt(1).toUpperCase();
},
XMASKED = Ext.baseCSSPrefix + "masked",
XMASKEDRELATIVE = Ext.baseCSSPrefix + "masked-relative",
EXTELMASKMSG = Ext.baseCSSPrefix + "mask-msg",
bodyRe = /^body/i,
propertyCache = {},
getDisplay = function(el) {
var data = el.getData(),
display = data[ORIGINALDISPLAY];
if (display === undefined) {
data[ORIGINALDISPLAY] = display = '';
}
return display;
},
getVisMode = function(el) {
var data = el.getData(),
visMode = data[VISMODE];
if (visMode === undefined) {
data[VISMODE] = visMode = Element.VISIBILITY;
}
return visMode;
},
emptyRange = DOC.createRange ? DOC.createRange() : null,
inputTags = {
INPUT: true,
TEXTAREA: true
};
if (Ext.isIE8) {
var removeNode = Ext.removeNode,
garbageBin = DOC.createElement('div'),
destroyQueue = [],
clearGarbage = Ext.Function.createBuffered(function() {
var len = destroyQueue.length,
i;
for (i = 0; i < len; i++) {
garbageBin.appendChild(destroyQueue[i]);
}
garbageBin.innerHTML = '';
destroyQueue.length = 0;
}, 10);
Ext.removeNode = function(node) {
node = node.dom || node;
removeNode(node);
destroyQueue[destroyQueue.length] = node;
clearGarbage();
};
}
return {
override: 'Ext.dom.Element',
mixins: [
'Ext.util.Animate'
],
uses: [
'Ext.dom.GarbageCollector',
'Ext.dom.Fly',
'Ext.event.publisher.MouseEnterLeave',
'Ext.fx.Manager',
'Ext.fx.Anim'
],
skipGarbageCollection: false,
_init: function(E) {
Element = E;
},
statics: {
selectableCls: Ext.baseCSSPrefix + 'selectable',
unselectableCls: Ext.baseCSSPrefix + 'unselectable',
tabIndexAttributeName: Ext.isIE8 ? 'tabIndex' : 'tabindex',
tabbableSelector: 'a[href],button,iframe,input,select,textarea,[tabindex],[contenteditable="true"]',
naturallyFocusableTags: {
BUTTON: true,
IFRAME: true,
EMBED: true,
INPUT: true,
OBJECT: true,
SELECT: true,
TEXTAREA: true,
HTML: Ext.isIE ? true : false
},
naturallyTabbableTags: {
BUTTON: true,
IFRAME: true,
INPUT: true,
SELECT: true,
TEXTAREA: true,
OBJECT: Ext.isIE8m ? true : false
},
tabbableSavedFlagAttribute: 'data-tabindexsaved',
tabbableSavedAttribute: 'data-savedtabindex',
normalize: function(prop) {
if (prop === 'float') {
prop = Ext.supports.Float ? 'cssFloat' : 'styleFloat';
}
return propertyCache[prop] || (propertyCache[prop] = prop.replace(msRe, 'ms-').replace(camelRe, camelReplaceFn));
},
getViewportHeight: function() {
return Ext.isIE9m ? DOC.documentElement.clientHeight : WIN.innerHeight;
},
getViewportWidth: function() {
return (!Ext.isStrict && !Ext.isOpera) ? document.body.clientWidth : Ext.isIE9m ? DOC.documentElement.clientWidth : WIN.innerWidth;
}
},
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).addCls(className);
var d = Ext.getDoc(),
fn = function() {
Ext.fly(dom).removeCls(className);
d.removeListener("mouseup", fn);
};
d.on("mouseup", fn);
});
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).addCls(className);
});
me.on("blur", function() {
Ext.fly(dom).removeCls(className);
});
return me;
},
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).addCls(className);
}, function() {
Ext.fly(dom).removeCls(className);
});
return me;
},
addKeyListener: function(key, fn, scope) {
var config;
if (typeof key !== 'object' || Ext.isArray(key)) {
config = {
target: this,
key: key,
fn: fn,
scope: scope
};
} else {
config = {
target: this,
key: key.key,
shift: key.shift,
ctrl: key.ctrl,
alt: key.alt,
fn: fn,
scope: scope
};
}
return new Ext.util.KeyMap(config);
},
addKeyMap: function(config) {
return new Ext.util.KeyMap(Ext.apply({
target: this
}, config));
},
afterAnimate: function() {
var shadow = this.shadow;
if (shadow && !shadow.disabled && !shadow.animate) {
shadow.show();
}
},
anchorAnimX: function(anchor) {
var xName = (anchor === 'l') ? 'right' : 'left';
this.dom.style[xName] = '0px';
},
anim: function(config) {
if (!Ext.isObject(config)) {
return (config) ? {} : false;
}
var me = this,
duration = config.duration || Ext.fx.Anim.prototype.duration,
easing = config.easing || 'ease',
animConfig;
if (config.stopAnimation) {
me.stopAnimation();
}
Ext.applyIf(config, Ext.fx.Manager.getFxDefaults(me.id));
Ext.fx.Manager.setFxDefaults(me.id, {
delay: 0
});
animConfig = {
target: me.dom,
remove: config.remove,
alternate: config.alternate || false,
duration: duration,
easing: easing,
callback: config.callback,
listeners: config.listeners,
iterations: config.iterations || 1,
scope: config.scope,
block: config.block,
concurrent: config.concurrent,
delay: config.delay || 0,
paused: true,
keyframes: config.keyframes,
from: config.from || {},
to: Ext.apply({}, config)
};
Ext.apply(animConfig.to, config.to);
delete animConfig.to.to;
delete animConfig.to.from;
delete animConfig.to.remove;
delete animConfig.to.alternate;
delete animConfig.to.keyframes;
delete animConfig.to.iterations;
delete animConfig.to.listeners;
delete animConfig.to.target;
delete animConfig.to.paused;
delete animConfig.to.callback;
delete animConfig.to.scope;
delete animConfig.to.duration;
delete animConfig.to.easing;
delete animConfig.to.concurrent;
delete animConfig.to.block;
delete animConfig.to.stopAnimation;
delete animConfig.to.delay;
return animConfig;
},
animate: function(config) {
var me = this,
animId = me.dom.id || Ext.id(me.dom),
listeners, anim, end;
if (!Ext.fx.Manager.hasFxBlock(animId)) {
if (config.listeners) {
listeners = config.listeners;
delete config.listeners;
}
if (config.internalListeners) {
config.listeners = config.internalListeners;
delete config.internalListeners;
}
end = config.autoEnd;
delete config.autoEnd;
anim = new Ext.fx.Anim(me.anim(config));
anim.on({
afteranimate: 'afterAnimate',
beforeanimate: 'beforeAnimate',
scope: me,
single: true
});
if (listeners) {
anim.on(listeners);
}
Ext.fx.Manager.queueFx(anim);
if (end) {
anim.jumpToEnd();
}
}
return me;
},
beforeAnimate: function() {
var shadow = this.shadow;
if (shadow && !shadow.disabled && !shadow.animate) {
shadow.hide();
}
},
boxWrap: function(cls) {
cls = cls || Ext.baseCSSPrefix + 'box';
var el = Ext.get(this.insertHtml("beforeBegin", "" + Ext.String.format(boxMarkup, cls) + "
"));
el.selectNode('.' + cls + '-mc').appendChild(this.dom);
return el;
},
clean: function(forceReclean) {
var me = this,
dom = me.dom,
data = me.getData(),
n = dom.firstChild,
ni = -1,
nx;
if (data.isCleaned && forceReclean !== true) {
return me;
}
while (n) {
nx = n.nextSibling;
if (n.nodeType === 3) {
if (!(nonSpaceRe.test(n.nodeValue))) {
dom.removeChild(n);
}
else if (nx && nx.nodeType === 3) {
n.appendData(Ext.String.trim(nx.data));
dom.removeChild(nx);
nx = n.nextSibling;
n.nodeIndex = ++ni;
}
} else {
Ext.fly(n, '_clean').clean();
n.nodeIndex = ++ni;
}
n = nx;
}
data.isCleaned = true;
return me;
},
empty: emptyRange ? function() {
var dom = this.dom;
if (dom.firstChild) {
emptyRange.setStartBefore(dom.firstChild);
emptyRange.setEndAfter(dom.lastChild);
emptyRange.deleteContents();
}
} : function() {
var dom = this.dom;
while (dom.lastChild) {
dom.removeChild(dom.lastChild);
}
},
clearListeners: function() {
this.removeAnchor();
this.callParent();
},
clearPositioning: function(value) {
value = value || '';
return this.setStyle({
left: value,
right: value,
top: value,
bottom: value,
'z-index': '',
position: 'static'
});
},
createProxy: function(config, renderTo, matchBox) {
config = (typeof config === 'object') ? config : {
tag: "div",
role: 'presentation',
cls: config
};
var me = this,
proxy = renderTo ? Ext.DomHelper.append(renderTo, config, true) : Ext.DomHelper.insertBefore(me.dom, config, true);
proxy.setVisibilityMode(Element.DISPLAY);
proxy.hide();
if (matchBox && me.setBox && me.getBox) {
proxy.setBox(me.getBox());
}
return proxy;
},
clearOpacity: function() {
return this.setOpacity('');
},
clip: function() {
var me = this,
data = me.getData(),
style;
if (!data[ISCLIPPED]) {
data[ISCLIPPED] = true;
style = me.getStyle([
OVERFLOW,
OVERFLOWX,
OVERFLOWY
]);
data[ORIGINALCLIP] = {
o: style[OVERFLOW],
x: style[OVERFLOWX],
y: style[OVERFLOWY]
};
me.setStyle(OVERFLOW, HIDDEN);
me.setStyle(OVERFLOWX, HIDDEN);
me.setStyle(OVERFLOWY, HIDDEN);
}
return me;
},
destroy: function() {
var me = this,
dom = me.dom,
data = me.getData(),
maskEl, maskMsg;
if (dom && me.isAnimate) {
me.stopAnimation();
}
me.callParent();
if (dom && Ext.isIE8 && (dom.window != dom) && (dom.nodeType !== 9) && (dom.tagName !== 'BODY') && (dom.tagName !== 'HTML')) {
destroyQueue[destroyQueue.length] = dom;
clearGarbage();
}
if (data) {
maskEl = data.maskEl;
maskMsg = data.maskMsg;
if (maskEl) {
maskEl.destroy();
}
if (maskMsg) {
maskMsg.destroy();
}
}
},
enableDisplayMode: function(display) {
var me = this;
me.setVisibilityMode(Element.DISPLAY);
if (display !== undefined) {
me.getData()[ORIGINALDISPLAY] = display;
}
return me;
},
fadeIn: function(o) {
var me = this,
dom = me.dom;
me.animate(Ext.apply({}, o, {
opacity: 1,
internalListeners: {
beforeanimate: function(anim) {
var el = Ext.fly(dom, '_anim');
if (el.isStyle('display', 'none')) {
el.setDisplayed('');
} else {
el.show();
}
}
}
}));
return this;
},
fadeOut: function(o) {
var me = this,
dom = me.dom;
o = Ext.apply({
opacity: 0,
internalListeners: {
afteranimate: function(anim) {
if (dom && anim.to.opacity === 0) {
var el = Ext.fly(dom, '_anim');
if (o.useDisplay) {
el.setDisplayed(false);
} else {
el.hide();
}
}
}
}
}, o);
me.animate(o);
return me;
},
fixDisplay: function() {
var me = this;
if (me.isStyle(DISPLAY, NONE)) {
me.setStyle(VISIBILITY, HIDDEN);
me.setStyle(DISPLAY, getDisplay(me));
if (me.isStyle(DISPLAY, NONE)) {
me.setStyle(DISPLAY, "block");
}
}
},
frame: function(color, count, obj) {
var me = this,
dom = me.dom,
beforeAnim;
color = color || '#C3DAF9';
count = count || 1;
obj = obj || {};
beforeAnim = function() {
var el = Ext.fly(dom, '_anim'),
animScope = this,
box, proxy, proxyAnim;
el.show();
box = el.getBox();
proxy = Ext.getBody().createChild({
role: 'presentation',
id: el.dom.id + '-anim-proxy',
style: {
position: 'absolute',
'pointer-events': 'none',
'z-index': 35000,
border: '0px solid ' + color
}
});
proxyAnim = new Ext.fx.Anim({
target: proxy,
duration: obj.duration || 1000,
iterations: count,
from: {
top: box.y,
left: box.x,
borderWidth: 0,
opacity: 1,
height: box.height,
width: box.width
},
to: {
top: box.y - 20,
left: box.x - 20,
borderWidth: 10,
opacity: 0,
height: box.height + 40,
width: box.width + 40
}
});
proxyAnim.on('afteranimate', function() {
proxy.destroy();
animScope.end();
});
};
me.animate({
duration: (Math.max(obj.duration, 500) * 2) || 2000,
listeners: {
beforeanimate: {
fn: beforeAnim
}
},
callback: obj.callback,
scope: obj.scope
});
return me;
},
getColor: function(attr, defaultValue, prefix) {
var v = this.getStyle(attr),
color = prefix || prefix === '' ? prefix : '#',
h, len,
i = 0;
if (!v || (/transparent|inherit/.test(v))) {
return defaultValue;
}
if (/^r/.test(v)) {
v = v.slice(4, v.length - 1).split(',');
len = v.length;
for (; i < len; i++) {
h = parseInt(v[i], 10);
color += (h < 16 ? '0' : '') + h.toString(16);
}
} else {
v = v.replace('#', '');
color += v.length === 3 ? v.replace(/^(\w)(\w)(\w)$/, '$1$1$2$2$3$3') : v;
}
return (color.length > 5 ? color.toLowerCase() : defaultValue);
},
getLoader: function() {
var me = this,
data = me.getData(),
loader = data.loader;
if (!loader) {
data.loader = loader = new Ext.ElementLoader({
target: me
});
}
return loader;
},
getPositioning: function(autoPx) {
var styles = this.getStyle([
'left',
'top',
'position',
'z-index'
]),
dom = this.dom;
if (autoPx) {
if (styles.left === 'auto') {
styles.left = dom.offsetLeft + 'px';
}
if (styles.top === 'auto') {
styles.top = dom.offsetTop + 'px';
}
}
return styles;
},
ghost: function(anchor, obj) {
var me = this,
dom = me.dom,
beforeAnim;
anchor = anchor || "b";
beforeAnim = function() {
var el = Ext.fly(dom, '_anim'),
width = el.getWidth(),
height = el.getHeight(),
xy = el.getXY(),
position = el.getPositioning(),
to = {
opacity: 0
};
switch (anchor) {
case 't':
to.y = xy[1] - height;
break;
case 'l':
to.x = xy[0] - width;
break;
case 'r':
to.x = xy[0] + width;
break;
case 'b':
to.y = xy[1] + height;
break;
case 'tl':
to.x = xy[0] - width;
to.y = xy[1] - height;
break;
case 'bl':
to.x = xy[0] - width;
to.y = xy[1] + height;
break;
case 'br':
to.x = xy[0] + width;
to.y = xy[1] + height;
break;
case 'tr':
to.x = xy[0] + width;
to.y = xy[1] - height;
break;
}
this.to = to;
this.on('afteranimate', function() {
var el = Ext.fly(dom, '_anim');
if (el) {
el.hide();
el.clearOpacity();
el.setPositioning(position);
}
});
};
me.animate(Ext.applyIf(obj || {}, {
duration: 500,
easing: 'ease-out',
listeners: {
beforeanimate: beforeAnim
}
}));
return me;
},
hide: function(animate) {
if (typeof animate === 'string') {
this.setVisible(false, animate);
return this;
}
this.setVisible(false, this.anim(animate));
return this;
},
highlight: function(color, o) {
var me = this,
dom = me.dom,
from = {},
restore, to, attr, lns, event, fn;
o = o || {};
lns = o.listeners || {};
attr = o.attr || 'backgroundColor';
from[attr] = color || 'ffff9c';
if (!o.to) {
to = {};
to[attr] = o.endColor || me.getColor(attr, 'ffffff', '');
} else {
to = o.to;
}
o.listeners = Ext.apply(Ext.apply({}, lns), {
beforeanimate: function() {
restore = dom.style[attr];
var el = Ext.fly(dom, '_anim');
el.clearOpacity();
el.show();
event = lns.beforeanimate;
if (event) {
fn = event.fn || event;
return fn.apply(event.scope || lns.scope || WIN, arguments);
}
},
afteranimate: function() {
if (dom) {
dom.style[attr] = restore;
}
event = lns.afteranimate;
if (event) {
fn = event.fn || event;
fn.apply(event.scope || lns.scope || WIN, arguments);
}
}
});
me.animate(Ext.apply({}, o, {
duration: 1000,
easing: 'ease-in',
from: from,
to: to
}));
return me;
},
hover: function(overFn, outFn, scope, options) {
var me = this;
me.on('mouseenter', overFn, scope || me.dom, options);
me.on('mouseleave', outFn, scope || me.dom, options);
return me;
},
initDD: function(group, config, overrides) {
var dd = new Ext.dd.DD(Ext.id(this.dom), group, config);
return Ext.apply(dd, overrides);
},
initDDProxy: function(group, config, overrides) {
var dd = new Ext.dd.DDProxy(Ext.id(this.dom), group, config);
return Ext.apply(dd, overrides);
},
initDDTarget: function(group, config, overrides) {
var dd = new Ext.dd.DDTarget(Ext.id(this.dom), group, config);
return Ext.apply(dd, overrides);
},
isFocusable: function() {
var dom = this.dom,
focusable = false,
nodeName;
if (dom && !dom.disabled) {
nodeName = dom.nodeName;
focusable = !!Ext.Element.naturallyFocusableTags[nodeName] || ((nodeName === 'A' || nodeName === 'LINK') && !!dom.href) || dom.getAttribute('tabindex') != null || dom.contentEditable === 'true';
if (Ext.isIE8 && nodeName === 'INPUT' && dom.type === 'hidden') {
focusable = false;
}
focusable = focusable && this.isVisible(true);
}
return focusable;
},
isInputField: function() {
var dom = this.dom,
contentEditable = dom.contentEditable;
if ((inputTags[dom.tagName] && dom.type !== 'button') || (contentEditable === '' || contentEditable === 'true')) {
return true;
}
return false;
},
isTabbable: function() {
var dom = this.dom,
tabbable = false,
nodeName, hasIndex, tabIndex;
if (dom && !dom.disabled) {
nodeName = dom.nodeName;
tabIndex = dom.getAttribute('tabindex');
hasIndex = tabIndex != null;
tabIndex -= 0;
if (nodeName === 'A' || nodeName === 'LINK') {
if (dom.href) {
tabbable = hasIndex && tabIndex < 0 ? false : true;
} else
{
if (dom.contentEditable === 'true') {
tabbable = !hasIndex || (hasIndex && tabIndex >= 0) ? true : false;
} else {
tabbable = hasIndex && tabIndex >= 0 ? true : false;
}
}
}
else if (dom.contentEditable === 'true' || Ext.Element.naturallyTabbableTags[nodeName]) {
tabbable = hasIndex && tabIndex < 0 ? false : true;
} else
{
if (hasIndex && tabIndex >= 0) {
tabbable = true;
}
}
if (Ext.isIE8 && nodeName === 'INPUT' && dom.type === 'hidden') {
tabbable = false;
}
tabbable = tabbable && (!this.component || this.component.isVisible(true)) && this.isVisible(true);
}
return tabbable;
},
isMasked: function(deep) {
var me = this,
data = me.getData(),
maskEl = data.maskEl,
maskMsg = data.maskMsg,
hasMask = false,
parent;
if (maskEl && maskEl.isVisible()) {
if (maskMsg) {
maskMsg.center(me);
}
hasMask = true;
} else if (deep) {
parent = me.findParentNode();
if (parent) {
return Ext.fly(parent).isMasked(deep);
}
}
return hasMask;
},
isScrollable: function() {
var dom = this.dom;
return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
},
load: function(options) {
this.getLoader().load(options);
return this;
},
mask: function(msg, msgCls,
elHeight) {
var me = this,
dom = me.dom,
data = me.getData(),
maskEl = data.maskEl,
maskMsg;
if (!(bodyRe.test(dom.tagName) && me.getStyle('position') === 'static')) {
me.addCls(XMASKEDRELATIVE);
}
if (maskEl) {
maskEl.destroy();
}
maskEl = Ext.DomHelper.append(dom, {
role: 'presentation',
cls: Ext.baseCSSPrefix + "mask " + Ext.baseCSSPrefix + "border-box",
children: {
role: 'presentation',
cls: msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG,
cn: {
tag: 'div',
role: 'presentation',
cls: Ext.baseCSSPrefix + 'mask-msg-inner',
cn: {
tag: 'div',
role: 'presentation',
cls: Ext.baseCSSPrefix + 'mask-msg-text',
html: msg || ''
}
}
}
}, true);
maskMsg = Ext.get(maskEl.dom.firstChild);
data.maskEl = maskEl;
me.addCls(XMASKED);
maskEl.setDisplayed(true);
if (typeof msg === 'string') {
maskMsg.setDisplayed(true);
maskMsg.center(me);
} else {
maskMsg.setDisplayed(false);
}
if (dom === DOC.body) {
maskEl.addCls(Ext.baseCSSPrefix + 'mask-fixed');
} else {
me.saveTabbableState();
}
me.saveChildrenTabbableState();
if (Ext.isIE9m && dom !== DOC.body && me.isStyle('height', 'auto')) {
maskEl.setSize(undefined, elHeight || me.getHeight());
}
return maskEl;
},
monitorMouseLeave: function(delay, handler, scope) {
var me = this,
timer,
listeners = {
mouseleave: function(e) {
if (Ext.isIE9m) {
e.enableIEAsync();
}
timer = Ext.defer(handler, delay, scope || me, [
e
]);
},
mouseenter: function() {
clearTimeout(timer);
}
};
me.on(listeners);
return listeners;
},
puff: function(obj) {
var me = this,
dom = me.dom,
beforeAnim,
box = me.getBox(),
originalStyles = me.getStyle([
'width',
'height',
'left',
'right',
'top',
'bottom',
'position',
'z-index',
'font-size',
'opacity'
], true);
obj = Ext.applyIf(obj || {}, {
easing: 'ease-out',
duration: 500,
useDisplay: false
});
beforeAnim = function() {
var el = Ext.fly(dom, '_anim');
el.clearOpacity();
el.show();
this.to = {
width: box.width * 2,
height: box.height * 2,
x: box.x - (box.width / 2),
y: box.y - (box.height / 2),
opacity: 0,
fontSize: '200%'
};
this.on('afteranimate', function() {
var el = Ext.fly(dom, '_anim');
if (el) {
if (obj.useDisplay) {
el.setDisplayed(false);
} else {
el.hide();
}
el.setStyle(originalStyles);
Ext.callback(obj.callback, obj.scope);
}
});
};
me.animate({
duration: obj.duration,
easing: obj.easing,
listeners: {
beforeanimate: {
fn: beforeAnim
}
}
});
return me;
},
selectable: function() {
var me = this;
me.dom.unselectable = '';
me.removeCls(Element.unselectableCls);
me.addCls(Element.selectableCls);
return me;
},
setCapture: function() {
var dom = this.dom;
if (Ext.isIE9m && dom.setCapture) {
dom.setCapture();
}
},
setDisplayed: function(value) {
var me = this;
if (typeof value === "boolean") {
value = value ? getDisplay(me) : NONE;
}
me.setStyle(DISPLAY, value);
if (me.shadow || me.shim) {
me.setUnderlaysVisible(value !== NONE);
}
return me;
},
setHeight: function(height, animate) {
var me = this;
if (!animate || !me.anim) {
me.callParent(arguments);
} else {
if (!Ext.isObject(animate)) {
animate = {};
}
me.animate(Ext.applyIf({
to: {
height: height
}
}, animate));
}
return me;
},
setHorizontal: function() {
var me = this,
cls = me.verticalCls;
delete me.vertical;
if (cls) {
delete me.verticalCls;
me.removeCls(cls);
}
delete me.setWidth;
delete me.setHeight;
if (!Ext.isIE8) {
delete me.getWidth;
delete me.getHeight;
}
delete me.styleHooks;
},
updateText: function(text) {
var me = this,
dom, textNode;
if (dom) {
textNode = dom.firstChild;
if (!textNode || (textNode.nodeType !== 3 || textNode.nextSibling)) {
textNode = DOC.createTextNode();
me.empty();
dom.appendChild(textNode);
}
if (text) {
textNode.data = text;
}
}
},
setHtml: function(html, loadScripts, callback) {
var me = this,
id, dom, interval;
if (!me.dom) {
return me;
}
html = html || '';
dom = me.dom;
if (loadScripts !== true) {
dom.innerHTML = html;
Ext.callback(callback, me);
return me;
}
id = Ext.id();
html += '';
interval = Ext.interval(function() {
var hd, match, attrs, srcMatch, typeMatch, el, s;
if (!(el = DOC.getElementById(id))) {
return false;
}
clearInterval(interval);
Ext.removeNode(el);
hd = Ext.getHead().dom;
while ((match = scriptTagRe.exec(html))) {
attrs = match[1];
srcMatch = attrs ? attrs.match(srcRe) : false;
if (srcMatch && srcMatch[2]) {
s = DOC.createElement("script");
s.src = srcMatch[2];
typeMatch = attrs.match(typeRe);
if (typeMatch && typeMatch[2]) {
s.type = typeMatch[2];
}
hd.appendChild(s);
} else if (match[2] && match[2].length > 0) {
(WIN.execScript || WIN.eval)(match[2]);
}
}
Ext.callback(callback, me);
}, 20);
dom.innerHTML = html.replace(replaceScriptTagRe, '');
return me;
},
setOpacity: function(opacity, animate) {
var me = this;
if (!me.dom) {
return me;
}
if (!animate || !me.anim) {
me.setStyle('opacity', opacity);
} else {
if (typeof animate != 'object') {
animate = {
duration: 350,
easing: 'ease-in'
};
}
me.animate(Ext.applyIf({
to: {
opacity: opacity
}
}, animate));
}
return me;
},
setPositioning: function(pc) {
return this.setStyle(pc);
},
setVertical: function(angle, cls) {
var me = this,
proto = Element.prototype;
me.vertical = true;
if (cls) {
me.addCls(me.verticalCls = cls);
}
me.setWidth = proto.setHeight;
me.setHeight = proto.setWidth;
if (!Ext.isIE8) {
me.getWidth = proto.getHeight;
me.getHeight = proto.getWidth;
}
me.styleHooks = (angle === 270) ? proto.verticalStyleHooks270 : proto.verticalStyleHooks90;
},
setSize: function(width, height, animate) {
var me = this;
if (Ext.isObject(width)) {
animate = height;
height = width.height;
width = width.width;
}
if (!animate || !me.anim) {
me.dom.style.width = Element.addUnits(width);
me.dom.style.height = Element.addUnits(height);
if (me.shadow || me.shim) {
me.syncUnderlays();
}
} else {
if (animate === true) {
animate = {};
}
me.animate(Ext.applyIf({
to: {
width: width,
height: height
}
}, animate));
}
return me;
},
setVisible: function(visible, animate) {
var me = this,
dom = me.dom,
visMode = getVisMode(me);
if (typeof animate === 'string') {
switch (animate) {
case DISPLAY:
visMode = Element.DISPLAY;
break;
case VISIBILITY:
visMode = Element.VISIBILITY;
break;
case OFFSETS:
visMode = Element.OFFSETS;
break;
}
me.setVisibilityMode(visMode);
animate = false;
}
if (!animate || !me.anim) {
if (visMode === Element.DISPLAY) {
return me.setDisplayed(visible);
} else if (visMode === Element.OFFSETS) {
me[visible ? 'removeCls' : 'addCls'](OFFSETCLASS);
} else if (visMode === Element.VISIBILITY) {
me.fixDisplay();
dom.style.visibility = visible ? '' : HIDDEN;
}
} else {
if (visible) {
me.setOpacity(0.01);
me.setVisible(true);
}
if (!Ext.isObject(animate)) {
animate = {
duration: 350,
easing: 'ease-in'
};
}
me.animate(Ext.applyIf({
callback: function() {
if (!visible) {
Ext.fly(dom).setVisible(false).setOpacity(1);
}
},
to: {
opacity: (visible) ? 1 : 0
}
}, animate));
}
me.getData()[ISVISIBLE] = visible;
if (me.shadow || me.shim) {
me.setUnderlaysVisible(visible);
}
return me;
},
setWidth: function(width, animate) {
var me = this;
if (!animate || !me.anim) {
me.callParent(arguments);
} else {
if (!Ext.isObject(animate)) {
animate = {};
}
me.animate(Ext.applyIf({
to: {
width: width
}
}, animate));
}
return me;
},
setX: function(x, animate) {
return this.setXY([
x,
this.getY()
], animate);
},
setXY: function(xy, animate) {
var me = this;
if (!animate || !me.anim) {
me.callParent([
xy
]);
} else {
if (!Ext.isObject(animate)) {
animate = {};
}
me.animate(Ext.applyIf({
to: {
x: xy[0],
y: xy[1]
}
}, animate));
}
return this;
},
setY: function(y, animate) {
return this.setXY([
this.getX(),
y
], animate);
},
show: function(animate) {
if (typeof animate === 'string') {
this.setVisible(true, animate);
return this;
}
this.setVisible(true, this.anim(animate));
return this;
},
slideIn: function(anchor, obj, slideOut) {
var me = this,
dom = me.dom,
elStyle = dom.style,
beforeAnim, wrapAnim, restoreScroll, wrapDomParentNode;
anchor = anchor || "t";
obj = obj || {};
beforeAnim = function() {
var animScope = this,
listeners = obj.listeners,
el = Ext.fly(dom, '_anim'),
box, originalStyles, anim, wrap;
if (!slideOut) {
el.fixDisplay();
}
box = el.getBox();
if ((anchor == 't' || anchor == 'b') && box.height === 0) {
box.height = dom.scrollHeight;
} else if ((anchor == 'l' || anchor == 'r') && box.width === 0) {
box.width = dom.scrollWidth;
}
originalStyles = el.getStyle([
'width',
'height',
'left',
'right',
'top',
'bottom',
'position',
'z-index'
], true);
el.setSize(box.width, box.height);
if (obj.preserveScroll) {
restoreScroll = el.cacheScrollValues();
}
wrap = el.wrap({
role: 'presentation',
id: Ext.id() + '-anim-wrap-for-' + el.dom.id,
style: {
visibility: slideOut ? 'visible' : 'hidden'
}
});
wrapDomParentNode = wrap.dom.parentNode;
wrap.setPositioning(el.getPositioning());
if (wrap.isStyle('position', 'static')) {
wrap.position('relative');
}
el.clearPositioning('auto');
wrap.clip();
if (restoreScroll) {
restoreScroll();
}
el.setStyle({
visibility: '',
position: 'absolute'
});
if (slideOut) {
wrap.setSize(box.width, box.height);
}
switch (anchor) {
case 't':
anim = {
from: {
width: box.width + 'px',
height: '0px'
},
to: {
width: box.width + 'px',
height: box.height + 'px'
}
};
elStyle.bottom = '0px';
break;
case 'l':
anim = {
from: {
width: '0px',
height: box.height + 'px'
},
to: {
width: box.width + 'px',
height: box.height + 'px'
}
};
me.anchorAnimX(anchor);
break;
case 'r':
anim = {
from: {
x: box.x + box.width,
width: '0px',
height: box.height + 'px'
},
to: {
x: box.x,
width: box.width + 'px',
height: box.height + 'px'
}
};
me.anchorAnimX(anchor);
break;
case 'b':
anim = {
from: {
y: box.y + box.height,
width: box.width + 'px',
height: '0px'
},
to: {
y: box.y,
width: box.width + 'px',
height: box.height + 'px'
}
};
break;
case 'tl':
anim = {
from: {
x: box.x,
y: box.y,
width: '0px',
height: '0px'
},
to: {
width: box.width + 'px',
height: box.height + 'px'
}
};
elStyle.bottom = '0px';
me.anchorAnimX('l');
break;
case 'bl':
anim = {
from: {
y: box.y + box.height,
width: '0px',
height: '0px'
},
to: {
y: box.y,
width: box.width + 'px',
height: box.height + 'px'
}
};
me.anchorAnimX('l');
break;
case 'br':
anim = {
from: {
x: box.x + box.width,
y: box.y + box.height,
width: '0px',
height: '0px'
},
to: {
x: box.x,
y: box.y,
width: box.width + 'px',
height: box.height + 'px'
}
};
me.anchorAnimX('r');
break;
case 'tr':
anim = {
from: {
x: box.x + box.width,
width: '0px',
height: '0px'
},
to: {
x: box.x,
width: box.width + 'px',
height: box.height + 'px'
}
};
elStyle.bottom = '0px';
me.anchorAnimX('r');
break;
}
wrap.show();
wrapAnim = Ext.apply({}, obj);
delete wrapAnim.listeners;
wrapAnim = new Ext.fx.Anim(Ext.applyIf(wrapAnim, {
target: wrap,
duration: 500,
easing: 'ease-out',
from: slideOut ? anim.to : anim.from,
to: slideOut ? anim.from : anim.to
}));
wrapAnim.on('afteranimate', function() {
var el = Ext.fly(dom, '_anim');
el.setStyle(originalStyles);
if (slideOut) {
if (obj.useDisplay) {
el.setDisplayed(false);
} else {
el.hide();
}
}
if (wrap.dom) {
if (wrap.dom.parentNode) {
wrap.dom.parentNode.insertBefore(el.dom, wrap.dom);
} else {
wrapDomParentNode.appendChild(el.dom);
}
wrap.destroy();
}
if (restoreScroll) {
restoreScroll();
}
animScope.end();
});
if (listeners) {
wrapAnim.on(listeners);
}
};
me.animate({
duration: obj.duration ? Math.max(obj.duration, 500) * 2 : 1000,
listeners: {
beforeanimate: beforeAnim
}
});
return me;
},
slideOut: function(anchor, o) {
return this.slideIn(anchor, o, true);
},
swallowEvent: function(eventName, preventDefault) {
var me = this,
e, eLen,
fn = function(e) {
e.stopPropagation();
if (preventDefault) {
e.preventDefault();
}
};
if (Ext.isArray(eventName)) {
eLen = eventName.length;
for (e = 0; e < eLen; e++) {
me.on(eventName[e], fn);
}
return me;
}
me.on(eventName, fn);
return me;
},
switchOff: function(obj) {
var me = this,
dom = me.dom,
beforeAnim;
obj = Ext.applyIf(obj || {}, {
easing: 'ease-in',
duration: 500,
remove: false,
useDisplay: false
});
beforeAnim = function() {
var el = Ext.fly(dom, '_anim'),
animScope = this,
size = el.getSize(),
xy = el.getXY(),
keyframe, position;
el.clearOpacity();
el.clip();
position = el.getPositioning();
keyframe = new Ext.fx.Animator({
target: dom,
duration: obj.duration,
easing: obj.easing,
keyframes: {
33: {
opacity: 0.3
},
66: {
height: 1,
y: xy[1] + size.height / 2
},
100: {
width: 1,
x: xy[0] + size.width / 2
}
}
});
keyframe.on('afteranimate', function() {
var el = Ext.fly(dom, '_anim');
if (obj.useDisplay) {
el.setDisplayed(false);
} else {
el.hide();
}
el.clearOpacity();
el.setPositioning(position);
el.setSize(size);
animScope.end();
});
};
me.animate({
duration: (Math.max(obj.duration, 500) * 2),
listeners: {
beforeanimate: {
fn: beforeAnim
}
},
callback: obj.callback,
scope: obj.scope
});
return me;
},
syncContent: function(source) {
source = Ext.getDom(source);
var sourceNodes = source.childNodes,
sourceLen = sourceNodes.length,
dest = this.dom,
destNodes = dest.childNodes,
destLen = destNodes.length,
i, destNode, sourceNode, nodeType, newAttrs, attLen, attName,
elData = dest._extData;
if (Ext.isIE9m && dest.mergeAttributes) {
dest.mergeAttributes(source, true);
dest.src = source.src;
} else {
newAttrs = source.attributes;
attLen = newAttrs.length;
for (i = 0; i < attLen; i++) {
attName = newAttrs[i].name;
if (attName !== 'id') {
dest.setAttribute(attName, newAttrs[i].value);
}
}
}
if (elData) {
elData.isSynchronized = false;
}
if (sourceLen !== destLen) {
dest.innerHTML = source.innerHTML;
return;
}
for (i = 0; i < sourceLen; i++) {
sourceNode = sourceNodes[i];
destNode = destNodes[i];
nodeType = sourceNode.nodeType;
if (nodeType !== destNode.nodeType || (nodeType === 1 && sourceNode.tagName !== destNode.tagName)) {
dest.innerHTML = source.innerHTML;
return;
}
if (nodeType === 3) {
destNode.data = sourceNode.data;
} else
{
if (sourceNode.id && destNode.id !== sourceNode.id) {
destNode.id = sourceNode.id;
}
destNode.style.cssText = sourceNode.style.cssText;
destNode.className = sourceNode.className;
Ext.fly(destNode, '_syncContent').syncContent(sourceNode);
}
}
},
toggle: function(animate) {
var me = this;
me.setVisible(!me.isVisible(), me.anim(animate));
return me;
},
unmask: function() {
var me = this,
data = me.getData(),
maskEl = data.maskEl,
style;
if (maskEl) {
style = maskEl.dom.style;
if (style.clearExpression) {
style.clearExpression('width');
style.clearExpression('height');
}
if (maskEl) {
maskEl.destroy();
delete data.maskEl;
}
me.removeCls([
XMASKED,
XMASKEDRELATIVE
]);
}
me.restoreChildrenTabbableState();
if (me.dom !== DOC.body) {
me.restoreTabbableState();
}
},
unclip: function() {
var me = this,
data = me.getData(),
clip;
if (data[ISCLIPPED]) {
data[ISCLIPPED] = false;
clip = data[ORIGINALCLIP];
if (clip.o) {
me.setStyle(OVERFLOW, clip.o);
}
if (clip.x) {
me.setStyle(OVERFLOWX, clip.x);
}
if (clip.y) {
me.setStyle(OVERFLOWY, clip.y);
}
}
return me;
},
translate: function(x, y, z) {
if (Ext.supports.CssTransforms && !Ext.isIE9m) {
this.callParent(arguments);
} else {
if (x != null) {
this.dom.style.left = x + 'px';
}
if (y != null) {
this.dom.style.top = y + 'px';
}
}
},
unselectable: function() {
var me = this;
if (Ext.isOpera) {
me.dom.unselectable = 'on';
}
me.removeCls(Element.selectableCls);
me.addCls(Element.unselectableCls);
return me;
},
privates: {
needsTabIndex: function() {
var dom = this.dom,
nodeName, isFocusable;
if (dom) {
nodeName = dom.nodeName;
isFocusable = !!Ext.Element.naturallyFocusableTags[nodeName] || ((nodeName === 'A' || nodeName === 'LINK') && !!dom.href) || dom.getAttribute('tabindex') != null || dom.contentEditable === 'true';
return !isFocusable;
}
},
findTabbableElements: function(asDom, selector,
limit, backward) {
asDom = asDom != undefined ? asDom : true;
var me = this,
selection;
selection = me.selectTabbableElements(asDom, selector, limit, backward);
if (me.isTabbable()) {
selection.unshift(asDom ? me.dom : me);
}
return selection;
},
selectTabbableElements: function(asDom, selector,
limit, backward) {
var selection = [],
nodes, node, el, i, len, to, step, tabIndex;
asDom = asDom != undefined ? asDom : true;
nodes = this.dom.querySelectorAll(selector || Ext.Element.tabbableSelector);
len = nodes.length;
if (!len) {
return selection;
}
if (backward) {
i = len - 1;
to = 0;
step = -1;
} else {
i = 0;
to = len - 1;
step = 1;
}
for (; ; i += step) {
if ((step > 0 && i > to) || (step < 0 && i < to)) {
break;
}
node = nodes[i];
tabIndex = node.getAttribute('tabindex') - 0;
if (!(tabIndex < 0)) {
el = asDom ? Ext.fly(node) : Ext.get(node);
if (el.isTabbable()) {
selection.push(asDom ? node : el);
}
}
if (selection.length >= limit) {
return selection;
}
}
return selection;
},
selectFirstTabbableElement: function(asDom, selector) {
var els = this.selectTabbableElements(asDom, selector, 1, false);
return els[0];
},
selectLastTabbableElement: function(asDom, selector) {
var el = this.selectTabbableElements(true, selector, 1, true)[0];
return (asDom !== false) ? el : Ext.get(el);
},
saveTabbableState: function(attribute) {
var tabbableSavedFlagAttribute = Ext.Element.tabbableSavedFlagAttribute,
dom = this.dom;
if (dom.hasAttribute(tabbableSavedFlagAttribute)) {
return;
}
attribute = attribute || Ext.Element.tabbableSavedAttribute;
if (dom.hasAttribute('tabindex')) {
dom.setAttribute(attribute, dom.getAttribute('tabindex'));
} else
{
dom.setAttribute(attribute, 'none');
}
dom.setAttribute('tabindex', -1);
dom.setAttribute(tabbableSavedFlagAttribute, true);
return this;
},
restoreTabbableState: function(attribute) {
var tabbableSavedFlagAttribute = Ext.Element.tabbableSavedFlagAttribute,
dom = this.dom,
idx;
attribute = attribute || Ext.Element.tabbableSavedAttribute;
if (!dom.hasAttribute(tabbableSavedFlagAttribute) || !dom.hasAttribute(attribute)) {
return;
}
idx = dom.getAttribute(attribute);
if (idx === 'none') {
dom.removeAttribute('tabindex');
} else {
dom.setAttribute('tabindex', idx);
}
dom.removeAttribute(attribute);
dom.removeAttribute(tabbableSavedFlagAttribute);
return this;
},
saveChildrenTabbableState: function(attribute) {
var children, child, i, len;
if (this.dom) {
children = this.selectTabbableElements();
for (i = 0 , len = children.length; i < len; i++) {
child = Ext.fly(children[i]);
child.saveTabbableState(attribute);
}
}
return children;
},
restoreChildrenTabbableState: function(attribute, children) {
var child, i, len;
if (this.dom) {
attribute = attribute || Ext.Element.tabbableSavedAttribute;
children = children || this.dom.querySelectorAll('[' + attribute + ']');
for (i = 0 , len = children.length; i < len; i++) {
child = Ext.fly(children[i]);
child.restoreTabbableState(attribute);
}
}
return children;
}
},
deprecated: {
'4.0': {
methods: {
pause: function(ms) {
var me = this;
Ext.fx.Manager.setFxDefaults(me.id, {
delay: ms
});
return me;
},
scale: function(w, h, o) {
this.animate(Ext.apply({}, o, {
width: w,
height: h
}));
return this;
},
shift: function(config) {
this.animate(config);
return this;
}
}
},
'4.2': {
methods: {
moveTo: function(x, y, animate) {
return this.setXY([
x,
y
], animate);
},
setBounds: function(x, y, width, height, animate) {
return this.setBox({
x: x,
y: y,
width: width,
height: height
}, animate);
},
setLeftTop: function(left, top) {
var me = this,
style = me.dom.style;
style.left = Element.addUnits(left);
style.top = Element.addUnits(top);
if (me.shadow || me.shim) {
me.syncUnderlays();
}
return me;
},
setLocation: function(x, y, animate) {
return this.setXY([
x,
y
], animate);
}
}
},
'5.0': {
methods: {
getAttributeNS: function(namespace, name) {
return this.getAttribute(name, namespace);
},
getCenterXY: function() {
return this.getAlignToXY(DOC, 'c-c');
},
getComputedHeight: function() {
return Math.max(this.dom.offsetHeight, this.dom.clientHeight) || parseFloat(this.getStyle(HEIGHT)) || 0;
},
getComputedWidth: function() {
return Math.max(this.dom.offsetWidth, this.dom.clientWidth) || parseFloat(this.getStyle(WIDTH)) || 0;
},
getStyleSize: function() {
var me = this,
d = this.dom,
isDoc = (d === DOC || d === DOC.body),
s, w, h;
if (isDoc) {
return {
width: Element.getViewportWidth(),
height: Element.getViewportHeight()
};
}
s = me.getStyle([
'height',
'width'
], true);
if (s.width && s.width !== 'auto') {
w = parseFloat(s.width);
}
if (s.height && s.height !== 'auto') {
h = parseFloat(s.height);
}
return {
width: w || me.getWidth(true),
height: h || me.getHeight(true)
};
},
isBorderBox: function() {
return true;
},
isDisplayed: function() {
return !this.isStyle('display', 'none');
},
focusable: 'isFocusable'
}
}
}
};
})(), function() {
var Element = Ext.dom.Element,
proto = Element.prototype,
useDocForId = !Ext.isIE8,
DOC = document,
view = DOC.defaultView,
opacityRe = /alpha\(opacity=(.*)\)/i,
trimRe = /^\s+|\s+$/g,
styleHooks = proto.styleHooks,
supports = Ext.supports,
verticalStyleHooks90, verticalStyleHooks270, edges, k, edge, borderWidth, getBorderWidth;
proto._init(Element);
delete proto._init;
Ext.plainTableCls = Ext.baseCSSPrefix + 'table-plain';
Ext.plainListCls = Ext.baseCSSPrefix + 'list-plain';
if (Ext.CompositeElementLite) {
Ext.CompositeElementLite.importElementMethods();
}
styleHooks.opacity = {
name: 'opacity',
afterSet: function(dom, value, el) {
var shadow = el.shadow;
if (shadow) {
shadow.setOpacity(value);
}
}
};
if (!supports.Opacity && Ext.isIE) {
Ext.apply(styleHooks.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;
}
}
});
}
if (!supports.matchesSelector) {
var simpleSelectorRe = /^([a-z]+|\*)?(?:\.([a-z][a-z\-_0-9]*))?$/i,
dashRe = /\-/g,
fragment,
classMatcher = function(tag, cls) {
var classRe = new RegExp('(?:^|\\s+)' + cls.replace(dashRe, '\\-') + '(?:\\s+|$)');
if (tag && tag !== '*') {
tag = tag.toUpperCase();
return function(el) {
return el.tagName === tag && classRe.test(el.className);
};
}
return function(el) {
return classRe.test(el.className);
};
},
tagMatcher = function(tag) {
tag = tag.toUpperCase();
return function(el) {
return el.tagName === tag;
};
},
cache = {};
proto.matcherCache = cache;
proto.is = function(selector) {
if (!selector) {
return true;
}
var dom = this.dom,
cls, match, testFn, root, isOrphan, is, tag;
if (dom.nodeType !== 1) {
return false;
}
if (!(testFn = Ext.isFunction(selector) ? selector : cache[selector])) {
if (!(match = selector.match(simpleSelectorRe))) {
root = dom.parentNode;
if (!root) {
isOrphan = true;
root = fragment || (fragment = DOC.createDocumentFragment());
fragment.appendChild(dom);
}
is = Ext.Array.indexOf(Ext.fly(root, '_is').query(selector), dom) !== -1;
if (isOrphan) {
fragment.removeChild(dom);
}
return is;
}
tag = match[1];
cls = match[2];
cache[selector] = testFn = cls ? classMatcher(tag, cls) : tagMatcher(tag);
}
return testFn(dom);
};
}
if (!view || !view.getComputedStyle) {
proto.getStyle = function(property, inline) {
var me = this,
dom = me.dom,
multiple = typeof property !== 'string',
prop = property,
props = prop,
len = 1,
isInline = inline,
styleHooks = me.styleHooks,
camel, domStyle, 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.currentStyle;
if (!style) {
isInline = true;
style = domStyle;
}
}
do {
hook = styleHooks[prop];
if (!hook) {
styleHooks[prop] = hook = {
name: Element.normalize(prop)
};
}
if (hook.get) {
out = hook.get(dom, me, isInline, style);
} else {
camel = hook.name;
out = style[camel];
}
if (!multiple) {
return out;
}
values[prop] = out;
prop = props[++i];
} while (i < len);
return values;
};
}
if (Ext.isIE8) {
getBorderWidth = function(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.apply(Ext, {
enableGarbageCollector: true,
isBorderBox: true,
useShims: false,
getDetachedBody: function() {
var detachedEl = Ext.detachedBodyEl;
if (!detachedEl) {
detachedEl = DOC.createElement('div');
Ext.detachedBodyEl = detachedEl = new Ext.dom.Fly(detachedEl);
detachedEl.isDetachedBody = true;
}
return detachedEl;
},
getElementById: function(id) {
var el = DOC.getElementById(id),
detachedBodyEl;
if (!el && (detachedBodyEl = Ext.detachedBodyEl)) {
el = detachedBodyEl.dom.querySelector(Ext.makeIdSelector(id));
}
return el;
},
addBehaviors: function(o) {
if (!Ext.isReady) {
Ext.onInternalReady(function() {
Ext.addBehaviors(o);
});
} else {
var cache = {},
parts, b, s;
for (b in o) {
if ((parts = b.split('@'))[1]) {
s = parts[0];
if (!cache[s]) {
cache[s] = Ext.fly(document).select(s, true);
}
cache[s].on(parts[1], o[b]);
}
}
cache = null;
}
}
});
if (Ext.isIE9m) {
Ext.getElementById = function(id) {
var el = DOC.getElementById(id),
detachedBodyEl;
if (!el && (detachedBodyEl = Ext.detachedBodyEl)) {
el = detachedBodyEl.dom.all[id];
}
return el;
};
proto.getById = function(id, asDom) {
var dom = this.dom,
ret = null,
entry, el;
if (dom) {
el = (useDocForId && DOC.getElementById(id)) || dom.all[id];
if (el) {
if (asDom) {
ret = el;
} else {
entry = Ext.cache[id];
if (entry) {
if (entry.skipGarbageCollection || !Ext.isGarbage(entry.dom)) {
ret = entry;
} else {
Ext.Error.raise("Stale Element with id '" + el.id + "' found in Element cache. " + "Make sure to clean up Element instances using destroy()");
entry.destroy();
}
}
ret = ret || new Ext.Element(el);
}
}
}
return ret;
};
} else if (!DOC.querySelector) {
Ext.getDetachedBody = Ext.getBody;
Ext.getElementById = function(id) {
return DOC.getElementById(id);
};
proto.getById = function(id, asDom) {
var dom = DOC.getElementById(id);
return asDom ? dom : (dom ? Ext.get(dom) : null);
};
}
if (Ext.isIE && !(Ext.isIE9p && DOC.documentMode >= 9)) {
proto.getAttribute = function(name, ns) {
var d = this.dom,
type;
if (ns) {
type = typeof d[ns + ":" + name];
if (type !== 'undefined' && type !== 'unknown') {
return d[ns + ":" + name] || null;
}
return null;
}
if (name === "for") {
name = "htmlFor";
}
return d[name] || null;
};
}
Ext.onInternalReady(function() {
var transparentRe = /^(?:transparent|(?:rgba[(](?:\s*\d+\s*[,]){3}\s*0\s*[)]))$/i,
bodyCls = [],
origSetWidth = proto.setWidth,
origSetHeight = proto.setHeight,
origSetSize = proto.setSize,
pxRe = /^\d+(?:\.\d*)?px$/i,
colorStyles, i, name, camel;
if (supports.FixedTableWidthBug) {
styleHooks.width = {
name: 'width',
set: function(dom, value, el) {
var style = dom.style,
needsFix = el._needsTableWidthFix,
origDisplay = style.display;
if (needsFix) {
style.display = 'none';
}
style.width = value;
if (needsFix) {
dom.scrollWidth;
style.display = origDisplay;
}
}
};
proto.setWidth = function(width, animate) {
var me = this,
dom = me.dom,
style = dom.style,
needsFix = me._needsTableWidthFix,
origDisplay = style.display;
if (needsFix && !animate) {
style.display = 'none';
}
origSetWidth.call(me, width, animate);
if (needsFix && !animate) {
dom.scrollWidth;
style.display = origDisplay;
}
return me;
};
proto.setSize = function(width, height, animate) {
var me = this,
dom = me.dom,
style = dom.style,
needsFix = me._needsTableWidthFix,
origDisplay = style.display;
if (needsFix && !animate) {
style.display = 'none';
}
origSetSize.call(me, width, height, animate);
if (needsFix && !animate) {
dom.scrollWidth;
style.display = origDisplay;
}
return me;
};
}
if (Ext.isIE8) {
styleHooks.height = {
name: 'height',
set: function(dom, value, el) {
var component = el.component,
frameInfo, frameBodyStyle;
if (component && component._syncFrameHeight && this === component.el) {
frameBodyStyle = component.frameBody.dom.style;
if (pxRe.test(value)) {
frameInfo = component.getFrameInfo();
if (frameInfo) {
frameBodyStyle.height = (parseInt(value, 10) - frameInfo.height) + 'px';
}
} else if (!value || value === 'auto') {
frameBodyStyle.height = '';
}
}
dom.style.height = value;
}
};
proto.setHeight = function(height, animate) {
var component = this.component,
frameInfo, frameBodyStyle;
if (component && component._syncFrameHeight && this === component.el) {
frameBodyStyle = component.frameBody.dom.style;
if (!height || height === 'auto') {
frameBodyStyle.height = '';
} else {
frameInfo = component.getFrameInfo();
if (frameInfo) {
frameBodyStyle.height = (height - frameInfo.height) + 'px';
}
}
}
return origSetHeight.call(this, height, animate);
};
proto.setSize = function(width, height, animate) {
var component = this.component,
frameInfo, frameBodyStyle;
if (component && component._syncFrameHeight && this === component.el) {
frameBodyStyle = component.frameBody.dom.style;
if (!height || height === 'auto') {
frameBodyStyle.height = '';
} else {
frameInfo = component.getFrameInfo();
if (frameInfo) {
frameBodyStyle.height = (height - frameInfo.height) + 'px';
}
}
}
return origSetSize.call(this, width, height, animate);
};
}
Ext.getDoc().on('selectstart', function(ev, dom) {
var selectableCls = Element.selectableCls,
unselectableCls = Element.unselectableCls,
tagName = dom && dom.tagName;
tagName = tagName && tagName.toLowerCase();
if (tagName === 'input' || tagName === 'textarea') {
return;
}
while (dom && dom.nodeType === 1 && dom !== DOC.documentElement) {
var el = Ext.fly(dom);
if (el.hasCls(selectableCls)) {
return;
}
if (el.hasCls(unselectableCls)) {
ev.stopEvent();
return;
}
dom = dom.parentNode;
}
});
function fixTransparent(dom, el, inline, style) {
var value = style[this.name] || '';
return transparentRe.test(value) ? 'transparent' : value;
}
function makeSelectionRestoreFn(activeEl, start, end) {
return function() {
activeEl.selectionStart = start;
activeEl.selectionEnd = end;
};
}
function getRightMarginFixCleaner(target) {
var hasInputBug = supports.DisplayChangeInputSelectionBug,
hasTextAreaBug = supports.DisplayChangeTextAreaSelectionBug,
activeEl, tag, start, end;
if (hasInputBug || hasTextAreaBug) {
activeEl = Element.getActiveElement();
tag = activeEl && activeEl.tagName;
if ((hasTextAreaBug && tag === 'TEXTAREA') || (hasInputBug && tag === 'INPUT' && activeEl.type === 'text')) {
if (Ext.fly(target).isAncestor(activeEl)) {
start = activeEl.selectionStart;
end = activeEl.selectionEnd;
if (Ext.isNumber(start) && Ext.isNumber(end)) {
return makeSelectionRestoreFn(activeEl, start, end);
}
}
}
}
return Ext.emptyFn;
}
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 = getRightMarginFixCleaner(dom);
display = domStyle.display;
domStyle.display = 'inline-block';
result = (inline ? style : dom.ownerDocument.defaultView.getComputedStyle(dom, '')).marginRight;
domStyle.display = display;
cleaner();
}
return result;
}
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
};
}
}
proto.verticalStyleHooks90 = verticalStyleHooks90 = Ext.Object.chain(styleHooks);
proto.verticalStyleHooks270 = verticalStyleHooks270 = Ext.Object.chain(styleHooks);
verticalStyleHooks90.width = styleHooks.height || {
name: 'height'
};
verticalStyleHooks90.height = styleHooks.width || {
name: 'width'
};
verticalStyleHooks90['margin-top'] = {
name: 'marginLeft'
};
verticalStyleHooks90['margin-right'] = {
name: 'marginTop'
};
verticalStyleHooks90['margin-bottom'] = {
name: 'marginRight'
};
verticalStyleHooks90['margin-left'] = {
name: 'marginBottom'
};
verticalStyleHooks90['padding-top'] = {
name: 'paddingLeft'
};
verticalStyleHooks90['padding-right'] = {
name: 'paddingTop'
};
verticalStyleHooks90['padding-bottom'] = {
name: 'paddingRight'
};
verticalStyleHooks90['padding-left'] = {
name: 'paddingBottom'
};
verticalStyleHooks90['border-top'] = {
name: 'borderLeft'
};
verticalStyleHooks90['border-right'] = {
name: 'borderTop'
};
verticalStyleHooks90['border-bottom'] = {
name: 'borderRight'
};
verticalStyleHooks90['border-left'] = {
name: 'borderBottom'
};
verticalStyleHooks270.width = styleHooks.height || {
name: 'height'
};
verticalStyleHooks270.height = styleHooks.width || {
name: 'width'
};
verticalStyleHooks270['margin-top'] = {
name: 'marginRight'
};
verticalStyleHooks270['margin-right'] = {
name: 'marginBottom'
};
verticalStyleHooks270['margin-bottom'] = {
name: 'marginLeft'
};
verticalStyleHooks270['margin-left'] = {
name: 'marginTop'
};
verticalStyleHooks270['padding-top'] = {
name: 'paddingRight'
};
verticalStyleHooks270['padding-right'] = {
name: 'paddingBottom'
};
verticalStyleHooks270['padding-bottom'] = {
name: 'paddingLeft'
};
verticalStyleHooks270['padding-left'] = {
name: 'paddingTop'
};
verticalStyleHooks270['border-top'] = {
name: 'borderRight'
};
verticalStyleHooks270['border-right'] = {
name: 'borderBottom'
};
verticalStyleHooks270['border-bottom'] = {
name: 'borderLeft'
};
verticalStyleHooks270['border-left'] = {
name: 'borderTop'
};
if (!Ext.scopeCss) {
bodyCls.push(Ext.baseCSSPrefix + 'body');
}
if (supports.Touch) {
bodyCls.push(Ext.baseCSSPrefix + 'touch');
}
if (Ext.isIE && Ext.isIE9m) {
bodyCls.push(Ext.baseCSSPrefix + 'ie', Ext.baseCSSPrefix + 'ie9m');
bodyCls.push(Ext.baseCSSPrefix + 'ie8p');
if (Ext.isIE8) {
bodyCls.push(Ext.baseCSSPrefix + 'ie8');
} else {
bodyCls.push(Ext.baseCSSPrefix + 'ie9', Ext.baseCSSPrefix + 'ie9p');
}
if (Ext.isIE8m) {
bodyCls.push(Ext.baseCSSPrefix + 'ie8m');
}
}
if (Ext.isIE10) {
bodyCls.push(Ext.baseCSSPrefix + 'ie10');
}
if (Ext.isIE11) {
bodyCls.push(Ext.baseCSSPrefix + 'ie11');
}
if (Ext.isGecko) {
bodyCls.push(Ext.baseCSSPrefix + 'gecko');
}
if (Ext.isOpera) {
bodyCls.push(Ext.baseCSSPrefix + 'opera');
}
if (Ext.isOpera12m) {
bodyCls.push(Ext.baseCSSPrefix + 'opera12m');
}
if (Ext.isWebKit) {
bodyCls.push(Ext.baseCSSPrefix + 'webkit');
}
if (Ext.isSafari) {
bodyCls.push(Ext.baseCSSPrefix + 'safari');
}
if (Ext.isChrome) {
bodyCls.push(Ext.baseCSSPrefix + 'chrome');
}
if (Ext.isMac) {
bodyCls.push(Ext.baseCSSPrefix + 'mac');
}
if (Ext.isLinux) {
bodyCls.push(Ext.baseCSSPrefix + 'linux');
}
if (!supports.CSS3BorderRadius) {
bodyCls.push(Ext.baseCSSPrefix + 'nbr');
}
if (!supports.CSS3LinearGradient) {
bodyCls.push(Ext.baseCSSPrefix + 'nlg');
}
if (supports.Touch) {
bodyCls.push(Ext.baseCSSPrefix + 'touch');
}
Ext.getBody().addCls(bodyCls);
}, null, {
priority: 1500
});
});
Ext.define('Ext.overrides.GlobalEvents', {
override: 'Ext.GlobalEvents',
attachListeners: function() {
this.callParent();
Ext.getDoc().on('mousedown', this.fireMouseDown, this);
},
fireMouseDown: function(e) {
this.fireEvent('mousedown', e);
},
deprecated: {
5: {
methods: {
addListener: function(ename, fn, scope, options, order, caller, eventOptions) {
var name, readyFn;
if (ename === 'ready') {
readyFn = fn;
} else if (typeof ename !== 'string') {
for (name in ename) {
if (name === 'ready') {
readyFn = ename[name];
}
}
}
if (readyFn) {
Ext.log.warn("Ext.on('ready', fn) is deprecated. Please use Ext.onReady(fn) instead.");
Ext.onReady(readyFn);
}
this.callParent([
ename,
fn,
scope,
options,
order,
caller,
eventOptions
]);
}
}
}
}
});
Ext.define('Ext.overrides.Widget', {
override: 'Ext.Widget',
uses: [
'Ext.Component'
],
$configStrict: false,
isComponent: true,
liquidLayout: true,
rendered: true,
rendering: true,
config: {
renderTo: null
},
cachedConfig: {
baseCls: Ext.baseCSSPrefix + 'widget'
},
constructor: function(config) {
var me = this,
renderTo;
me.callParent([
config
]);
me.getComponentLayout();
renderTo = me.getRenderTo();
if (renderTo) {
me.render(renderTo);
}
},
addCls: function(cls) {
this.el.addCls(cls);
},
addClsWithUI: function(cls) {
this.el.addCls(cls);
},
afterComponentLayout: Ext.emptyFn,
finishRender: function() {
this.rendering = false;
this.initBindable();
},
getComponentLayout: function() {
var me = this,
layout = me.componentLayout;
if (!layout) {
layout = me.componentLayout = new Ext.layout.component.Auto();
layout.setOwner(me);
}
return layout;
},
getTdCls: function() {
return Ext.baseCSSPrefix + this.getTdType() + '-' + (this.ui || 'default') + '-cell';
},
getTdType: function() {
return this.xtype;
},
getItemId: function() {
return this.itemId || this.id;
},
getSizeModel: function() {
return Ext.Component.prototype.getSizeModel.apply(this, arguments);
},
onAdded: function(container, pos, instanced) {
var me = this,
inheritedState = me.inheritedState;
me.ownerCt = container;
if (inheritedState && instanced) {
me.invalidateInheritedState();
}
if (me.reference) {
me.fixReference();
}
},
onRemoved: function(destroying) {
var me = this,
refHolder;
if (me.reference) {
refHolder = me.lookupReferenceHolder();
if (refHolder) {
refHolder.clearReference(me);
}
}
if (!destroying) {
me.removeBindings();
}
if (me.inheritedState && !destroying) {
me.invalidateInheritedState();
}
me.ownerCt = me.ownerLayout = null;
},
parseBox: function(box) {
return Ext.Element.parseBox(box);
},
removeCls: function(cls) {
this.el.removeCls(cls);
},
removeClsWithUI: function(cls) {
this.el.removeCls(cls);
},
render: function(container, position) {
var me = this,
element = me.element,
proto = Ext.Component.prototype,
nextSibling;
if (!me.ownerCt || me.floating) {
if (Ext.scopeCss) {
element.addCls(proto.rootCls);
}
element.addCls(proto.borderBoxCls);
}
if (position) {
nextSibling = container.childNodes[position];
if (nextSibling) {
Ext.fly(container).insertBefore(element, nextSibling);
return;
}
}
Ext.fly(container).appendChild(element);
},
setPosition: function(x, y) {
this.el.setLocalXY(x, y);
},
up: function() {
return Ext.Component.prototype.up.apply(this, arguments);
},
isAncestor: function() {
return Ext.Component.prototype.isAncestor.apply(this, arguments);
},
onFocusEnter: function() {
return Ext.Component.prototype.onFocusEnter.apply(this, arguments);
},
onFocusLeave: function() {
return Ext.Component.prototype.onFocusLeave.apply(this, arguments);
},
focus: Ext.emptyFn,
isFocusable: Ext.emptyFn
}, function(Cls) {
var prototype = Cls.prototype;
if (Ext.isIE8) {
prototype.addElementReferenceOnDemand = prototype.addElementReference;
}
});
Ext.define('Ext.overrides.app.domain.Component', {
override: 'Ext.app.domain.Component',
requires: [
'Ext.Component'
]
}, function(ComponentDomain) {
ComponentDomain.monitor(Ext.Component);
});
Ext.application = function(config) {
var createApp = function(App) {
Ext.onReady(function() {
Ext.app.Application.instance = new App();
});
},
paths = config.paths,
ns;
if (typeof config === "string") {
Ext.require(config, function() {
createApp(Ext.ClassManager.get(config));
});
} else {
config = Ext.apply({
extend: 'Ext.app.Application'
},
config);
Ext.Loader.setPath(config.name, config.appFolder || 'app');
if (paths) {
for (ns in paths) {
if (paths.hasOwnProperty(ns)) {
Ext.Loader.setPath(ns, paths[ns]);
}
}
}
config['paths processed'] = true;
Ext.define(config.name + ".$application", config, function() {
createApp(this);
});
}
};
Ext.define('Ext.overrides.app.Application', {
override: 'Ext.app.Application',
uses: [
'Ext.tip.QuickTipManager'
],
autoCreateViewport: false,
config: {
enableQuickTips: true
},
applyMainView: function(value) {
var view = this.getView(value),
proto = view.prototype,
config, plugins;
if (!proto.isViewport) {
plugins = proto.plugins;
plugins = [
'viewport'
].concat(plugins ? Ext.Array.from(plugins, true) : []);
config = {
plugins: plugins
};
}
return view.create(config);
},
getDependencies: function(cls, data, requires) {
var Controller = Ext.app.Controller,
proto = cls.prototype,
namespace = data.$namespace,
viewportClass = data.autoCreateViewport;
if (viewportClass) {
if (!namespace) {
Ext.Error.raise("[Ext.app.Application] Can't resolve namespace for " + data.$className + ", did you forget to specify 'name' property?");
}
if (viewportClass === true) {
viewportClass = 'Viewport';
} else {
requires.push('Ext.plugin.Viewport');
}
Controller.processDependencies(proto, requires, namespace, 'view', viewportClass);
}
},
onBeforeLaunch: function() {
var me = this,
autoCreateViewport = me.autoCreateViewport;
if (me.getEnableQuickTips()) {
me.initQuickTips();
}
if (autoCreateViewport) {
me.initViewport();
}
this.callParent(arguments);
},
getViewportName: function() {
var name = null,
autoCreate = this.autoCreateViewport;
if (autoCreate) {
name = (autoCreate === true) ? 'Viewport' : autoCreate;
}
return name;
},
initViewport: function() {
this.setMainView(this.getViewportName());
},
initQuickTips: function() {
Ext.tip.QuickTipManager.init();
}
});
Ext.define('Ext.overrides.dom.Helper', (function() {
var tableRe = /^(?:table|thead|tbody|tr|td)$/i,
tableElRe = /td|tr|tbody|thead/i,
ts = '',
tbs = ts + '',
tbe = '' + te,
trs = tbs + '',
tre = '
' + tbe;
return {
override: 'Ext.dom.Helper',
ieInsertHtml: function(where, el, html) {
var frag = null;
if (Ext.isIE9m && tableRe.test(el.tagName)) {
frag = this.insertIntoTable(el.tagName.toLowerCase(), where, el, html);
}
return frag;
},
ieOverwrite: function(el, html) {
if (Ext.isIE9m && tableRe.test(el.tagName)) {
while (el.firstChild) {
el.removeChild(el.firstChild);
}
if (html) {
return this.insertHtml('afterbegin', el, html);
}
}
},
ieTable: function(depth, openingTags, htmlContent, closingTags) {
var i = -1,
el = this.detachedDiv,
ns, nx;
el.innerHTML = [
openingTags,
htmlContent,
closingTags
].join('');
while (++i < depth) {
el = el.firstChild;
}
ns = el.nextSibling;
if (ns) {
ns = el;
el = document.createDocumentFragment();
while (ns) {
nx = ns.nextSibling;
el.appendChild(ns);
ns = nx;
}
}
return el;
},
insertIntoTable: function(tag, where, destinationEl, html) {
var node, before,
bb = where === 'beforebegin',
ab = where === 'afterbegin',
be = where === 'beforeend',
ae = where === 'afterend';
if (tag === 'td' && (ab || be) || !tableElRe.test(tag) && (bb || ae)) {
return null;
}
before = bb ? destinationEl : ae ? destinationEl.nextSibling : ab ? destinationEl.firstChild : null;
if (bb || ae) {
destinationEl = destinationEl.parentNode;
}
if (tag === 'td' || (tag === 'tr' && (be || ab))) {
node = this.ieTable(4, trs, html, tre);
} else if (((tag === 'tbody' || tag === 'thead') && (be || ab)) || (tag === 'tr' && (bb || ae))) {
node = this.ieTable(3, tbs, html, tbe);
} else {
node = this.ieTable(2, ts, html, te);
}
destinationEl.insertBefore(node, before);
return node;
}
};
})());
Ext.define('Ext.overrides.plugin.Abstract', {
override: 'Ext.plugin.Abstract',
$configStrict: false,
$configPrefixed: false,
disabled: false,
getState: null,
applyState: null,
enable: function() {
this.disabled = false;
},
disable: function() {
this.disabled = true;
}
});