/**
* @class Ext.EventManager
* Registers event handlers that want to receive a normalized EventObject instead of the standard browser event and provides
* several useful events directly.
* See {@link Ext.EventObject} for more details on normalized event objects.
* @singleton
*/
Ext.EventManager = {
// --------------------- onReady ---------------------
/**
* Check if we have bound our global onReady listener
* @private
*/
hasBoundOnReady: false,
/**
* Check if fireDocReady has been called
* @private
*/
hasFiredReady: false,
/**
* Timer for the document ready event in old IE versions
* @private
*/
readyTimeout: null,
/**
* Checks if we have bound an onreadystatechange event
* @private
*/
hasOnReadyStateChange: false,
/**
* Holds references to any onReady functions
* @private
*/
readyEvent: new Ext.util.Event(),
/**
* Check the ready state for old IE versions
* @private
* @return {Boolean} True if the document is ready
*/
checkReadyState: function(){
var me = Ext.EventManager;
if(window.attachEvent){
// See here for reference: http://javascript.nwbox.com/IEContentLoaded/
if (window != top) {
return false;
}
try{
document.documentElement.doScroll('left');
}catch(e){
return false;
}
me.fireDocReady();
return true;
}
if (document.readyState == 'complete') {
me.fireDocReady();
return true;
}
me.readyTimeout = setTimeout(arguments.callee, 2);
return false;
},
/**
* Binds the appropriate browser event for checking if the DOM has loaded.
* @private
*/
bindReadyEvent: function(){
var me = Ext.EventManager;
if (me.hasBoundOnReady) {
return;
}
if (document.addEventListener) {
document.addEventListener('DOMContentLoaded', me.fireDocReady, false);
// fallback, load will ~always~ fire
window.addEventListener('load', me.fireDocReady, false);
} else {
// check if the document is ready, this will also kick off the scroll checking timer
if (!me.checkReadyState()) {
document.attachEvent('onreadystatechange', me.checkReadyState);
me.hasOnReadyStateChange = true;
}
// fallback, onload will ~always~ fire
window.attachEvent('onload', me.fireDocReady, false);
}
me.hasBoundOnReady = true;
},
/**
* We know the document is loaded, so trigger any onReady events.
* @private
*/
fireDocReady: function(){
var me = Ext.EventManager;
// only unbind these events once
if (!me.hasFiredReady) {
me.hasFiredReady = true;
if (document.addEventListener) {
document.removeEventListener('DOMContentLoaded', me.fireDocReady, false);
window.removeEventListener('load', me.fireDocReady, false);
} else {
if (me.readyTimeout !== null) {
clearTimeout(me.readyTimeout);
}
if (me.hasOnReadyStateChange) {
document.detachEvent('onreadystatechange', me.checkReadyState);
}
window.detachEvent('onload', me.fireDocReady);
}
Ext.supports.init();
}
if (!Ext.isReady) {
Ext.isReady = true;
me.onWindowUnload();
me.readyEvent.fire();
}
},
/**
* Adds a listener to be notified when the document is ready (before onload and before images are loaded). Can be
* accessed shorthanded as Ext.onReady().
* @param {Function} fn The method the event invokes.
* @param {Object} scope (optional) The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
* @param {boolean} options (optional) Options object as passed to {@link Ext.core.Element#addListener}.
*/
onDocumentReady: function(fn, scope, options){
options = options || {};
var me = Ext.EventManager,
readyEvent = me.readyEvent;
// force single to be true so our event is only ever fired once.
options.single = true;
// Document already loaded, let's just fire it
if (Ext.isReady) {
readyEvent.addListener(fn, scope, options);
readyEvent.fire();
} else {
options.delay = options.delay || 1;
readyEvent.addListener(fn, scope, options);
me.bindReadyEvent();
}
},
// --------------------- event binding ---------------------
/**
* Contains a list of all document mouse downs, so we can ensure they fire even when stopEvent is called.
* @private
*/
stoppedMouseDownEvent: new Ext.util.Event(),
/**
* Options to parse for the 4th argument to addListener.
* @private
*/
propRe: /^(?:scope|delay|buffer|single|stopEvent|preventDefault|stopPropagation|normalized|args|delegate|freezeEvent)$/,
/**
* Get the id of the element. If one has not been assigned, automatically assign it.
* @param {Mixed} element The element to get the id for.
* @return {String} id
*/
getId : function(element) {
var skipGarbageCollection = false,
id;
element = Ext.getDom(element);
if (element === document || element === window) {
id = element === document ? Ext.documentId : Ext.windowId;
}
else {
id = Ext.id(element);
}
// skip garbage collection for special elements (window, document, iframes)
if (element && (element.getElementById || element.navigator)) {
skipGarbageCollection = true;
}
if (!Ext.cache[id]){
Ext.core.Element.addToCache(new Ext.core.Element(element), id);
if (skipGarbageCollection) {
Ext.cache[id].skipGarbageCollection = true;
}
}
return id;
},
/**
* Convert a "config style" listener into a set of flat arguments so they can be passed to addListener
* @private
* @param {Object} element The element the event is for
* @param {Object} event The event configuration
* @param {Object} isRemove True if a removal should be performed, otherwise an add will be done.
*/
prepareListenerConfig: function(element, config, isRemove){
var me = this,
propRe = me.propRe,
key, value, args;
// loop over all the keys in the object
for (key in config) {
if (config.hasOwnProperty(key)) {
// if the key is something else then an event option
if (!propRe.test(key)) {
value = config[key];
// if the value is a function it must be something like click: function(){}, scope: this
// which means that there might be multiple event listeners with shared options
if (Ext.isFunction(value)) {
// shared options
args = [element, key, value, config.scope, config];
} else {
// if its not a function, it must be an object like click: {fn: function(){}, scope: this}
args = [element, key, value.fn, value.scope, value];
}
if (isRemove === true) {
me.removeListener.apply(this, args);
} else {
me.addListener.apply(me, args);
}
}
}
}
},
/**
* Normalize cross browser event differences
* @private
* @param {Object} eventName The event name
* @param {Object} fn The function to execute
* @return {Object} The new event name/function
*/
normalizeEvent: function(eventName, fn){
if (/mouseenter|mouseleave/.test(eventName) && !Ext.supports.MouseEnterLeave) {
if (fn) {
fn = Ext.Function.createInterceptor(fn, this.contains, this);
}
eventName = eventName == 'mouseenter' ? 'mouseover' : 'mouseout';
} else if (eventName == 'mousewheel' && !Ext.supports.MouseWheel && !Ext.isOpera){
eventName = 'DOMMouseScroll';
}
return {
eventName: eventName,
fn: fn
};
},
/**
* Checks whether the event's relatedTarget is contained inside (or <b>is</b>) the element.
* @private
* @param {Object} event
*/
contains: function(event){
var parent = event.browserEvent.currentTarget,
child = this.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;
},
/**
* Appends an event handler to an element. The shorthand version {@link #on} is equivalent. Typically you will
* use {@link Ext.core.Element#addListener} directly on an Element in favor of calling this version.
* @param {String/HTMLElement} el The html element or id to assign the event handler to.
* @param {String} eventName The name of the event to listen for.
* @param {Function} handler The handler function the event invokes. This function is passed
* the following parameters:<ul>
* <li>evt : EventObject<div class="sub-desc">The {@link Ext.EventObject EventObject} describing the event.</div></li>
* <li>t : Element<div class="sub-desc">The {@link Ext.core.Element Element} which was the target of the event.
* Note that this may be filtered by using the <tt>delegate</tt> option.</div></li>
* <li>o : Object<div class="sub-desc">The options object from the addListener call.</div></li>
* </ul>
* @param {Object} scope (optional) The scope (<b><code>this</code></b> reference) in which the handler function is executed. <b>Defaults to the Element</b>.
* @param {Object} options (optional) An object containing handler configuration properties.
* This may contain any of the following properties:<ul>
* <li>scope : Object<div class="sub-desc">The scope (<b><code>this</code></b> reference) in which the handler function is executed. <b>Defaults to the Element</b>.</div></li>
* <li>delegate : String<div class="sub-desc">A simple selector to filter the target or look for a descendant of the target</div></li>
* <li>stopEvent : Boolean<div class="sub-desc">True to stop the event. That is stop propagation, and prevent the default action.</div></li>
* <li>preventDefault : Boolean<div class="sub-desc">True to prevent the default action</div></li>
* <li>stopPropagation : Boolean<div class="sub-desc">True to prevent event propagation</div></li>
* <li>normalized : Boolean<div class="sub-desc">False to pass a browser event to the handler function instead of an Ext.EventObject</div></li>
* <li>delay : Number<div class="sub-desc">The number of milliseconds to delay the invocation of the handler after te event fires.</div></li>
* <li>single : Boolean<div class="sub-desc">True to add a handler to handle just the next firing of the event, and then remove itself.</div></li>
* <li>buffer : Number<div class="sub-desc">Causes the handler to be scheduled to run in an {@link Ext.util.DelayedTask} delayed
* by the specified number of milliseconds. If the event fires again within that time, the original
* handler is <em>not</em> invoked, but the new handler is scheduled in its place.</div></li>
* <li>target : Element<div class="sub-desc">Only call the handler if the event was fired on the target Element, <i>not</i> if the event was bubbled up from a child node.</div></li>
* </ul><br>
* <p>See {@link Ext.core.Element#addListener} for examples of how to use these options.</p>
*/
addListener: function(element, eventName, fn, scope, options){
// Check if we've been passed a "config style" event.
if (Ext.isObject(eventName)) {
this.prepareListenerConfig(element, eventName);
return;
}
var dom = Ext.getDom(element),
bind,
wrap;
//<debug>
if (!dom){
Ext.Error.raise({
sourceClass: 'Ext.EventManager',
sourceMethod: 'addListener',
targetElement: element,
eventName: eventName,
msg: 'Error adding "' + eventName + '\" listener for nonexistent element "' + element + '"'
});
}
if (!fn) {
Ext.Error.raise({
sourceClass: 'Ext.EventManager',
sourceMethod: 'addListener',
targetElement: element,
eventName: eventName,
msg: 'Error adding "' + eventName + '\" listener. The handler function is undefined.'
});
}
//</debug>
// create the wrapper function
options = options || {};
bind = this.normalizeEvent(eventName, fn);
wrap = this.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 == document && eventName == 'mousedown') {
this.stoppedMouseDownEvent.addListener(wrap);
}
// add all required data into the event cache
this.getEventListenerCache(dom, eventName).push({
fn: fn,
wrap: wrap,
scope: scope
});
},
/**
* Removes an event handler from an element. The shorthand version {@link #un} is equivalent. Typically
* you will use {@link Ext.core.Element#removeListener} directly on an Element in favor of calling this version.
* @param {String/HTMLElement} el The id or html element from which to remove the listener.
* @param {String} eventName The name of the event.
* @param {Function} fn The handler function to remove. <b>This must be a reference to the function passed into the {@link #addListener} call.</b>
* @param {Object} scope If a scope (<b><code>this</code></b> reference) was specified when the listener was added,
* then this must refer to the same object.
*/
removeListener : function(element, eventName, fn, scope) {
// handle our listener config object syntax
if (Ext.isObject(eventName)) {
this.prepareListenerConfig(element, eventName, true);
return;
}
var dom = Ext.getDom(element),
cache = this.getEventListenerCache(dom, eventName),
bindName = this.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;
// clear buffered calls
if (wrap.task) {
clearTimeout(wrap.task);
delete wrap.task;
}
// clear delayed calls
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 == document && eventName == 'mousedown') {
this.stoppedMouseDownEvent.removeListener(wrap);
}
// remove listener from cache
cache.splice(i, 1);
}
}
},
/**
* Removes all event handers from an element. Typically you will use {@link Ext.core.Element#removeAllListeners}
* directly on an Element in favor of calling this version.
* @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
*/
removeAll : function(element){
var dom = Ext.getDom(element),
cache, ev;
if (!dom) {
return;
}
cache = this.getElementEventCache(dom);
for (ev in cache) {
if (cache.hasOwnProperty(ev)) {
this.removeListener(dom, ev);
}
}
Ext.cache[dom.id].events = {};
},
/**
* Recursively removes all previous added listeners from an element and its children. Typically you will use {@link Ext.core.Element#purgeAllListeners}
* directly on an Element in favor of calling this version.
* @param {String/HTMLElement} el The id or html element from which to remove all event handlers.
* @param {String} eventName (optional) The name of the event.
*/
purgeElement : function(element, eventName) {
var dom = Ext.getDom(element),
i = 0, len;
if(eventName) {
this.removeListener(dom, eventName);
}
else {
this.removeAll(dom);
}
if(dom && dom.childNodes) {
for(len = element.childNodes.length; i < len; i++) {
this.purgeElement(element.childNodes[i], eventName);
}
}
},
/**
* Create the wrapper function for the event
* @private
* @param {HTMLElement} dom The dom element
* @param {String} ename The event name
* @param {Function} fn The function to execute
* @param {Object} scope The scope to execute callback in
* @param {Object} o The options
*/
createListenerWrap : function(dom, ename, fn, scope, options) {
options = !Ext.isObject(options) ? {} : options;
var f = ['if(!Ext) {return;}'],
gen;
if(options.buffer || options.delay || options.freezeEvent) {
f.push('e = new Ext.EventObjectImpl(e, ' + (options.freezeEvent ? 'true' : 'false' ) + ');');
} else {
f.push('e = Ext.EventObject.setEvent(e);');
}
if (options.delegate) {
f.push('var t = e.getTarget("' + options.delegate + '", this);');
f.push('if(!t) {return;}');
} else {
f.push('var t = e.target;');
}
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(){');
}
// finally call the actual handler fn
f.push('fn.call(scope || dom, e, t, options);');
if(options.single) {
f.push('Ext.EventManager.removeListener(dom, ename, fn, scope);');
}
if(options.delay) {
f.push('}, ' + options.delay + '));');
}
if(options.buffer) {
f.push('}, ' + options.buffer + ');');
}
gen = Ext.functionFactory('e', 'options', 'fn', 'scope', 'ename', 'dom', 'wrap', 'args', f.join('\n'));
return function wrap(e, args) {
gen.call(dom, e, options, fn, scope, ename, dom, wrap, args);
};
},
/**
* Get the event cache for a particular element for a particular event
* @private
* @param {HTMLElement} element The element
* @param {Object} eventName The event name
* @return {Array} The events for the element
*/
getEventListenerCache : function(element, eventName) {
var eventCache = this.getElementEventCache(element);
return eventCache[eventName] || (eventCache[eventName] = []);
},
/**
* Gets the event cache for the object
* @private
* @param {HTMLElement} element The element
* @return {Object} The event cache for the object
*/
getElementEventCache : function(element) {
var elementCache = Ext.cache[this.getId(element)];
return elementCache.events || (elementCache.events = {});
},
// --------------------- utility methods ---------------------
mouseLeaveRe: /(mouseout|mouseleave)/,
mouseEnterRe: /(mouseover|mouseenter)/,
/**
* Stop the event (preventDefault and stopPropagation)
* @param {Event} The event to stop
*/
stopEvent: function(event) {
this.stopPropagation(event);
this.preventDefault(event);
},
/**
* Cancels bubbling of the event.
* @param {Event} The event to stop bubbling.
*/
stopPropagation: function(event) {
event = event.browserEvent || event;
if (event.stopPropagation) {
event.stopPropagation();
} else {
event.cancelBubble = true;
}
},
/**
* Prevents the browsers default handling of the event.
* @param {Event} The event to prevent the default
*/
preventDefault: function(event) {
event = event.browserEvent || event;
if (event.preventDefault) {
event.preventDefault();
} else {
event.returnValue = false;
// Some keys events require setting the keyCode to -1 to be prevented
try {
// all ctrl + X and F1 -> F12
if (event.ctrlKey || event.keyCode > 111 && event.keyCode < 124) {
event.keyCode = -1;
}
} catch (e) {
// see this outdated document http://support.microsoft.com/kb/934364/en-us for more info
}
}
},
/**
* Gets the related target from the event.
* @param {Object} event The event
* @return {HTMLElement} The related target.
*/
getRelatedTarget: function(event) {
event = event.browserEvent || event;
var target = event.relatedTarget;
if (!target) {
if (this.mouseLeaveRe.test(event.type)) {
target = event.toElement;
} else if (this.mouseEnterRe.test(event.type)) {
target = event.fromElement;
}
}
return this.resolveTextNode(target);
},
/**
* Gets the x coordinate from the event
* @param {Object} event The event
* @return {Number} The x coordinate
*/
getPageX: function(event) {
return this.getXY(event)[0];
},
/**
* Gets the y coordinate from the event
* @param {Object} event The event
* @return {Number} The y coordinate
*/
getPageY: function(event) {
return this.getXY(event)[1];
},
/**
* Gets the x & ycoordinate from the event
* @param {Object} event The event
* @return {Array} The x/y coordinate
*/
getPageXY: function(event) {
event = event.browserEvent || event;
var x = event.pageX,
y = event.pageY,
doc = document.documentElement,
body = document.body;
// pageX/pageY not available (undefined, not null), use clientX/clientY instead
if (!x && x !== 0) {
x = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
y = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
}
return [x, y];
},
/**
* Gets the target of the event.
* @param {Object} event The event
* @return {HTMLElement} target
*/
getTarget: function(event) {
event = event.browserEvent || event;
return this.resolveTextNode(event.target || event.srcElement);
},
/**
* Resolve any text nodes accounting for browser differences.
* @private
* @param {HTMLElement} node The node
* @return {HTMLElement} The resolved node
*/
// technically no need to browser sniff this, however it makes no sense to check this every time, for every event, whether the string is equal.
resolveTextNode: Ext.isGecko ?
function(node) {
if (!node) {
return;
}
// work around firefox bug, https://bugzilla.mozilla.org/show_bug.cgi?id=101197
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;
},
// --------------------- custom event binding ---------------------
// Keep track of the current width/height
curWidth: 0,
curHeight: 0,
/**
* Adds a listener to be notified when the browser window is resized and provides resize event buffering (100 milliseconds),
* passes new viewport width and height to handlers.
* @param {Function} fn The handler function the window resize event invokes.
* @param {Object} scope The scope (<code>this</code> reference) in which the handler function executes. Defaults to the browser window.
* @param {boolean} options Options object as passed to {@link Ext.core.Element#addListener}
*/
onWindowResize: function(fn, scope, options){
var resize = this.resizeEvent;
if(!resize){
this.resizeEvent = resize = new Ext.util.Event();
this.on(window, 'resize', this.fireResize, this, {buffer: 100});
}
resize.addListener(fn, scope, options);
},
/**
* Fire the resize event.
* @private
*/
fireResize: function(){
var me = this,
w = Ext.core.Element.getViewWidth(),
h = Ext.core.Element.getViewHeight();
//whacky problem in IE where the resize event will sometimes fire even though the w/h are the same.
if(me.curHeight != h || me.curWidth != w){
me.curHeight = h;
me.curWidth = w;
me.resizeEvent.fire(w, h);
}
},
/**
* Removes the passed window resize listener.
* @param {Function} fn The method the event invokes
* @param {Object} scope The scope of handler
*/
removeResizeListener: function(fn, scope){
if (this.resizeEvent) {
this.resizeEvent.removeListener(fn, scope);
}
},
onWindowUnload: function() {
var unload = this.unloadEvent;
if (!unload) {
this.unloadEvent = unload = new Ext.util.Event();
this.addListener(window, 'unload', this.fireUnload, this);
}
},
/**
* Fires the unload event for items bound with onWindowUnload
* @private
*/
fireUnload: function() {
// wrap in a try catch, could have some problems during unload
try {
this.removeUnloadListener();
// Work around FF3 remembering the last scroll position when refreshing the grid and then losing grid view
if (Ext.isGecko3) {
var gridviews = Ext.ComponentQuery.query('gridview'),
i = 0,
ln = gridviews.length;
for (; i < ln; i++) {
gridviews[i].scrollToTop();
}
}
// Purge all elements in the cache
var el,
cache = Ext.cache;
for (el in cache) {
if (cache.hasOwnProperty(el)) {
Ext.EventManager.removeAll(el);
}
}
} catch(e) {
}
},
/**
* Removes the passed window unload listener.
* @param {Function} fn The method the event invokes
* @param {Object} scope The scope of handler
*/
removeUnloadListener: function(){
if (this.unloadEvent) {
this.removeListener(window, 'unload', this.fireUnload);
}
},
/**
* note 1: IE fires ONLY the keydown event on specialkey autorepeat
* note 2: Safari < 3.1, Gecko (Mac/Linux) & Opera fire only the keypress event on specialkey autorepeat
* (research done by @Jan Wolter at http://unixpapa.com/js/key.html)
* @private
*/
useKeyDown: Ext.isWebKit ?
parseInt(navigator.userAgent.match(/AppleWebKit\/(\d+)/)[1], 10) >= 525 :
!((Ext.isGecko && !Ext.isWindows) || Ext.isOpera),
/**
* Indicates which event to use for getting key presses.
* @return {String} The appropriate event name.
*/
getKeyEvent: function(){
return this.useKeyDown ? 'keydown' : 'keypress';
}
};
/**
* Alias for {@link Ext.Loader#onReady Ext.Loader.onReady} with withDomReady set to true
* @member Ext
* @method onReady
*/
Ext.onReady = function(fn, scope, options) {
Ext.Loader.onReady(fn, scope, true, options);
};
/**
* Alias for {@link Ext.EventManager#onDocumentReady Ext.EventManager.onDocumentReady}
* @member Ext
* @method onDocumentReady
*/
Ext.onDocumentReady = Ext.EventManager.onDocumentReady;
/**
* Alias for {@link Ext.EventManager#addListener Ext.EventManager.addListener}
* @member Ext.EventManager
* @method on
*/
Ext.EventManager.on = Ext.EventManager.addListener;
/**
* Alias for {@link Ext.EventManager#removeListener Ext.EventManager.removeListener}
* @member Ext.EventManager
* @method un
*/
Ext.EventManager.un = Ext.EventManager.removeListener;
(function(){
var initExtCss = function() {
// find the body element
var bd = document.body || document.getElementsByTagName('body')[0],
baseCSSPrefix = Ext.baseCSSPrefix,
cls = [],
htmlCls = [],
html;
if (!bd) {
return false;
}
html = bd.parentNode;
//Let's keep this human readable!
if (Ext.isIE) {
cls.push(baseCSSPrefix + 'ie');
}
if (Ext.isIE6) {
cls.push(baseCSSPrefix + 'ie6');
}
if (Ext.isIE7) {
cls.push(baseCSSPrefix + 'ie7');
}
if (Ext.isIE8) {
cls.push(baseCSSPrefix + 'ie8');
}
if (Ext.isIE9) {
cls.push(baseCSSPrefix + 'ie9');
}
if (Ext.isGecko) {
cls.push(baseCSSPrefix + 'gecko');
}
if (Ext.isGecko3) {
cls.push(baseCSSPrefix + 'gecko3');
}
if (Ext.isGecko4) {
cls.push(baseCSSPrefix + 'gecko4');
}
if (Ext.isOpera) {
cls.push(baseCSSPrefix + 'opera');
}
if (Ext.isWebKit) {
cls.push(baseCSSPrefix + 'webkit');
}
if (Ext.isSafari) {
cls.push(baseCSSPrefix + 'safari');
}
if (Ext.isSafari2) {
cls.push(baseCSSPrefix + 'safari2');
}
if (Ext.isSafari3) {
cls.push(baseCSSPrefix + 'safari3');
}
if (Ext.isSafari4) {
cls.push(baseCSSPrefix + 'safari4');
}
if (Ext.isChrome) {
cls.push(baseCSSPrefix + 'chrome');
}
if (Ext.isMac) {
cls.push(baseCSSPrefix + 'mac');
}
if (Ext.isLinux) {
cls.push(baseCSSPrefix + 'linux');
}
if (!Ext.supports.CSS3BorderRadius) {
cls.push(baseCSSPrefix + 'nbr');
}
if (!Ext.supports.CSS3LinearGradient) {
cls.push(baseCSSPrefix + 'nlg');
}
if (!Ext.scopeResetCSS) {
cls.push(baseCSSPrefix + 'reset');
}
// add to the parent to allow for selectors x-strict x-border-box, also set the isBorderBox property correctly
if (html) {
if (Ext.isStrict && (Ext.isIE6 || Ext.isIE7)) {
Ext.isBorderBox = false;
}
else {
Ext.isBorderBox = true;
}
htmlCls.push(baseCSSPrefix + (Ext.isBorderBox ? 'border-box' : 'strict'));
if (!Ext.isStrict) {
htmlCls.push(baseCSSPrefix + 'quirks');
if (Ext.isIE && !Ext.isStrict) {
Ext.isIEQuirks = true;
}
}
Ext.fly(html, '_internal').addCls(htmlCls);
}
Ext.fly(bd, '_internal').addCls(cls);
return true;
};
Ext.onReady(initExtCss);
})();