text: /*
  This file is part of Ext JS 4.1
  
  Copyright (c) 2011-2012 Sencha Inc
  
  Contact:  http://www.sencha.com/contact
  
  Commercial Usage
  Licensees holding valid commercial licenses may use this file in accordance with the Commercial
  Software License Agreement provided with the Software or, alternatively, in accordance with the
  terms contained in a written agreement between you and Sencha.
  
  If you are unsure which license is appropriate for your use, please contact the sales department
  at http://www.sencha.com/contact.
  
  Build date: 2012-07-04 21:23:42 (65ff594cd80b9bad45df640c22cc0adb52c95a7b)
  */
  
  
  var Ext = Ext || {};
  Ext._startTime = new Date().getTime();
  (function() {
      var global = this,
          objectPrototype = Object.prototype,
          toString = objectPrototype.toString,
          enumerables = true,
          enumerablesTest = { toString: 1 },
          emptyFn = function () {},
          
          
          callOverrideParent = function () {
              var method = callOverrideParent.caller.caller; 
              return method.$owner.prototype[method.$name].apply(this, arguments);
          },
          i;
  
      Ext.global = global;
  
      for (i in enumerablesTest) {
          enumerables = null;
      }
  
      if (enumerables) {
          enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable',
                         'toLocaleString', 'toString', 'constructor'];
      }
  
      
      Ext.enumerables = enumerables;
  
      
      Ext.apply = function(object, config, defaults) {
          if (defaults) {
              Ext.apply(object, defaults);
          }
  
          if (object && config && typeof config === 'object') {
              var i, j, k;
  
              for (i in config) {
                  object[i] = config[i];
              }
  
              if (enumerables) {
                  for (j = enumerables.length; j--;) {
                      k = enumerables[j];
                      if (config.hasOwnProperty(k)) {
                          object[k] = config[k];
                      }
                  }
              }
          }
  
          return object;
      };
  
      Ext.buildSettings = Ext.apply({
          baseCSSPrefix: 'x-',
          scopeResetCSS: false
      }, Ext.buildSettings || {});
  
      Ext.apply(Ext, {
  
          
          name: Ext.sandboxName || 'Ext',
  
          
          emptyFn: emptyFn,
  
          
          emptyString: new String(),
  
          baseCSSPrefix: Ext.buildSettings.baseCSSPrefix,
  
          
          applyIf: function(object, config) {
              var property;
  
              if (object) {
                  for (property in config) {
                      if (object[property] === undefined) {
                          object[property] = config[property];
                      }
                  }
              }
  
              return object;
          },
  
          
          iterate: function(object, fn, scope) {
              if (Ext.isEmpty(object)) {
                  return;
              }
  
              if (scope === undefined) {
                  scope = object;
              }
  
              if (Ext.isIterable(object)) {
                  Ext.Array.each.call(Ext.Array, object, fn, scope);
              }
              else {
                  Ext.Object.each.call(Ext.Object, object, fn, scope);
              }
          }
      });
  
      Ext.apply(Ext, {
  
          
          extend: (function() {
              
              var objectConstructor = objectPrototype.constructor,
                  inlineOverrides = function(o) {
                  for (var m in o) {
                      if (!o.hasOwnProperty(m)) {
                          continue;
                      }
                      this[m] = o[m];
                  }
              };
  
              return function(subclass, superclass, overrides) {
                  
                  if (Ext.isObject(superclass)) {
                      overrides = superclass;
                      superclass = subclass;
                      subclass = overrides.constructor !== objectConstructor ? overrides.constructor : function() {
                          superclass.apply(this, arguments);
                      };
                  }
  
  
                  
                  var F = function() {},
                      subclassProto, superclassProto = superclass.prototype;
  
                  F.prototype = superclassProto;
                  subclassProto = subclass.prototype = new F();
                  subclassProto.constructor = subclass;
                  subclass.superclass = superclassProto;
  
                  if (superclassProto.constructor === objectConstructor) {
                      superclassProto.constructor = superclass;
                  }
  
                  subclass.override = function(overrides) {
                      Ext.override(subclass, overrides);
                  };
  
                  subclassProto.override = inlineOverrides;
                  subclassProto.proto = subclassProto;
  
                  subclass.override(overrides);
                  subclass.extend = function(o) {
                      return Ext.extend(subclass, o);
                  };
  
                  return subclass;
              };
          }()),
  
          
          override: function (target, overrides) {
              if (target.$isClass) {
                  target.override(overrides);
              } else if (typeof target == 'function') {
                  Ext.apply(target.prototype, overrides);
              } else {
                  var owner = target.self,
                      name, value;
  
                  if (owner && owner.$isClass) { 
                      for (name in overrides) {
                          if (overrides.hasOwnProperty(name)) {
                              value = overrides[name];
  
                              if (typeof value == 'function') {
  
                                  value.$name = name;
                                  value.$owner = owner;
                                  value.$previous = target.hasOwnProperty(name)
                                      ? target[name] 
                                      : callOverrideParent; 
                              }
  
                              target[name] = value;
                          }
                      }
                  } else {
                      Ext.apply(target, overrides);
                  }
              }
  
              return target;
          }
      });
  
      
      Ext.apply(Ext, {
  
          
          valueFrom: function(value, defaultValue, allowBlank){
              return Ext.isEmpty(value, allowBlank) ? defaultValue : value;
          },
  
          
          typeOf: function(value) {
              var type,
                  typeToString;
              
              if (value === null) {
                  return 'null';
              }
  
              type = typeof value;
  
              if (type === 'undefined' || type === 'string' || type === 'number' || type === 'boolean') {
                  return type;
              }
  
              typeToString = toString.call(value);
  
              switch(typeToString) {
                  case '[object Array]':
                      return 'array';
                  case '[object Date]':
                      return 'date';
                  case '[object Boolean]':
                      return 'boolean';
                  case '[object Number]':
                      return 'number';
                  case '[object RegExp]':
                      return 'regexp';
              }
  
              if (type === 'function') {
                  return 'function';
              }
  
              if (type === 'object') {
                  if (value.nodeType !== undefined) {
                      if (value.nodeType === 3) {
                          return (/\S/).test(value.nodeValue) ? 'textnode' : 'whitespace';
                      }
                      else {
                          return 'element';
                      }
                  }
  
                  return 'object';
              }
  
          },
  
          
          isEmpty: function(value, allowEmptyString) {
              return (value === null) || (value === undefined) || (!allowEmptyString ? value === '' : false) || (Ext.isArray(value) && value.length === 0);
          },
  
          
          isArray: ('isArray' in Array) ? Array.isArray : function(value) {
              return toString.call(value) === '[object Array]';
          },
  
          
          isDate: function(value) {
              return toString.call(value) === '[object Date]';
          },
  
          
          isObject: (toString.call(null) === '[object Object]') ?
          function(value) {
              
              return value !== null && value !== undefined && toString.call(value) === '[object Object]' && value.ownerDocument === undefined;
          } :
          function(value) {
              return toString.call(value) === '[object Object]';
          },
  
          
          isSimpleObject: function(value) {
              return value instanceof Object && value.constructor === Object;
          },
          
          isPrimitive: function(value) {
              var type = typeof value;
  
              return type === 'string' || type === 'number' || type === 'boolean';
          },
  
          
          isFunction:
          
          
          (typeof document !== 'undefined' && typeof document.getElementsByTagName('body') === 'function') ? function(value) {
              return toString.call(value) === '[object Function]';
          } : function(value) {
              return typeof value === 'function';
          },
  
          
          isNumber: function(value) {
              return typeof value === 'number' && isFinite(value);
          },
  
          
          isNumeric: function(value) {
              return !isNaN(parseFloat(value)) && isFinite(value);
          },
  
          
          isString: function(value) {
              return typeof value === 'string';
          },
  
          
          isBoolean: function(value) {
              return typeof value === 'boolean';
          },
  
          
          isElement: function(value) {
              return value ? value.nodeType === 1 : false;
          },
  
          
          isTextNode: function(value) {
              return value ? value.nodeName === "#text" : false;
          },
  
          
          isDefined: function(value) {
              return typeof value !== 'undefined';
          },
  
          
          isIterable: function(value) {
              var type = typeof value,
                  checkLength = false;
              if (value && type != 'string') {
                  
                  if (type == 'function') {
                      
                      
                      if (Ext.isSafari) {
                          checkLength = value instanceof NodeList || value instanceof HTMLCollection;
                      }
                  } else {
                      checkLength = true;
                  }
              }
              return checkLength ? value.length !== undefined : false;
          }
      });
  
      Ext.apply(Ext, {
  
          
          clone: function(item) {
              var type,
                  i,
                  j,
                  k,
                  clone,
                  key;
              
              if (item === null || item === undefined) {
                  return item;
              }
  
              
              
              
              if (item.nodeType && item.cloneNode) {
                  return item.cloneNode(true);
              }
  
              type = toString.call(item);
  
              
              if (type === '[object Date]') {
                  return new Date(item.getTime());
              }
  
  
              
              if (type === '[object Array]') {
                  i = item.length;
  
                  clone = [];
  
                  while (i--) {
                      clone[i] = Ext.clone(item[i]);
                  }
              }
              
              else if (type === '[object Object]' && item.constructor === Object) {
                  clone = {};
  
                  for (key in item) {
                      clone[key] = Ext.clone(item[key]);
                  }
  
                  if (enumerables) {
                      for (j = enumerables.length; j--;) {
                          k = enumerables[j];
                          clone[k] = item[k];
                      }
                  }
              }
  
              return clone || item;
          },
  
          
          getUniqueGlobalNamespace: function() {
              var uniqueGlobalNamespace = this.uniqueGlobalNamespace,
                  i;
  
              if (uniqueGlobalNamespace === undefined) {
                  i = 0;
  
                  do {
                      uniqueGlobalNamespace = 'ExtBox' + (++i);
                  } while (Ext.global[uniqueGlobalNamespace] !== undefined);
  
                  Ext.global[uniqueGlobalNamespace] = Ext;
                  this.uniqueGlobalNamespace = uniqueGlobalNamespace;
              }
  
              return uniqueGlobalNamespace;
          },
          
          
          functionFactoryCache: {},
          
          cacheableFunctionFactory: function() {
              var me = this,
                  args = Array.prototype.slice.call(arguments),
                  cache = me.functionFactoryCache,
                  idx, fn, ln;
                  
               if (Ext.isSandboxed) {
                  ln = args.length;
                  if (ln > 0) {
                      ln--;
                      args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];
                  }
              }
              idx = args.join('');
              fn = cache[idx];
              if (!fn) {
                  fn = Function.prototype.constructor.apply(Function.prototype, args);
                  
                  cache[idx] = fn;
              }
              return fn;
          },
          
          functionFactory: function() {
              var me = this,
                  args = Array.prototype.slice.call(arguments),
                  ln;
                  
              if (Ext.isSandboxed) {
                  ln = args.length;
                  if (ln > 0) {
                      ln--;
                      args[ln] = 'var Ext=window.' + Ext.name + ';' + args[ln];
                  }
              }
       
              return Function.prototype.constructor.apply(Function.prototype, args);
          },
  
          
          Logger: {
              verbose: emptyFn,
              log: emptyFn,
              info: emptyFn,
              warn: emptyFn,
              error: function(message) {
                  throw new Error(message);
              },
              deprecate: emptyFn
          }
      });
  
      
      Ext.type = Ext.typeOf;
  
  }());
  
  
  Ext.globalEval = Ext.global.execScript
      ? function(code) {
          execScript(code);
      }
      : function($$code) {
          
          
          (function(){
              eval($$code);
          }());
      };
  
  
  (function() {
  
  
  var version = '4.1.1', Version;
      Ext.Version = Version = Ext.extend(Object, {
  
          
          constructor: function(version) {
              var parts, releaseStartIndex;
  
              if (version instanceof Version) {
                  return version;
              }
  
              this.version = this.shortVersion = String(version).toLowerCase().replace(/_/g, '.').replace(/[\-+]/g, '');
  
              releaseStartIndex = this.version.search(/([^\d\.])/);
  
              if (releaseStartIndex !== -1) {
                  this.release = this.version.substr(releaseStartIndex, version.length);
                  this.shortVersion = this.version.substr(0, releaseStartIndex);
              }
  
              this.shortVersion = this.shortVersion.replace(/[^\d]/g, '');
  
              parts = this.version.split('.');
  
              this.major = parseInt(parts.shift() || 0, 10);
              this.minor = parseInt(parts.shift() || 0, 10);
              this.patch = parseInt(parts.shift() || 0, 10);
              this.build = parseInt(parts.shift() || 0, 10);
  
              return this;
          },
  
          
          toString: function() {
              return this.version;
          },
  
          
          valueOf: function() {
              return this.version;
          },
  
          
          getMajor: function() {
              return this.major || 0;
          },
  
          
          getMinor: function() {
              return this.minor || 0;
          },
  
          
          getPatch: function() {
              return this.patch || 0;
          },
  
          
          getBuild: function() {
              return this.build || 0;
          },
  
          
          getRelease: function() {
              return this.release || '';
          },
  
          
          isGreaterThan: function(target) {
              return Version.compare(this.version, target) === 1;
          },
  
          
          isGreaterThanOrEqual: function(target) {
              return Version.compare(this.version, target) >= 0;
          },
  
          
          isLessThan: function(target) {
              return Version.compare(this.version, target) === -1;
          },
  
          
          isLessThanOrEqual: function(target) {
              return Version.compare(this.version, target) <= 0;
          },
  
          
          equals: function(target) {
              return Version.compare(this.version, target) === 0;
          },
  
          
          match: function(target) {
              target = String(target);
              return this.version.substr(0, target.length) === target;
          },
  
          
          toArray: function() {
              return [this.getMajor(), this.getMinor(), this.getPatch(), this.getBuild(), this.getRelease()];
          },
  
          
          getShortVersion: function() {
              return this.shortVersion;
          },
  
          
          gt: function() {
              return this.isGreaterThan.apply(this, arguments);
          },
  
          
          lt: function() {
              return this.isLessThan.apply(this, arguments);
          },
  
          
          gtEq: function() {
              return this.isGreaterThanOrEqual.apply(this, arguments);
          },
  
          
          ltEq: function() {
              return this.isLessThanOrEqual.apply(this, arguments);
          }
      });
  
      Ext.apply(Version, {
          
          releaseValueMap: {
              'dev': -6,
              'alpha': -5,
              'a': -5,
              'beta': -4,
              'b': -4,
              'rc': -3,
              '#': -2,
              'p': -1,
              'pl': -1
          },
  
          
          getComponentValue: function(value) {
              return !value ? 0 : (isNaN(value) ? this.releaseValueMap[value] || value : parseInt(value, 10));
          },
  
          
          compare: function(current, target) {
              var currentValue, targetValue, i;
  
              current = new Version(current).toArray();
              target = new Version(target).toArray();
  
              for (i = 0; i < Math.max(current.length, target.length); i++) {
                  currentValue = this.getComponentValue(current[i]);
                  targetValue = this.getComponentValue(target[i]);
  
                  if (currentValue < targetValue) {
                      return -1;
                  } else if (currentValue > targetValue) {
                      return 1;
                  }
              }
  
              return 0;
          }
      });
  
      
      Ext.apply(Ext, {
          
          versions: {},
  
          
          lastRegisteredVersion: null,
  
          
          setVersion: function(packageName, version) {
              Ext.versions[packageName] = new Version(version);
              Ext.lastRegisteredVersion = Ext.versions[packageName];
  
              return this;
          },
  
          
          getVersion: function(packageName) {
              if (packageName === undefined) {
                  return Ext.lastRegisteredVersion;
              }
  
              return Ext.versions[packageName];
          },
  
          
          deprecate: function(packageName, since, closure, scope) {
              if (Version.compare(Ext.getVersion(packageName), since) < 1) {
                  closure.call(scope);
              }
          }
      }); 
  
      Ext.setVersion('core', version);
  
  }());
  
  
  
  Ext.String = (function() {
      var trimRegex     = /^[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+|[\x09\x0a\x0b\x0c\x0d\x20\xa0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000]+$/g,
          escapeRe      = /('|\\)/g,
          formatRe      = /\{(\d+)\}/g,
          escapeRegexRe = /([-.*+?\^${}()|\[\]\/\\])/g,
          basicTrimRe   = /^\s+|\s+$/g,
          whitespaceRe  = /\s+/,
          varReplace    = /(^[^a-z]*|[^\w])/gi,
          charToEntity,
          entityToChar,
          charToEntityRegex,
          entityToCharRegex,
          htmlEncodeReplaceFn = function(match, capture) {
              return charToEntity[capture];
          },
          htmlDecodeReplaceFn = function(match, capture) {
              return (capture in entityToChar) ? entityToChar[capture] : String.fromCharCode(parseInt(capture.substr(2), 10));
          };
  
      return {
  
          
          createVarName: function(s) {
              return s.replace(varReplace, '');
          },
  
          
          htmlEncode: function(value) {
              return (!value) ? value : String(value).replace(charToEntityRegex, htmlEncodeReplaceFn);
          },
  
          
          htmlDecode: function(value) {
              return (!value) ? value : String(value).replace(entityToCharRegex, htmlDecodeReplaceFn);
          },
  
          
          addCharacterEntities: function(newEntities) {
              var charKeys = [],
                  entityKeys = [],
                  key, echar;
              for (key in newEntities) {
                  echar = newEntities[key];
                  entityToChar[key] = echar;
                  charToEntity[echar] = key;
                  charKeys.push(echar);
                  entityKeys.push(key);
              }
              charToEntityRegex = new RegExp('(' + charKeys.join('|') + ')', 'g');
              entityToCharRegex = new RegExp('(' + entityKeys.join('|') + '|&#[0-9]{1,5};' + ')', 'g');
          },
  
          
          resetCharacterEntities: function() {
              charToEntity = {};
              entityToChar = {};
              
              this.addCharacterEntities({
                  '&amp;'     :   '&',
                  '&gt;'      :   '>',
                  '&lt;'      :   '<',
                  '&quot;'    :   '"',
                  '&#39;'     :   "'"
              });
          },
  
          
          urlAppend : function(url, string) {
              if (!Ext.isEmpty(string)) {
                  return url + (url.indexOf('?') === -1 ? '?' : '&') + string;
              }
  
              return url;
          },
  
          
          trim: function(string) {
              return string.replace(trimRegex, "");
          },
  
          
          capitalize: function(string) {
              return string.charAt(0).toUpperCase() + string.substr(1);
          },
  
          
          uncapitalize: function(string) {
              return string.charAt(0).toLowerCase() + string.substr(1);
          },
  
          
          ellipsis: function(value, len, word) {
              if (value && value.length > len) {
                  if (word) {
                      var vs = value.substr(0, len - 2),
                      index = Math.max(vs.lastIndexOf(' '), vs.lastIndexOf('.'), vs.lastIndexOf('!'), vs.lastIndexOf('?'));
                      if (index !== -1 && index >= (len - 15)) {
                          return vs.substr(0, index) + "...";
                      }
                  }
                  return value.substr(0, len - 3) + "...";
              }
              return value;
          },
  
          
          escapeRegex: function(string) {
              return string.replace(escapeRegexRe, "\\$1");
          },
  
          
          escape: function(string) {
              return string.replace(escapeRe, "\\$1");
          },
  
          
          toggle: function(string, value, other) {
              return string === value ? other : value;
          },
  
          
          leftPad: function(string, size, character) {
              var result = String(string);
              character = character || " ";
              while (result.length < size) {
                  result = character + result;
              }
              return result;
          },
  
          
          format: function(format) {
              var args = Ext.Array.toArray(arguments, 1);
              return format.replace(formatRe, function(m, i) {
                  return args[i];
              });
          },
  
          
          repeat: function(pattern, count, sep) {
              for (var buf = [], i = count; i--; ) {
                  buf.push(pattern);
              }
              return buf.join(sep || '');
          },
  
          
          splitWords: function (words) {
              if (words && typeof words == 'string') {
                  return words.replace(basicTrimRe, '').split(whitespaceRe);
              }
              return words || [];
          }
      };
  }());
  
  
  Ext.String.resetCharacterEntities();
  
  
  Ext.htmlEncode = Ext.String.htmlEncode;
  
  
  
  Ext.htmlDecode = Ext.String.htmlDecode;
  
  
  Ext.urlAppend = Ext.String.urlAppend;
  
  
  Ext.Number = new function() {
  
      var me = this,
          isToFixedBroken = (0.9).toFixed() !== '1',
          math = Math;
  
      Ext.apply(this, {
          
          constrain: function(number, min, max) {
              var x = parseFloat(number);
  
              
              
  
              
              
              
              
              
              return (x < min) ? min : ((x > max) ? max : x);
          },
  
          
          snap : function(value, increment, minValue, maxValue) {
              var m;
  
              
              
              if (value === undefined || value < minValue) {
                  return minValue || 0;
              }
  
              if (increment) {
                  m = value % increment;
                  if (m !== 0) {
                      value -= m;
                      if (m * 2 >= increment) {
                          value += increment;
                      } else if (m * 2 < -increment) {
                          value -= increment;
                      }
                  }
              }
              return me.constrain(value, minValue,  maxValue);
          },
  
          
          snapInRange : function(value, increment, minValue, maxValue) {
              var tween;
  
              
              minValue = (minValue || 0);
  
              
              if (value === undefined || value < minValue) {
                  return minValue;
              }
  
              
              if (increment && (tween = ((value - minValue) % increment))) {
                  value -= tween;
                  tween *= 2;
                  if (tween >= increment) {
                      value += increment;
                  }
              }
  
              
              if (maxValue !== undefined) {
                  if (value > (maxValue = me.snapInRange(maxValue, increment, minValue))) {
                      value = maxValue;
                  }
              }
  
              return value;
          },
  
          
          toFixed: isToFixedBroken ? function(value, precision) {
              precision = precision || 0;
              var pow = math.pow(10, precision);
              return (math.round(value * pow) / pow).toFixed(precision);
          } : function(value, precision) {
              return value.toFixed(precision);
          },
  
          
          from: function(value, defaultValue) {
              if (isFinite(value)) {
                  value = parseFloat(value);
              }
  
              return !isNaN(value) ? value : defaultValue;
          },
  
          
          randomInt: function (from, to) {
             return math.floor(math.random() * (to - from + 1) + from);
          }
      });
  
      
      Ext.num = function() {
          return me.from.apply(this, arguments);
      };
  };
  
  (function() {
  
      var arrayPrototype = Array.prototype,
          slice = arrayPrototype.slice,
          supportsSplice = (function () {
              var array = [],
                  lengthBefore,
                  j = 20;
  
              if (!array.splice) {
                  return false;
              }
  
              
              
  
              while (j--) {
                  array.push("A");
              }
  
              array.splice(15, 0, "F", "F", "F", "F", "F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F","F");
  
              lengthBefore = array.length; 
              array.splice(13, 0, "XXX"); 
  
              if (lengthBefore+1 != array.length) {
                  return false;
              }
              
  
              return true;
          }()),
          supportsForEach = 'forEach' in arrayPrototype,
          supportsMap = 'map' in arrayPrototype,
          supportsIndexOf = 'indexOf' in arrayPrototype,
          supportsEvery = 'every' in arrayPrototype,
          supportsSome = 'some' in arrayPrototype,
          supportsFilter = 'filter' in arrayPrototype,
          supportsSort = (function() {
              var a = [1,2,3,4,5].sort(function(){ return 0; });
              return a[0] === 1 && a[1] === 2 && a[2] === 3 && a[3] === 4 && a[4] === 5;
          }()),
          supportsSliceOnNodeList = true,
          ExtArray,
          erase,
          replace,
          splice;
  
      try {
          
          if (typeof document !== 'undefined') {
              slice.call(document.getElementsByTagName('body'));
          }
      } catch (e) {
          supportsSliceOnNodeList = false;
      }
  
      function fixArrayIndex (array, index) {
          return (index < 0) ? Math.max(0, array.length + index)
                             : Math.min(array.length, index);
      }
  
      
      function replaceSim (array, index, removeCount, insert) {
          var add = insert ? insert.length : 0,
              length = array.length,
              pos = fixArrayIndex(array, index),
              remove,
              tailOldPos,
              tailNewPos,
              tailCount,
              lengthAfterRemove,
              i;
  
          
          if (pos === length) {
              if (add) {
                  array.push.apply(array, insert);
              }
          } else {
              remove = Math.min(removeCount, length - pos);
              tailOldPos = pos + remove;
              tailNewPos = tailOldPos + add - remove;
              tailCount = length - tailOldPos;
              lengthAfterRemove = length - remove;
  
              if (tailNewPos < tailOldPos) { 
                  for (i = 0; i < tailCount; ++i) {
                      array[tailNewPos+i] = array[tailOldPos+i];
                  }
              } else if (tailNewPos > tailOldPos) { 
                  for (i = tailCount; i--; ) {
                      array[tailNewPos+i] = array[tailOldPos+i];
                  }
              } 
  
              if (add && pos === lengthAfterRemove) {
                  array.length = lengthAfterRemove; 
                  array.push.apply(array, insert);
              } else {
                  array.length = lengthAfterRemove + add; 
                  for (i = 0; i < add; ++i) {
                      array[pos+i] = insert[i];
                  }
              }
          }
  
          return array;
      }
  
      function replaceNative (array, index, removeCount, insert) {
          if (insert && insert.length) {
              if (index < array.length) {
                  array.splice.apply(array, [index, removeCount].concat(insert));
              } else {
                  array.push.apply(array, insert);
              }
          } else {
              array.splice(index, removeCount);
          }
          return array;
      }
  
      function eraseSim (array, index, removeCount) {
          return replaceSim(array, index, removeCount);
      }
  
      function eraseNative (array, index, removeCount) {
          array.splice(index, removeCount);
          return array;
      }
  
      function spliceSim (array, index, removeCount) {
          var pos = fixArrayIndex(array, index),
              removed = array.slice(index, fixArrayIndex(array, pos+removeCount));
  
          if (arguments.length < 4) {
              replaceSim(array, pos, removeCount);
          } else {
              replaceSim(array, pos, removeCount, slice.call(arguments, 3));
          }
  
          return removed;
      }
  
      function spliceNative (array) {
          return array.splice.apply(array, slice.call(arguments, 1));
      }
  
      erase = supportsSplice ? eraseNative : eraseSim;
      replace = supportsSplice ? replaceNative : replaceSim;
      splice = supportsSplice ? spliceNative : spliceSim;
  
      
  
      ExtArray = Ext.Array = {
          
          each: function(array, fn, scope, reverse) {
              array = ExtArray.from(array);
  
              var i,
                  ln = array.length;
  
              if (reverse !== true) {
                  for (i = 0; i < ln; i++) {
                      if (fn.call(scope || array[i], array[i], i, array) === false) {
                          return i;
                      }
                  }
              }
              else {
                  for (i = ln - 1; i > -1; i--) {
                      if (fn.call(scope || array[i], array[i], i, array) === false) {
                          return i;
                      }
                  }
              }
  
              return true;
          },
  
          
          forEach: supportsForEach ? function(array, fn, scope) {
              return array.forEach(fn, scope);
          } : function(array, fn, scope) {
              var i = 0,
                  ln = array.length;
  
              for (; i < ln; i++) {
                  fn.call(scope, array[i], i, array);
              }
          },
  
          
          indexOf: supportsIndexOf ? function(array, item, from) {
              return array.indexOf(item, from);
           } : function(array, item, from) {
              var i, length = array.length;
  
              for (i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++) {
                  if (array[i] === item) {
                      return i;
                  }
              }
  
              return -1;
          },
  
          
          contains: supportsIndexOf ? function(array, item) {
              return array.indexOf(item) !== -1;
          } : function(array, item) {
              var i, ln;
  
              for (i = 0, ln = array.length; i < ln; i++) {
                  if (array[i] === item) {
                      return true;
                  }
              }
  
              return false;
          },
  
          
          toArray: function(iterable, start, end){
              if (!iterable || !iterable.length) {
                  return [];
              }
  
              if (typeof iterable === 'string') {
                  iterable = iterable.split('');
              }
  
              if (supportsSliceOnNodeList) {
                  return slice.call(iterable, start || 0, end || iterable.length);
              }
  
              var array = [],
                  i;
  
              start = start || 0;
              end = end ? ((end < 0) ? iterable.length + end : end) : iterable.length;
  
              for (i = start; i < end; i++) {
                  array.push(iterable[i]);
              }
  
              return array;
          },
  
          
          pluck: function(array, propertyName) {
              var ret = [],
                  i, ln, item;
  
              for (i = 0, ln = array.length; i < ln; i++) {
                  item = array[i];
  
                  ret.push(item[propertyName]);
              }
  
              return ret;
          },
  
          
          map: supportsMap ? function(array, fn, scope) {
              return array.map(fn, scope);
          } : function(array, fn, scope) {
              var results = [],
                  i = 0,
                  len = array.length;
  
              for (; i < len; i++) {
                  results[i] = fn.call(scope, array[i], i, array);
              }
  
              return results;
          },
  
          
          every: supportsEvery ? function(array, fn, scope) {
              return array.every(fn, scope);
          } : function(array, fn, scope) {
              var i = 0,
                  ln = array.length;
  
              for (; i < ln; ++i) {
                  if (!fn.call(scope, array[i], i, array)) {
                      return false;
                  }
              }
  
              return true;
          },
  
          
          some: supportsSome ? function(array, fn, scope) {
              return array.some(fn, scope);
          } : function(array, fn, scope) {
              var i = 0,
                  ln = array.length;
  
              for (; i < ln; ++i) {
                  if (fn.call(scope, array[i], i, array)) {
                      return true;
                  }
              }
  
              return false;
          },
  
          
          clean: function(array) {
              var results = [],
                  i = 0,
                  ln = array.length,
                  item;
  
              for (; i < ln; i++) {
                  item = array[i];
  
                  if (!Ext.isEmpty(item)) {
                      results.push(item);
                  }
              }
  
              return results;
          },
  
          
          unique: function(array) {
              var clone = [],
                  i = 0,
                  ln = array.length,
                  item;
  
              for (; i < ln; i++) {
                  item = array[i];
  
                  if (ExtArray.indexOf(clone, item) === -1) {
                      clone.push(item);
                  }
              }
  
              return clone;
          },
  
          
          filter: supportsFilter ? function(array, fn, scope) {
              return array.filter(fn, scope);
          } : function(array, fn, scope) {
              var results = [],
                  i = 0,
                  ln = array.length;
  
              for (; i < ln; i++) {
                  if (fn.call(scope, array[i], i, array)) {
                      results.push(array[i]);
                  }
              }
  
              return results;
          },
  
          
          from: function(value, newReference) {
              if (value === undefined || value === null) {
                  return [];
              }
  
              if (Ext.isArray(value)) {
                  return (newReference) ? slice.call(value) : value;
              }
  
              var type = typeof value;
              
              
              if (value && value.length !== undefined && type !== 'string' && (type !== 'function' || !value.apply)) {
                  return ExtArray.toArray(value);
              }
  
              return [value];
          },
  
          
          remove: function(array, item) {
              var index = ExtArray.indexOf(array, item);
  
              if (index !== -1) {
                  erase(array, index, 1);
              }
  
              return array;
          },
  
          
          include: function(array, item) {
              if (!ExtArray.contains(array, item)) {
                  array.push(item);
              }
          },
  
          
          clone: function(array) {
              return slice.call(array);
          },
  
          
          merge: function() {
              var args = slice.call(arguments),
                  array = [],
                  i, ln;
  
              for (i = 0, ln = args.length; i < ln; i++) {
                  array = array.concat(args[i]);
              }
  
              return ExtArray.unique(array);
          },
  
          
          intersect: function() {
              var intersection = [],
                  arrays = slice.call(arguments),
                  arraysLength,
                  array,
                  arrayLength,
                  minArray,
                  minArrayIndex,
                  minArrayCandidate,
                  minArrayLength,
                  element,
                  elementCandidate,
                  elementCount,
                  i, j, k;
  
              if (!arrays.length) {
                  return intersection;
              }
  
              
              arraysLength = arrays.length;
              for (i = minArrayIndex = 0; i < arraysLength; i++) {
                  minArrayCandidate = arrays[i];
                  if (!minArray || minArrayCandidate.length < minArray.length) {
                      minArray = minArrayCandidate;
                      minArrayIndex = i;
                  }
              }
  
              minArray = ExtArray.unique(minArray);
              erase(arrays, minArrayIndex, 1);
  
              
              
              
              minArrayLength = minArray.length;
              arraysLength = arrays.length;
              for (i = 0; i < minArrayLength; i++) {
                  element = minArray[i];
                  elementCount = 0;
  
                  for (j = 0; j < arraysLength; j++) {
                      array = arrays[j];
                      arrayLength = array.length;
                      for (k = 0; k < arrayLength; k++) {
                          elementCandidate = array[k];
                          if (element === elementCandidate) {
                              elementCount++;
                              break;
                          }
                      }
                  }
  
                  if (elementCount === arraysLength) {
                      intersection.push(element);
                  }
              }
  
              return intersection;
          },
  
          
          difference: function(arrayA, arrayB) {
              var clone = slice.call(arrayA),
                  ln = clone.length,
                  i, j, lnB;
  
              for (i = 0,lnB = arrayB.length; i < lnB; i++) {
                  for (j = 0; j < ln; j++) {
                      if (clone[j] === arrayB[i]) {
                          erase(clone, j, 1);
                          j--;
                          ln--;
                      }
                  }
              }
  
              return clone;
          },
  
          
          
          slice: ([1,2].slice(1, undefined).length ?
              function (array, begin, end) {
                  return slice.call(array, begin, end);
              } :
              
              function (array, begin, end) {
                  
                  
                  if (typeof begin === 'undefined') {
                      return slice.call(array);
                  }
                  if (typeof end === 'undefined') {
                      return slice.call(array, begin);
                  }
                  return slice.call(array, begin, end);
              }
          ),
  
          
          sort: supportsSort ? function(array, sortFn) {
              if (sortFn) {
                  return array.sort(sortFn);
              } else {
                  return array.sort();
              }
           } : function(array, sortFn) {
              var length = array.length,
                  i = 0,
                  comparison,
                  j, min, tmp;
  
              for (; i < length; i++) {
                  min = i;
                  for (j = i + 1; j < length; j++) {
                      if (sortFn) {
                          comparison = sortFn(array[j], array[min]);
                          if (comparison < 0) {
                              min = j;
                          }
                      } else if (array[j] < array[min]) {
                          min = j;
                      }
                  }
                  if (min !== i) {
                      tmp = array[i];
                      array[i] = array[min];
                      array[min] = tmp;
                  }
              }
  
              return array;
          },
  
          
          flatten: function(array) {
              var worker = [];
  
              function rFlatten(a) {
                  var i, ln, v;
  
                  for (i = 0, ln = a.length; i < ln; i++) {
                      v = a[i];
  
                      if (Ext.isArray(v)) {
                          rFlatten(v);
                      } else {
                          worker.push(v);
                      }
                  }
  
                  return worker;
              }
  
              return rFlatten(array);
          },
  
          
          min: function(array, comparisonFn) {
              var min = array[0],
                  i, ln, item;
  
              for (i = 0, ln = array.length; i < ln; i++) {
                  item = array[i];
  
                  if (comparisonFn) {
                      if (comparisonFn(min, item) === 1) {
                          min = item;
                      }
                  }
                  else {
                      if (item < min) {
                          min = item;
                      }
                  }
              }
  
              return min;
          },
  
          
          max: function(array, comparisonFn) {
              var max = array[0],
                  i, ln, item;
  
              for (i = 0, ln = array.length; i < ln; i++) {
                  item = array[i];
  
                  if (comparisonFn) {
                      if (comparisonFn(max, item) === -1) {
                          max = item;
                      }
                  }
                  else {
                      if (item > max) {
                          max = item;
                      }
                  }
              }
  
              return max;
          },
  
          
          mean: function(array) {
              return array.length > 0 ? ExtArray.sum(array) / array.length : undefined;
          },
  
          
          sum: function(array) {
              var sum = 0,
                  i, ln, item;
  
              for (i = 0,ln = array.length; i < ln; i++) {
                  item = array[i];
  
                  sum += item;
              }
  
              return sum;
          },
  
          
          toMap: function(array, getKey, scope) {
              var map = {},
                  i = array.length;
  
              if (!getKey) {
                  while (i--) {
                      map[array[i]] = i+1;
                  }
              } else if (typeof getKey == 'string') {
                  while (i--) {
                      map[array[i][getKey]] = i+1;
                  }
              } else {
                  while (i--) {
                      map[getKey.call(scope, array[i])] = i+1;
                  }
              }
  
              return map;
          },
  
  
          
          erase: erase,
  
          
          insert: function (array, index, items) {
              return replace(array, index, 0, items);
          },
  
          
          replace: replace,
  
          
          splice: splice,
  
          
          push: function(array) {
              var len = arguments.length,
                  i = 1,
                  newItem;
  
              if (array === undefined) {
                  array = [];
              } else if (!Ext.isArray(array)) {
                  array = [array];
              }
              for (; i < len; i++) {
                  newItem = arguments[i];
                  Array.prototype.push[Ext.isArray(newItem) ? 'apply' : 'call'](array, newItem);
              }
              return array;
          }
      };
  
      
      Ext.each = ExtArray.each;
  
      
      ExtArray.union = ExtArray.merge;
  
      
      Ext.min = ExtArray.min;
  
      
      Ext.max = ExtArray.max;
  
      
      Ext.sum = ExtArray.sum;
  
      
      Ext.mean = ExtArray.mean;
  
      
      Ext.flatten = ExtArray.flatten;
  
      
      Ext.clean = ExtArray.clean;
  
      
      Ext.unique = ExtArray.unique;
  
      
      Ext.pluck = ExtArray.pluck;
  
      
      Ext.toArray = function() {
          return ExtArray.toArray.apply(ExtArray, arguments);
      };
  }());
  
  
  Ext.Function = {
  
      
      flexSetter: function(fn) {
          return function(a, b) {
              var k, i;
  
              if (a === null) {
                  return this;
              }
  
              if (typeof a !== 'string') {
                  for (k in a) {
                      if (a.hasOwnProperty(k)) {
                          fn.call(this, k, a[k]);
                      }
                  }
  
                  if (Ext.enumerables) {
                      for (i = Ext.enumerables.length; i--;) {
                          k = Ext.enumerables[i];
                          if (a.hasOwnProperty(k)) {
                              fn.call(this, k, a[k]);
                          }
                      }
                  }
              } else {
                  fn.call(this, a, b);
              }
  
              return this;
          };
      },
  
      
      bind: function(fn, scope, args, appendArgs) {
          if (arguments.length === 2) {
              return function() {
                  return fn.apply(scope, arguments);
              };
          }
  
          var method = fn,
              slice = Array.prototype.slice;
  
          return function() {
              var callArgs = args || arguments;
  
              if (appendArgs === true) {
                  callArgs = slice.call(arguments, 0);
                  callArgs = callArgs.concat(args);
              }
              else if (typeof appendArgs == 'number') {
                  callArgs = slice.call(arguments, 0); 
                  Ext.Array.insert(callArgs, appendArgs, args);
              }
  
              return method.apply(scope || Ext.global, callArgs);
          };
      },
  
      
      pass: function(fn, args, scope) {
          if (!Ext.isArray(args)) {
              if (Ext.isIterable(args)) {
                  args = Ext.Array.clone(args);
              } else {
                  args = args !== undefined ? [args] : [];
              }
          }
  
          return function() {
              var fnArgs = [].concat(args);
              fnArgs.push.apply(fnArgs, arguments);
              return fn.apply(scope || this, fnArgs);
          };
      },
  
      
      alias: function(object, methodName) {
          return function() {
              return object[methodName].apply(object, arguments);
          };
      },
  
      
      clone: function(method) {
          return function() {
              return method.apply(this, arguments);
          };
      },
  
      
      createInterceptor: function(origFn, newFn, scope, returnValue) {
          var method = origFn;
          if (!Ext.isFunction(newFn)) {
              return origFn;
          }
          else {
              return function() {
                  var me = this,
                      args = arguments;
                  newFn.target = me;
                  newFn.method = origFn;
                  return (newFn.apply(scope || me || Ext.global, args) !== false) ? origFn.apply(me || Ext.global, args) : returnValue || null;
              };
          }
      },
  
      
      createDelayed: function(fn, delay, scope, args, appendArgs) {
          if (scope || args) {
              fn = Ext.Function.bind(fn, scope, args, appendArgs);
          }
  
          return function() {
              var me = this,
                  args = Array.prototype.slice.call(arguments);
  
              setTimeout(function() {
                  fn.apply(me, args);
              }, delay);
          };
      },
  
      
      defer: function(fn, millis, scope, args, appendArgs) {
          fn = Ext.Function.bind(fn, scope, args, appendArgs);
          if (millis > 0) {
              return setTimeout(Ext.supports.TimeoutActualLateness ? function () {
                  fn();
              } : fn, millis);
          }
          fn();
          return 0;
      },
  
      
      createSequence: function(originalFn, newFn, scope) {
          if (!newFn) {
              return originalFn;
          }
          else {
              return function() {
                  var result = originalFn.apply(this, arguments);
                  newFn.apply(scope || this, arguments);
                  return result;
              };
          }
      },
  
      
      createBuffered: function(fn, buffer, scope, args) {
          var timerId;
  
          return function() {
              var callArgs = args || Array.prototype.slice.call(arguments, 0),
                  me = scope || this;
  
              if (timerId) {
                  clearTimeout(timerId);
              }
  
              timerId = setTimeout(function(){
                  fn.apply(me, callArgs);
              }, buffer);
          };
      },
  
      
      createThrottled: function(fn, interval, scope) {
          var lastCallTime, elapsed, lastArgs, timer, execute = function() {
              fn.apply(scope || this, lastArgs);
              lastCallTime = new Date().getTime();
          };
  
          return function() {
              elapsed = new Date().getTime() - lastCallTime;
              lastArgs = arguments;
  
              clearTimeout(timer);
              if (!lastCallTime || (elapsed >= interval)) {
                  execute();
              } else {
                  timer = setTimeout(execute, interval - elapsed);
              }
          };
      },
  
  
      
      interceptBefore: function(object, methodName, fn, scope) {
          var method = object[methodName] || Ext.emptyFn;
  
          return (object[methodName] = function() {
              var ret = fn.apply(scope || this, arguments);
              method.apply(this, arguments);
  
              return ret;
          });
      },
  
      
      interceptAfter: function(object, methodName, fn, scope) {
          var method = object[methodName] || Ext.emptyFn;
  
          return (object[methodName] = function() {
              method.apply(this, arguments);
              return fn.apply(scope || this, arguments);
          });
      }
  };
  
  
  Ext.defer = Ext.Function.alias(Ext.Function, 'defer');
  
  
  Ext.pass = Ext.Function.alias(Ext.Function, 'pass');
  
  
  Ext.bind = Ext.Function.alias(Ext.Function, 'bind');
  
  
  
  (function() {
  
  
  var TemplateClass = function(){},
      ExtObject = Ext.Object = {
  
      
      chain: function (object) {
          TemplateClass.prototype = object;
          var result = new TemplateClass();
          TemplateClass.prototype = null;
          return result;
      },
  
      
      toQueryObjects: function(name, value, recursive) {
          var self = ExtObject.toQueryObjects,
              objects = [],
              i, ln;
  
          if (Ext.isArray(value)) {
              for (i = 0, ln = value.length; i < ln; i++) {
                  if (recursive) {
                      objects = objects.concat(self(name + '[' + i + ']', value[i], true));
                  }
                  else {
                      objects.push({
                          name: name,
                          value: value[i]
                      });
                  }
              }
          }
          else if (Ext.isObject(value)) {
              for (i in value) {
                  if (value.hasOwnProperty(i)) {
                      if (recursive) {
                          objects = objects.concat(self(name + '[' + i + ']', value[i], true));
                      }
                      else {
                          objects.push({
                              name: name,
                              value: value[i]
                          });
                      }
                  }
              }
          }
          else {
              objects.push({
                  name: name,
                  value: value
              });
          }
  
          return objects;
      },
  
      
      toQueryString: function(object, recursive) {
          var paramObjects = [],
              params = [],
              i, j, ln, paramObject, value;
  
          for (i in object) {
              if (object.hasOwnProperty(i)) {
                  paramObjects = paramObjects.concat(ExtObject.toQueryObjects(i, object[i], recursive));
              }
          }
  
          for (j = 0, ln = paramObjects.length; j < ln; j++) {
              paramObject = paramObjects[j];
              value = paramObject.value;
  
              if (Ext.isEmpty(value)) {
                  value = '';
              }
              else if (Ext.isDate(value)) {
                  value = Ext.Date.toString(value);
              }
  
              params.push(encodeURIComponent(paramObject.name) + '=' + encodeURIComponent(String(value)));
          }
  
          return params.join('&');
      },
  
      
      fromQueryString: function(queryString, recursive) {
          var parts = queryString.replace(/^\?/, '').split('&'),
              object = {},
              temp, components, name, value, i, ln,
              part, j, subLn, matchedKeys, matchedName,
              keys, key, nextKey;
  
          for (i = 0, ln = parts.length; i < ln; i++) {
              part = parts[i];
  
              if (part.length > 0) {
                  components = part.split('=');
                  name = decodeURIComponent(components[0]);
                  value = (components[1] !== undefined) ? decodeURIComponent(components[1]) : '';
  
                  if (!recursive) {
                      if (object.hasOwnProperty(name)) {
                          if (!Ext.isArray(object[name])) {
                              object[name] = [object[name]];
                          }
  
                          object[name].push(value);
                      }
                      else {
                          object[name] = value;
                      }
                  }
                  else {
                      matchedKeys = name.match(/(\[):?([^\]]*)\]/g);
                      matchedName = name.match(/^([^\[]+)/);
  
  
                      name = matchedName[0];
                      keys = [];
  
                      if (matchedKeys === null) {
                          object[name] = value;
                          continue;
                      }
  
                      for (j = 0, subLn = matchedKeys.length; j < subLn; j++) {
                          key = matchedKeys[j];
                          key = (key.length === 2) ? '' : key.substring(1, key.length - 1);
                          keys.push(key);
                      }
  
                      keys.unshift(name);
  
                      temp = object;
  
                      for (j = 0, subLn = keys.length; j < subLn; j++) {
                          key = keys[j];
  
                          if (j === subLn - 1) {
                              if (Ext.isArray(temp) && key === '') {
                                  temp.push(value);
                              }
                              else {
                                  temp[key] = value;
                              }
                          }
                          else {
                              if (temp[key] === undefined || typeof temp[key] === 'string') {
                                  nextKey = keys[j+1];
  
                                  temp[key] = (Ext.isNumeric(nextKey) || nextKey === '') ? [] : {};
                              }
  
                              temp = temp[key];
                          }
                      }
                  }
              }
          }
  
          return object;
      },
  
      
      each: function(object, fn, scope) {
          for (var property in object) {
              if (object.hasOwnProperty(property)) {
                  if (fn.call(scope || object, property, object[property], object) === false) {
                      return;
                  }
              }
          }
      },
  
      
      merge: function(destination) {
          var i = 1,
              ln = arguments.length,
              mergeFn = ExtObject.merge,
              cloneFn = Ext.clone,
              object, key, value, sourceKey;
  
          for (; i < ln; i++) {
              object = arguments[i];
  
              for (key in object) {
                  value = object[key];
                  if (value && value.constructor === Object) {
                      sourceKey = destination[key];
                      if (sourceKey && sourceKey.constructor === Object) {
                          mergeFn(sourceKey, value);
                      }
                      else {
                          destination[key] = cloneFn(value);
                      }
                  }
                  else {
                      destination[key] = value;
                  }
              }
          }
  
          return destination;
      },
  
      
      mergeIf: function(destination) {
          var i = 1,
              ln = arguments.length,
              cloneFn = Ext.clone,
              object, key, value;
  
          for (; i < ln; i++) {
              object = arguments[i];
  
              for (key in object) {
                  if (!(key in destination)) {
                      value = object[key];
  
                      if (value && value.constructor === Object) {
                          destination[key] = cloneFn(value);
                      }
                      else {
                          destination[key] = value;
                      }
                  }
              }
          }
  
          return destination;
      },
  
      
      getKey: function(object, value) {
          for (var property in object) {
              if (object.hasOwnProperty(property) && object[property] === value) {
                  return property;
              }
          }
  
          return null;
      },
  
      
      getValues: function(object) {
          var values = [],
              property;
  
          for (property in object) {
              if (object.hasOwnProperty(property)) {
                  values.push(object[property]);
              }
          }
  
          return values;
      },
  
      
      getKeys: (typeof Object.keys == 'function')
          ? function(object){
              if (!object) {
                  return [];
              }
              return Object.keys(object);
          }
          : function(object) {
              var keys = [],
                  property;
  
              for (property in object) {
                  if (object.hasOwnProperty(property)) {
                      keys.push(property);
                  }
              }
  
              return keys;
          },
  
      
      getSize: function(object) {
          var size = 0,
              property;
  
          for (property in object) {
              if (object.hasOwnProperty(property)) {
                  size++;
              }
          }
  
          return size;
      },
  
      
      classify: function(object) {
          var prototype = object,
              objectProperties = [],
              propertyClassesMap = {},
              objectClass = function() {
                  var i = 0,
                      ln = objectProperties.length,
                      property;
  
                  for (; i < ln; i++) {
                      property = objectProperties[i];
                      this[property] = new propertyClassesMap[property]();
                  }
              },
              key, value;
  
          for (key in object) {
              if (object.hasOwnProperty(key)) {
                  value = object[key];
  
                  if (value && value.constructor === Object) {
                      objectProperties.push(key);
                      propertyClassesMap[key] = ExtObject.classify(value);
                  }
              }
          }
  
          objectClass.prototype = prototype;
  
          return objectClass;
      }
  };
  
  
  Ext.merge = Ext.Object.merge;
  
  
  Ext.mergeIf = Ext.Object.mergeIf;
  
  
  Ext.urlEncode = function() {
      var args = Ext.Array.from(arguments),
          prefix = '';
  
      
      if ((typeof args[1] === 'string')) {
          prefix = args[1] + '&';
          args[1] = false;
      }
  
      return prefix + ExtObject.toQueryString.apply(ExtObject, args);
  };
  
  
  Ext.urlDecode = function() {
      return ExtObject.fromQueryString.apply(ExtObject, arguments);
  };
  
  }());
  
  
  
  
  
  (function() {
  
  
  
  
  function xf(format) {
      var args = Array.prototype.slice.call(arguments, 1);
      return format.replace(/\{(\d+)\}/g, function(m, i) {
          return args[i];
      });
  }
  
  Ext.Date = {
      
      now: Date.now || function() {
          return +new Date();
      },
  
      
      toString: function(date) {
          var pad = Ext.String.leftPad;
  
          return date.getFullYear() + "-"
              + pad(date.getMonth() + 1, 2, '0') + "-"
              + pad(date.getDate(), 2, '0') + "T"
              + pad(date.getHours(), 2, '0') + ":"
              + pad(date.getMinutes(), 2, '0') + ":"
              + pad(date.getSeconds(), 2, '0');
      },
  
      
      getElapsed: function(dateA, dateB) {
          return Math.abs(dateA - (dateB || new Date()));
      },
  
      
      useStrict: false,
  
      
      formatCodeToRegex: function(character, currentGroup) {
          
          var p = utilDate.parseCodes[character];
  
          if (p) {
            p = typeof p == 'function'? p() : p;
            utilDate.parseCodes[character] = p; 
          }
  
          return p ? Ext.applyIf({
            c: p.c ? xf(p.c, currentGroup || "{0}") : p.c
          }, p) : {
              g: 0,
              c: null,
              s: Ext.String.escapeRegex(character) 
          };
      },
  
      
      parseFunctions: {
          "MS": function(input, strict) {
              
              
              var re = new RegExp('\\/Date\\(([-+])?(\\d+)(?:[+-]\\d{4})?\\)\\/'),
                  r = (input || '').match(re);
              return r? new Date(((r[1] || '') + r[2]) * 1) : null;
          }
      },
      parseRegexes: [],
  
      
      formatFunctions: {
          "MS": function() {
              
              return '\\/Date(' + this.getTime() + ')\\/';
          }
      },
  
      y2kYear : 50,
  
      
      MILLI : "ms",
  
      
      SECOND : "s",
  
      
      MINUTE : "mi",
  
      
      HOUR : "h",
  
      
      DAY : "d",
  
      
      MONTH : "mo",
  
      
      YEAR : "y",
  
      
      defaults: {},
  
      
      
      dayNames : [
          "Sunday",
          "Monday",
          "Tuesday",
          "Wednesday",
          "Thursday",
          "Friday",
          "Saturday"
      ],
      
  
      
      
      monthNames : [
          "January",
          "February",
          "March",
          "April",
          "May",
          "June",
          "July",
          "August",
          "September",
          "October",
          "November",
          "December"
      ],
      
  
      
      
      monthNumbers : {
          January: 0,
          Jan: 0,
          February: 1,
          Feb: 1,
          March: 2,
          Mar: 2,
          April: 3,
          Apr: 3,
          May: 4,
          June: 5,
          Jun: 5,
          July: 6,
          Jul: 6,
          August: 7,
          Aug: 7,
          September: 8,
          Sep: 8,
          October: 9,
          Oct: 9,
          November: 10,
          Nov: 10,
          December: 11,
          Dec: 11
      },
      
      
      
      
      defaultFormat : "m/d/Y",
      
      
      
      getShortMonthName : function(month) {
          return Ext.Date.monthNames[month].substring(0, 3);
      },
      
  
      
      
      getShortDayName : function(day) {
          return Ext.Date.dayNames[day].substring(0, 3);
      },
      
  
      
      
      getMonthNumber : function(name) {
          
          return Ext.Date.monthNumbers[name.substring(0, 1).toUpperCase() + name.substring(1, 3).toLowerCase()];
      },
      
  
      
      formatContainsHourInfo : (function(){
          var stripEscapeRe = /(\\.)/g,
              hourInfoRe = /([gGhHisucUOPZ]|MS)/;
          return function(format){
              return hourInfoRe.test(format.replace(stripEscapeRe, ''));
          };
      }()),
  
      
      formatContainsDateInfo : (function(){
          var stripEscapeRe = /(\\.)/g,
              dateInfoRe = /([djzmnYycU]|MS)/;
  
          return function(format){
              return dateInfoRe.test(format.replace(stripEscapeRe, ''));
          };
      }()),
      
      
      unescapeFormat: (function() { 
          var slashRe = /\\/gi;
          return function(format) {
              
              
              
              return format.replace(slashRe, '');
          }
      }()),
  
      
      formatCodes : {
          d: "Ext.String.leftPad(this.getDate(), 2, '0')",
          D: "Ext.Date.getShortDayName(this.getDay())", 
          j: "this.getDate()",
          l: "Ext.Date.dayNames[this.getDay()]",
          N: "(this.getDay() ? this.getDay() : 7)",
          S: "Ext.Date.getSuffix(this)",
          w: "this.getDay()",
          z: "Ext.Date.getDayOfYear(this)",
          W: "Ext.String.leftPad(Ext.Date.getWeekOfYear(this), 2, '0')",
          F: "Ext.Date.monthNames[this.getMonth()]",
          m: "Ext.String.leftPad(this.getMonth() + 1, 2, '0')",
          M: "Ext.Date.getShortMonthName(this.getMonth())", 
          n: "(this.getMonth() + 1)",
          t: "Ext.Date.getDaysInMonth(this)",
          L: "(Ext.Date.isLeapYear(this) ? 1 : 0)",
          o: "(this.getFullYear() + (Ext.Date.getWeekOfYear(this) == 1 && this.getMonth() > 0 ? +1 : (Ext.Date.getWeekOfYear(this) >= 52 && this.getMonth() < 11 ? -1 : 0)))",
          Y: "Ext.String.leftPad(this.getFullYear(), 4, '0')",
          y: "('' + this.getFullYear()).substring(2, 4)",
          a: "(this.getHours() < 12 ? 'am' : 'pm')",
          A: "(this.getHours() < 12 ? 'AM' : 'PM')",
          g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
          G: "this.getHours()",
          h: "Ext.String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
          H: "Ext.String.leftPad(this.getHours(), 2, '0')",
          i: "Ext.String.leftPad(this.getMinutes(), 2, '0')",
          s: "Ext.String.leftPad(this.getSeconds(), 2, '0')",
          u: "Ext.String.leftPad(this.getMilliseconds(), 3, '0')",
          O: "Ext.Date.getGMTOffset(this)",
          P: "Ext.Date.getGMTOffset(this, true)",
          T: "Ext.Date.getTimezone(this)",
          Z: "(this.getTimezoneOffset() * -60)",
  
          c: function() { 
              var c, code, i, l, e;
              for (c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
                  e = c.charAt(i);
                  code.push(e == "T" ? "'T'" : utilDate.getFormatCode(e)); 
              }
              return code.join(" + ");
          },
          
  
          U: "Math.round(this.getTime() / 1000)"
      },
  
      
      isValid : function(y, m, d, h, i, s, ms) {
          
          h = h || 0;
          i = i || 0;
          s = s || 0;
          ms = ms || 0;
  
          
          var dt = utilDate.add(new Date(y < 100 ? 100 : y, m - 1, d, h, i, s, ms), utilDate.YEAR, y < 100 ? y - 100 : 0);
  
          return y == dt.getFullYear() &&
              m == dt.getMonth() + 1 &&
              d == dt.getDate() &&
              h == dt.getHours() &&
              i == dt.getMinutes() &&
              s == dt.getSeconds() &&
              ms == dt.getMilliseconds();
      },
  
      
      parse : function(input, format, strict) {
          var p = utilDate.parseFunctions;
          if (p[format] == null) {
              utilDate.createParser(format);
          }
          return p[format](input, Ext.isDefined(strict) ? strict : utilDate.useStrict);
      },
  
      
      parseDate: function(input, format, strict){
          return utilDate.parse(input, format, strict);
      },
  
  
      
      getFormatCode : function(character) {
          var f = utilDate.formatCodes[character];
  
          if (f) {
            f = typeof f == 'function'? f() : f;
            utilDate.formatCodes[character] = f; 
          }
  
          
          return f || ("'" + Ext.String.escape(character) + "'");
      },
  
      
      createFormat : function(format) {
          var code = [],
              special = false,
              ch = '',
              i;
  
          for (i = 0; i < format.length; ++i) {
              ch = format.charAt(i);
              if (!special && ch == "\\") {
                  special = true;
              } else if (special) {
                  special = false;
                  code.push("'" + Ext.String.escape(ch) + "'");
              } else {
                  code.push(utilDate.getFormatCode(ch));
              }
          }
          utilDate.formatFunctions[format] = Ext.functionFactory("return " + code.join('+'));
      },
  
      
      createParser : (function() {
          var code = [
              "var dt, y, m, d, h, i, s, ms, o, z, zz, u, v,",
                  "def = Ext.Date.defaults,",
                  "results = String(input).match(Ext.Date.parseRegexes[{0}]);", 
  
              "if(results){",
                  "{1}",
  
                  "if(u != null){", 
                      "v = new Date(u * 1000);", 
                  "}else{",
                      
                      
                      
                      "dt = Ext.Date.clearTime(new Date);",
  
                      
                      "y = Ext.Number.from(y, Ext.Number.from(def.y, dt.getFullYear()));",
                      "m = Ext.Number.from(m, Ext.Number.from(def.m - 1, dt.getMonth()));",
                      "d = Ext.Number.from(d, Ext.Number.from(def.d, dt.getDate()));",
  
                      
                      "h  = Ext.Number.from(h, Ext.Number.from(def.h, dt.getHours()));",
                      "i  = Ext.Number.from(i, Ext.Number.from(def.i, dt.getMinutes()));",
                      "s  = Ext.Number.from(s, Ext.Number.from(def.s, dt.getSeconds()));",
                      "ms = Ext.Number.from(ms, Ext.Number.from(def.ms, dt.getMilliseconds()));",
  
                      "if(z >= 0 && y >= 0){",
                          
                          
  
                          
                          
                          "v = Ext.Date.add(new Date(y < 100 ? 100 : y, 0, 1, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
  
                          
                          "v = !strict? v : (strict === true && (z <= 364 || (Ext.Date.isLeapYear(v) && z <= 365))? Ext.Date.add(v, Ext.Date.DAY, z) : null);",
                      "}else if(strict === true && !Ext.Date.isValid(y, m + 1, d, h, i, s, ms)){", 
                          "v = null;", 
                      "}else{",
                          
                          
                          "v = Ext.Date.add(new Date(y < 100 ? 100 : y, m, d, h, i, s, ms), Ext.Date.YEAR, y < 100 ? y - 100 : 0);",
                      "}",
                  "}",
              "}",
  
              "if(v){",
                  
                  "if(zz != null){",
                      
                      "v = Ext.Date.add(v, Ext.Date.SECOND, -v.getTimezoneOffset() * 60 - zz);",
                  "}else if(o){",
                      
                      "v = Ext.Date.add(v, Ext.Date.MINUTE, -v.getTimezoneOffset() + (sn == '+'? -1 : 1) * (hr * 60 + mn));",
                  "}",
              "}",
  
              "return v;"
          ].join('\n');
  
          return function(format) {
              var regexNum = utilDate.parseRegexes.length,
                  currentGroup = 1,
                  calc = [],
                  regex = [],
                  special = false,
                  ch = "",
                  i = 0,
                  len = format.length,
                  atEnd = [],
                  obj;
  
              for (; i < len; ++i) {
                  ch = format.charAt(i);
                  if (!special && ch == "\\") {
                      special = true;
                  } else if (special) {
                      special = false;
                      regex.push(Ext.String.escape(ch));
                  } else {
                      obj = utilDate.formatCodeToRegex(ch, currentGroup);
                      currentGroup += obj.g;
                      regex.push(obj.s);
                      if (obj.g && obj.c) {
                          if (obj.calcAtEnd) {
                              atEnd.push(obj.c);
                          } else {
                              calc.push(obj.c);
                          }
                      }
                  }
              }
              
              calc = calc.concat(atEnd);
  
              utilDate.parseRegexes[regexNum] = new RegExp("^" + regex.join('') + "$", 'i');
              utilDate.parseFunctions[format] = Ext.functionFactory("input", "strict", xf(code, regexNum, calc.join('')));
          };
      }()),
  
      
      parseCodes : {
          
          d: {
              g:1,
              c:"d = parseInt(results[{0}], 10);\n",
              s:"(3[0-1]|[1-2][0-9]|0[1-9])" 
          },
          j: {
              g:1,
              c:"d = parseInt(results[{0}], 10);\n",
              s:"(3[0-1]|[1-2][0-9]|[1-9])" 
          },
          D: function() {
              for (var a = [], i = 0; i < 7; a.push(utilDate.getShortDayName(i)), ++i); 
              return {
                  g:0,
                  c:null,
                  s:"(?:" + a.join("|") +")"
              };
          },
          l: function() {
              return {
                  g:0,
                  c:null,
                  s:"(?:" + utilDate.dayNames.join("|") + ")"
              };
          },
          N: {
              g:0,
              c:null,
              s:"[1-7]" 
          },
          
          S: {
              g:0,
              c:null,
              s:"(?:st|nd|rd|th)"
          },
          
          w: {
              g:0,
              c:null,
              s:"[0-6]" 
          },
          z: {
              g:1,
              c:"z = parseInt(results[{0}], 10);\n",
              s:"(\\d{1,3})" 
          },
          W: {
              g:0,
              c:null,
              s:"(?:\\d{2})" 
          },
          F: function() {
              return {
                  g:1,
                  c:"m = parseInt(Ext.Date.getMonthNumber(results[{0}]), 10);\n", 
                  s:"(" + utilDate.monthNames.join("|") + ")"
              };
          },
          M: function() {
              for (var a = [], i = 0; i < 12; a.push(utilDate.getShortMonthName(i)), ++i); 
              return Ext.applyIf({
                  s:"(" + a.join("|") + ")"
              }, utilDate.formatCodeToRegex("F"));
          },
          m: {
              g:1,
              c:"m = parseInt(results[{0}], 10) - 1;\n",
              s:"(1[0-2]|0[1-9])" 
          },
          n: {
              g:1,
              c:"m = parseInt(results[{0}], 10) - 1;\n",
              s:"(1[0-2]|[1-9])" 
          },
          t: {
              g:0,
              c:null,
              s:"(?:\\d{2})" 
          },
          L: {
              g:0,
              c:null,
              s:"(?:1|0)"
          },
          o: function() {
              return utilDate.formatCodeToRegex("Y");
          },
          Y: {
              g:1,
              c:"y = parseInt(results[{0}], 10);\n",
              s:"(\\d{4})" 
          },
          y: {
              g:1,
              c:"var ty = parseInt(results[{0}], 10);\n"
                  + "y = ty > Ext.Date.y2kYear ? 1900 + ty : 2000 + ty;\n", 
              s:"(\\d{1,2})"
          },
          
          
          a: {
              g:1,
              c:"if (/(am)/i.test(results[{0}])) {\n"
                  + "if (!h || h == 12) { h = 0; }\n"
                  + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
              s:"(am|pm|AM|PM)",
              calcAtEnd: true
          },
          
          
          A: {
              g:1,
              c:"if (/(am)/i.test(results[{0}])) {\n"
                  + "if (!h || h == 12) { h = 0; }\n"
                  + "} else { if (!h || h < 12) { h = (h || 0) + 12; }}",
              s:"(AM|PM|am|pm)",
              calcAtEnd: true
          },
          
          g: {
              g:1,
              c:"h = parseInt(results[{0}], 10);\n",
              s:"(1[0-2]|[0-9])" 
          },
          G: {
              g:1,
              c:"h = parseInt(results[{0}], 10);\n",
              s:"(2[0-3]|1[0-9]|[0-9])" 
          },
          h: {
              g:1,
              c:"h = parseInt(results[{0}], 10);\n",
              s:"(1[0-2]|0[1-9])" 
          },
          H: {
              g:1,
              c:"h = parseInt(results[{0}], 10);\n",
              s:"(2[0-3]|[0-1][0-9])" 
          },
          i: {
              g:1,
              c:"i = parseInt(results[{0}], 10);\n",
              s:"([0-5][0-9])" 
          },
          s: {
              g:1,
              c:"s = parseInt(results[{0}], 10);\n",
              s:"([0-5][0-9])" 
          },
          u: {
              g:1,
              c:"ms = results[{0}]; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n",
              s:"(\\d+)" 
          },
          O: {
              g:1,
              c:[
                  "o = results[{0}];",
                  "var sn = o.substring(0,1),", 
                      "hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60),", 
                      "mn = o.substring(3,5) % 60;", 
                  "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" 
              ].join("\n"),
              s: "([+-]\\d{4})" 
          },
          P: {
              g:1,
              c:[
                  "o = results[{0}];",
                  "var sn = o.substring(0,1),", 
                      "hr = o.substring(1,3)*1 + Math.floor(o.substring(4,6) / 60),", 
                      "mn = o.substring(4,6) % 60;", 
                  "o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))? (sn + Ext.String.leftPad(hr, 2, '0') + Ext.String.leftPad(mn, 2, '0')) : null;\n" 
              ].join("\n"),
              s: "([+-]\\d{2}:\\d{2})" 
          },
          T: {
              g:0,
              c:null,
              s:"[A-Z]{1,4}" 
          },
          Z: {
              g:1,
              c:"zz = results[{0}] * 1;\n" 
                    + "zz = (-43200 <= zz && zz <= 50400)? zz : null;\n",
              s:"([+-]?\\d{1,5})" 
          },
          c: function() {
              var calc = [],
                  arr = [
                      utilDate.formatCodeToRegex("Y", 1), 
                      utilDate.formatCodeToRegex("m", 2), 
                      utilDate.formatCodeToRegex("d", 3), 
                      utilDate.formatCodeToRegex("H", 4), 
                      utilDate.formatCodeToRegex("i", 5), 
                      utilDate.formatCodeToRegex("s", 6), 
                      {c:"ms = results[7] || '0'; ms = parseInt(ms, 10)/Math.pow(10, ms.length - 3);\n"}, 
                      {c:[ 
                          "if(results[8]) {", 
                              "if(results[8] == 'Z'){",
                                  "zz = 0;", 
                              "}else if (results[8].indexOf(':') > -1){",
                                  utilDate.formatCodeToRegex("P", 8).c, 
                              "}else{",
                                  utilDate.formatCodeToRegex("O", 8).c, 
                              "}",
                          "}"
                      ].join('\n')}
                  ],
                  i,
                  l;
  
              for (i = 0, l = arr.length; i < l; ++i) {
                  calc.push(arr[i].c);
              }
  
              return {
                  g:1,
                  c:calc.join(""),
                  s:[
                      arr[0].s, 
                      "(?:", "-", arr[1].s, 
                          "(?:", "-", arr[2].s, 
                              "(?:",
                                  "(?:T| )?", 
                                  arr[3].s, ":", arr[4].s,  
                                  "(?::", arr[5].s, ")?", 
                                  "(?:(?:\\.|,)(\\d+))?", 
                                  "(Z|(?:[-+]\\d{2}(?::)?\\d{2}))?", 
                              ")?",
                          ")?",
                      ")?"
                  ].join("")
              };
          },
          U: {
              g:1,
              c:"u = parseInt(results[{0}], 10);\n",
              s:"(-?\\d+)" 
          }
      },
  
      
      
      dateFormat: function(date, format) {
          return utilDate.format(date, format);
      },
  
      
      isEqual: function(date1, date2) {
          
          if (date1 && date2) {
              return (date1.getTime() === date2.getTime());
          }
          
          return !(date1 || date2);
      },
  
      
      format: function(date, format) {
          var formatFunctions = utilDate.formatFunctions;
  
          if (!Ext.isDate(date)) {
              return '';
          }
  
          if (formatFunctions[format] == null) {
              utilDate.createFormat(format);
          }
  
          return formatFunctions[format].call(date) + '';
      },
  
      
      getTimezone : function(date) {
          
          
          
          
          
          
          
          
          
          
          
          
          return date.toString().replace(/^.* (?:\((.*)\)|([A-Z]{1,4})(?:[\-+][0-9]{4})?(?: -?\d+)?)$/, "$1$2").replace(/[^A-Z]/g, "");
      },
  
      
      getGMTOffset : function(date, colon) {
          var offset = date.getTimezoneOffset();
          return (offset > 0 ? "-" : "+")
              + Ext.String.leftPad(Math.floor(Math.abs(offset) / 60), 2, "0")
              + (colon ? ":" : "")
              + Ext.String.leftPad(Math.abs(offset % 60), 2, "0");
      },
  
      
      getDayOfYear: function(date) {
          var num = 0,
              d = Ext.Date.clone(date),
              m = date.getMonth(),
              i;
  
          for (i = 0, d.setDate(1), d.setMonth(0); i < m; d.setMonth(++i)) {
              num += utilDate.getDaysInMonth(d);
          }
          return num + date.getDate() - 1;
      },
  
      
      getWeekOfYear : (function() {
          
          var ms1d = 864e5, 
              ms7d = 7 * ms1d; 
  
          return function(date) { 
              var DC3 = Date.UTC(date.getFullYear(), date.getMonth(), date.getDate() + 3) / ms1d, 
                  AWN = Math.floor(DC3 / 7), 
                  Wyr = new Date(AWN * ms7d).getUTCFullYear();
  
              return AWN - Math.floor(Date.UTC(Wyr, 0, 7) / ms7d) + 1;
          };
      }()),
  
      
      isLeapYear : function(date) {
          var year = date.getFullYear();
          return !!((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
      },
  
      
      getFirstDayOfMonth : function(date) {
          var day = (date.getDay() - (date.getDate() - 1)) % 7;
          return (day < 0) ? (day + 7) : day;
      },
  
      
      getLastDayOfMonth : function(date) {
          return utilDate.getLastDateOfMonth(date).getDay();
      },
  
  
      
      getFirstDateOfMonth : function(date) {
          return new Date(date.getFullYear(), date.getMonth(), 1);
      },
  
      
      getLastDateOfMonth : function(date) {
          return new Date(date.getFullYear(), date.getMonth(), utilDate.getDaysInMonth(date));
      },
  
      
      getDaysInMonth: (function() {
          var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
  
          return function(date) { 
              var m = date.getMonth();
  
              return m == 1 && utilDate.isLeapYear(date) ? 29 : daysInMonth[m];
          };
      }()),
  
      
      
      getSuffix : function(date) {
          switch (date.getDate()) {
              case 1:
              case 21:
              case 31:
                  return "st";
              case 2:
              case 22:
                  return "nd";
              case 3:
              case 23:
                  return "rd";
              default:
                  return "th";
          }
      },
      
  
      
      clone : function(date) {
          return new Date(date.getTime());
      },
  
      
      isDST : function(date) {
          
          
          return new Date(date.getFullYear(), 0, 1).getTimezoneOffset() != date.getTimezoneOffset();
      },
  
      
      clearTime : function(date, clone) {
          if (clone) {
              return Ext.Date.clearTime(Ext.Date.clone(date));
          }
  
          
          var d = date.getDate(),
              hr,
              c;
  
          
          date.setHours(0);
          date.setMinutes(0);
          date.setSeconds(0);
          date.setMilliseconds(0);
  
          if (date.getDate() != d) { 
              
              
  
              
              for (hr = 1, c = utilDate.add(date, Ext.Date.HOUR, hr); c.getDate() != d; hr++, c = utilDate.add(date, Ext.Date.HOUR, hr));
  
              date.setDate(d);
              date.setHours(c.getHours());
          }
  
          return date;
      },
  
      
      add : function(date, interval, value) {
          var d = Ext.Date.clone(date),
              Date = Ext.Date,
              day;
          if (!interval || value === 0) {
              return d;
          }
  
          switch(interval.toLowerCase()) {
              case Ext.Date.MILLI:
                  d.setMilliseconds(d.getMilliseconds() + value);
                  break;
              case Ext.Date.SECOND:
                  d.setSeconds(d.getSeconds() + value);
                  break;
              case Ext.Date.MINUTE:
                  d.setMinutes(d.getMinutes() + value);
                  break;
              case Ext.Date.HOUR:
                  d.setHours(d.getHours() + value);
                  break;
              case Ext.Date.DAY:
                  d.setDate(d.getDate() + value);
                  break;
              case Ext.Date.MONTH:
                  day = date.getDate();
                  if (day > 28) {
                      day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), Ext.Date.MONTH, value)).getDate());
                  }
                  d.setDate(day);
                  d.setMonth(date.getMonth() + value);
                  break;
              case Ext.Date.YEAR:
                  day = date.getDate();
                  if (day > 28) {
                      day = Math.min(day, Ext.Date.getLastDateOfMonth(Ext.Date.add(Ext.Date.getFirstDateOfMonth(date), Ext.Date.YEAR, value)).getDate());
                  }
                  d.setDate(day);
                  d.setFullYear(date.getFullYear() + value);
                  break;
          }
          return d;
      },
  
      
      between : function(date, start, end) {
          var t = date.getTime();
          return start.getTime() <= t && t <= end.getTime();
      },
  
      
      compat: function() {
          var nativeDate = window.Date,
              p, u,
              statics = ['useStrict', 'formatCodeToRegex', 'parseFunctions', 'parseRegexes', 'formatFunctions', 'y2kYear', 'MILLI', 'SECOND', 'MINUTE', 'HOUR', 'DAY', 'MONTH', 'YEAR', 'defaults', 'dayNames', 'monthNames', 'monthNumbers', 'getShortMonthName', 'getShortDayName', 'getMonthNumber', 'formatCodes', 'isValid', 'parseDate', 'getFormatCode', 'createFormat', 'createParser', 'parseCodes'],
              proto = ['dateFormat', 'format', 'getTimezone', 'getGMTOffset', 'getDayOfYear', 'getWeekOfYear', 'isLeapYear', 'getFirstDayOfMonth', 'getLastDayOfMonth', 'getDaysInMonth', 'getSuffix', 'clone', 'isDST', 'clearTime', 'add', 'between'],
              sLen    = statics.length,
              pLen    = proto.length,
              stat, prot, s;
  
          
          for (s = 0; s < sLen; s++) {
              stat = statics[s];
              nativeDate[stat] = utilDate[stat];
          }
  
          
          for (p = 0; p < pLen; p++) {
              prot = proto[p];
              nativeDate.prototype[prot] = function() {
                  var args = Array.prototype.slice.call(arguments);
                  args.unshift(this);
                  return utilDate[prot].apply(utilDate, args);
              };
          }
      }
  };
  
  var utilDate = Ext.Date;
  
  }());
  
  
  (function(flexSetter) {
  
  var noArgs = [],
      Base = function(){};
  
      
      Ext.apply(Base, {
          $className: 'Ext.Base',
  
          $isClass: true,
  
          
          create: function() {
              return Ext.create.apply(Ext, [this].concat(Array.prototype.slice.call(arguments, 0)));
          },
  
          
          extend: function(parent) {
              var parentPrototype = parent.prototype,
                  basePrototype, prototype, i, ln, name, statics;
  
              prototype = this.prototype = Ext.Object.chain(parentPrototype);
              prototype.self = this;
  
              this.superclass = prototype.superclass = parentPrototype;
  
              if (!parent.$isClass) {
                  basePrototype = Ext.Base.prototype;
  
                  for (i in basePrototype) {
                      if (i in prototype) {
                          prototype[i] = basePrototype[i];
                      }
                  }
              }
  
              
              statics = parentPrototype.$inheritableStatics;
  
              if (statics) {
                  for (i = 0,ln = statics.length; i < ln; i++) {
                      name = statics[i];
  
                      if (!this.hasOwnProperty(name)) {
                          this[name] = parent[name];
                      }
                  }
              }
  
              if (parent.$onExtended) {
                  this.$onExtended = parent.$onExtended.slice();
              }
  
              prototype.config = new prototype.configClass();
              prototype.initConfigList = prototype.initConfigList.slice();
              prototype.initConfigMap = Ext.clone(prototype.initConfigMap);
              prototype.configMap = Ext.Object.chain(prototype.configMap);
          },
  
          
          $onExtended: [],
  
          
          triggerExtended: function() {
              var callbacks = this.$onExtended,
                  ln = callbacks.length,
                  i, callback;
  
              if (ln > 0) {
                  for (i = 0; i < ln; i++) {
                      callback = callbacks[i];
                      callback.fn.apply(callback.scope || this, arguments);
                  }
              }
          },
  
          
          onExtended: function(fn, scope) {
              this.$onExtended.push({
                  fn: fn,
                  scope: scope
              });
  
              return this;
          },
  
          
          addConfig: function(config, fullMerge) {
              var prototype = this.prototype,
                  configNameCache = Ext.Class.configNameCache,
                  hasConfig = prototype.configMap,
                  initConfigList = prototype.initConfigList,
                  initConfigMap = prototype.initConfigMap,
                  defaultConfig = prototype.config,
                  initializedName, name, value;
  
              for (name in config) {
                  if (config.hasOwnProperty(name)) {
                      if (!hasConfig[name]) {
                          hasConfig[name] = true;
                      }
  
                      value = config[name];
  
                      initializedName = configNameCache[name].initialized;
  
                      if (!initConfigMap[name] && value !== null && !prototype[initializedName]) {
                          initConfigMap[name] = true;
                          initConfigList.push(name);
                      }
                  }
              }
  
              if (fullMerge) {
                  Ext.merge(defaultConfig, config);
              }
              else {
                  Ext.mergeIf(defaultConfig, config);
              }
  
              prototype.configClass = Ext.Object.classify(defaultConfig);
          },
  
          
          addStatics: function(members) {
              var member, name;
  
              for (name in members) {
                  if (members.hasOwnProperty(name)) {
                      member = members[name];
                      this[name] = member;
                  }
              }
  
              return this;
          },
  
          
          addInheritableStatics: function(members) {
              var inheritableStatics,
                  hasInheritableStatics,
                  prototype = this.prototype,
                  name, member;
  
              inheritableStatics = prototype.$inheritableStatics;
              hasInheritableStatics = prototype.$hasInheritableStatics;
  
              if (!inheritableStatics) {
                  inheritableStatics = prototype.$inheritableStatics = [];
                  hasInheritableStatics = prototype.$hasInheritableStatics = {};
              }
  
              for (name in members) {
                  if (members.hasOwnProperty(name)) {
                      member = members[name];
                      this[name] = member;
  
                      if (!hasInheritableStatics[name]) {
                          hasInheritableStatics[name] = true;
                          inheritableStatics.push(name);
                      }
                  }
              }
  
              return this;
          },
  
          
          addMembers: function(members) {
              var prototype = this.prototype,
                  enumerables = Ext.enumerables,
                  names = [],
                  i, ln, name, member;
  
              for (name in members) {
                  names.push(name);
              }
  
              if (enumerables) {
                  names.push.apply(names, enumerables);
              }
  
              for (i = 0,ln = names.length; i < ln; i++) {
                  name = names[i];
  
                  if (members.hasOwnProperty(name)) {
                      member = members[name];
  
                      if (typeof member == 'function' && !member.$isClass && member !== Ext.emptyFn) {
                          member.$owner = this;
                          member.$name = name;
                      }
  
                      prototype[name] = member;
                  }
              }
  
              return this;
          },
  
          
          addMember: function(name, member) {
              if (typeof member == 'function' && !member.$isClass && member !== Ext.emptyFn) {
                  member.$owner = this;
                  member.$name = name;
              }
  
              this.prototype[name] = member;
  
              return this;
          },
  
          
          implement: function() {
              this.addMembers.apply(this, arguments);
          },
  
          
          borrow: function(fromClass, members) {
              var prototype = this.prototype,
                  fromPrototype = fromClass.prototype,
                  i, ln, name, fn, toBorrow;
  
              members = Ext.Array.from(members);
  
              for (i = 0,ln = members.length; i < ln; i++) {
                  name = members[i];
  
                  toBorrow = fromPrototype[name];
  
                  if (typeof toBorrow == 'function') {
                      fn = Ext.Function.clone(toBorrow);
  
  
                      fn.$owner = this;
                      fn.$name = name;
  
                      prototype[name] = fn;
                  }
                  else {
                      prototype[name] = toBorrow;
                  }
              }
  
              return this;
          },
  
          
          override: function(members) {
              var me = this,
                  enumerables = Ext.enumerables,
                  target = me.prototype,
                  cloneFunction = Ext.Function.clone,
                  name, index, member, statics, names, previous;
  
              if (arguments.length === 2) {
                  name = members;
                  members = {};
                  members[name] = arguments[1];
                  enumerables = null;
              }
  
              do {
                  names = []; 
                  statics = null; 
  
                  for (name in members) { 
                      if (name == 'statics') {
                          statics = members[name];
                      } else if (name == 'config') {
                          me.addConfig(members[name], true);
                      } else {
                          names.push(name);
                      }
                  }
  
                  if (enumerables) {
                      names.push.apply(names, enumerables);
                  }
  
                  for (index = names.length; index--; ) {
                      name = names[index];
  
                      if (members.hasOwnProperty(name)) {
                          member = members[name];
  
                          if (typeof member == 'function' && !member.$className && member !== Ext.emptyFn) {
                              if (typeof member.$owner != 'undefined') {
                                  member = cloneFunction(member);
                              }
  
  
                              member.$owner = me;
                              member.$name = name;
  
                              previous = target[name];
                              if (previous) {
                                  member.$previous = previous;
                              }
                          }
  
                          target[name] = member;
                      }
                  }
  
                  target = me; 
                  members = statics; 
              } while (members);
  
              return this;
          },
  
          
          callParent: function(args) {
              var method;
  
              
              return (method = this.callParent.caller) && (method.$previous ||
                    ((method = method.$owner ? method : method.caller) &&
                          method.$owner.superclass.$class[method.$name])).apply(this, args || noArgs);
          },
  
          
          mixin: function(name, mixinClass) {
              var mixin = mixinClass.prototype,
                  prototype = this.prototype,
                  key;
  
              if (typeof mixin.onClassMixedIn != 'undefined') {
                  mixin.onClassMixedIn.call(mixinClass, this);
              }
  
              if (!prototype.hasOwnProperty('mixins')) {
                  if ('mixins' in prototype) {
                      prototype.mixins = Ext.Object.chain(prototype.mixins);
                  }
                  else {
                      prototype.mixins = {};
                  }
              }
  
              for (key in mixin) {
                  if (key === 'mixins') {
                      Ext.merge(prototype.mixins, mixin[key]);
                  }
                  else if (typeof prototype[key] == 'undefined' && key != 'mixinId' && key != 'config') {
                      prototype[key] = mixin[key];
                  }
              }
  
              if ('config' in mixin) {
                  this.addConfig(mixin.config, false);
              }
  
              prototype.mixins[name] = mixin;
          },
  
          
          getName: function() {
              return Ext.getClassName(this);
          },
  
          
          createAlias: flexSetter(function(alias, origin) {
              this.override(alias, function() {
                  return this[origin].apply(this, arguments);
              });
          }),
  
          
          addXtype: function(xtype) {
              var prototype = this.prototype,
                  xtypesMap = prototype.xtypesMap,
                  xtypes = prototype.xtypes,
                  xtypesChain = prototype.xtypesChain;
  
              if (!prototype.hasOwnProperty('xtypesMap')) {
                  xtypesMap = prototype.xtypesMap = Ext.merge({}, prototype.xtypesMap || {});
                  xtypes = prototype.xtypes = prototype.xtypes ? [].concat(prototype.xtypes) : [];
                  xtypesChain = prototype.xtypesChain = prototype.xtypesChain ? [].concat(prototype.xtypesChain) : [];
                  prototype.xtype = xtype;
              }
  
              if (!xtypesMap[xtype]) {
                  xtypesMap[xtype] = true;
                  xtypes.push(xtype);
                  xtypesChain.push(xtype);
                  Ext.ClassManager.setAlias(this, 'widget.' + xtype);
              }
  
              return this;
          }
      });
  
      Base.implement({
          
          isInstance: true,
  
          
          $className: 'Ext.Base',
  
          
          configClass: Ext.emptyFn,
  
          
          initConfigList: [],
  
          
          configMap: {},
  
          
          initConfigMap: {},
  
          
          statics: function() {
              var method = this.statics.caller,
                  self = this.self;
  
              if (!method) {
                  return self;
              }
  
              return method.$owner;
          },
  
          
          callParent: function(args) {
              
              
              
              
              var method,
                  superMethod = (method = this.callParent.caller) && (method.$previous ||
                          ((method = method.$owner ? method : method.caller) &&
                                  method.$owner.superclass[method.$name]));
  
  
              return superMethod.apply(this, args || noArgs);
          },
  
          
          self: Base,
  
          
          constructor: function() {
              return this;
          },
  
          
          initConfig: function(config) {
              var instanceConfig = config,
                  configNameCache = Ext.Class.configNameCache,
                  defaultConfig = new this.configClass(),
                  defaultConfigList = this.initConfigList,
                  hasConfig = this.configMap,
                  nameMap, i, ln, name, initializedName;
  
              this.initConfig = Ext.emptyFn;
  
              this.initialConfig = instanceConfig || {};
  
              this.config = config = (instanceConfig) ? Ext.merge(defaultConfig, config) : defaultConfig;
  
              if (instanceConfig) {
                  defaultConfigList = defaultConfigList.slice();
  
                  for (name in instanceConfig) {
                      if (hasConfig[name]) {
                          if (instanceConfig[name] !== null) {
                              defaultConfigList.push(name);
                              this[configNameCache[name].initialized] = false;
                          }
                      }
                  }
              }
  
              for (i = 0,ln = defaultConfigList.length; i < ln; i++) {
                  name = defaultConfigList[i];
                  nameMap = configNameCache[name];
                  initializedName = nameMap.initialized;
  
                  if (!this[initializedName]) {
                      this[initializedName] = true;
                      this[nameMap.set].call(this, config[name]);
                  }
              }
  
              return this;
          },
  
          
          hasConfig: function(name) {
              return Boolean(this.configMap[name]);
          },
  
          
          setConfig: function(config, applyIfNotSet) {
              if (!config) {
                  return this;
              }
  
              var configNameCache = Ext.Class.configNameCache,
                  currentConfig = this.config,
                  hasConfig = this.configMap,
                  initialConfig = this.initialConfig,
                  name, value;
  
              applyIfNotSet = Boolean(applyIfNotSet);
  
              for (name in config) {
                  if (applyIfNotSet && initialConfig.hasOwnProperty(name)) {
                      continue;
                  }
  
                  value = config[name];
                  currentConfig[name] = value;
  
                  if (hasConfig[name]) {
                      this[configNameCache[name].set](value);
                  }
              }
  
              return this;
          },
  
          
          getConfig: function(name) {
              var configNameCache = Ext.Class.configNameCache;
  
              return this[configNameCache[name].get]();
          },
  
          
          getInitialConfig: function(name) {
              var config = this.config;
  
              if (!name) {
                  return config;
              }
              else {
                  return config[name];
              }
          },
  
          
          onConfigUpdate: function(names, callback, scope) {
              var self = this.self,
                  i, ln, name,
                  updaterName, updater, newUpdater;
  
              names = Ext.Array.from(names);
  
              scope = scope || this;
  
              for (i = 0,ln = names.length; i < ln; i++) {
                  name = names[i];
                  updaterName = 'update' + Ext.String.capitalize(name);
                  updater = this[updaterName] || Ext.emptyFn;
                  newUpdater = function() {
                      updater.apply(this, arguments);
                      scope[callback].apply(scope, arguments);
                  };
                  newUpdater.$name = updaterName;
                  newUpdater.$owner = self;
  
                  this[updaterName] = newUpdater;
              }
          },
  
          
          destroy: function() {
              this.destroy = Ext.emptyFn;
          }
      });
  
      
      Base.prototype.callOverridden = Base.prototype.callParent;
  
      Ext.Base = Base;
  
  }(Ext.Function.flexSetter));
  
  
  (function() {
      var ExtClass,
          Base = Ext.Base,
          baseStaticMembers = [],
          baseStaticMember, baseStaticMemberLength;
  
      for (baseStaticMember in Base) {
          if (Base.hasOwnProperty(baseStaticMember)) {
              baseStaticMembers.push(baseStaticMember);
          }
      }
  
      baseStaticMemberLength = baseStaticMembers.length;
  
      
      function makeCtor (className) {
          function constructor () {
              
              
              return this.constructor.apply(this, arguments) || null;
          }
          return constructor;
      }
  
      
      Ext.Class = ExtClass = function(Class, data, onCreated) {
          if (typeof Class != 'function') {
              onCreated = data;
              data = Class;
              Class = null;
          }
  
          if (!data) {
              data = {};
          }
  
          Class = ExtClass.create(Class, data);
  
          ExtClass.process(Class, data, onCreated);
  
          return Class;
      };
  
      Ext.apply(ExtClass, {
          
          onBeforeCreated: function(Class, data, hooks) {
              Class.addMembers(data);
  
              hooks.onCreated.call(Class, Class);
          },
  
          
          create: function(Class, data) {
              var name, i;
  
              if (!Class) {
                  Class = makeCtor(
                  );
              }
  
              for (i = 0; i < baseStaticMemberLength; i++) {
                  name = baseStaticMembers[i];
                  Class[name] = Base[name];
              }
  
              return Class;
          },
  
          
          process: function(Class, data, onCreated) {
              var preprocessorStack = data.preprocessors || ExtClass.defaultPreprocessors,
                  registeredPreprocessors = this.preprocessors,
                  hooks = {
                      onBeforeCreated: this.onBeforeCreated
                  },
                  preprocessors = [],
                  preprocessor, preprocessorsProperties,
                  i, ln, j, subLn, preprocessorProperty, process;
  
              delete data.preprocessors;
  
              for (i = 0,ln = preprocessorStack.length; i < ln; i++) {
                  preprocessor = preprocessorStack[i];
  
                  if (typeof preprocessor == 'string') {
                      preprocessor = registeredPreprocessors[preprocessor];
                      preprocessorsProperties = preprocessor.properties;
  
                      if (preprocessorsProperties === true) {
                          preprocessors.push(preprocessor.fn);
                      }
                      else if (preprocessorsProperties) {
                          for (j = 0,subLn = preprocessorsProperties.length; j < subLn; j++) {
                              preprocessorProperty = preprocessorsProperties[j];
  
                              if (data.hasOwnProperty(preprocessorProperty)) {
                                  preprocessors.push(preprocessor.fn);
                                  break;
                              }
                          }
                      }
                  }
                  else {
                      preprocessors.push(preprocessor);
                  }
              }
  
              hooks.onCreated = onCreated ? onCreated : Ext.emptyFn;
              hooks.preprocessors = preprocessors;
  
              this.doProcess(Class, data, hooks);
          },
          
          doProcess: function(Class, data, hooks){
              var me = this,
                  preprocessor = hooks.preprocessors.shift();
  
              if (!preprocessor) {
                  hooks.onBeforeCreated.apply(me, arguments);
                  return;
              }
  
              if (preprocessor.call(me, Class, data, hooks, me.doProcess) !== false) {
                  me.doProcess(Class, data, hooks);
              }
          },
  
          
          preprocessors: {},
  
          
          registerPreprocessor: function(name, fn, properties, position, relativeTo) {
              if (!position) {
                  position = 'last';
              }
  
              if (!properties) {
                  properties = [name];
              }
  
              this.preprocessors[name] = {
                  name: name,
                  properties: properties || false,
                  fn: fn
              };
  
              this.setDefaultPreprocessorPosition(name, position, relativeTo);
  
              return this;
          },
  
          
          getPreprocessor: function(name) {
              return this.preprocessors[name];
          },
  
          
          getPreprocessors: function() {
              return this.preprocessors;
          },
  
          
          defaultPreprocessors: [],
  
          
          getDefaultPreprocessors: function() {
              return this.defaultPreprocessors;
          },
  
          
          setDefaultPreprocessors: function(preprocessors) {
              this.defaultPreprocessors = Ext.Array.from(preprocessors);
  
              return this;
          },
  
          
          setDefaultPreprocessorPosition: function(name, offset, relativeName) {
              var defaultPreprocessors = this.defaultPreprocessors,
                  index;
  
              if (typeof offset == 'string') {
                  if (offset === 'first') {
                      defaultPreprocessors.unshift(name);
  
                      return this;
                  }
                  else if (offset === 'last') {
                      defaultPreprocessors.push(name);
  
                      return this;
                  }
  
                  offset = (offset === 'after') ? 1 : -1;
              }
  
              index = Ext.Array.indexOf(defaultPreprocessors, relativeName);
  
              if (index !== -1) {
                  Ext.Array.splice(defaultPreprocessors, Math.max(0, index + offset), 0, name);
              }
  
              return this;
          },
  
          configNameCache: {},
  
          getConfigNameMap: function(name) {
              var cache = this.configNameCache,
                  map = cache[name],
                  capitalizedName;
  
              if (!map) {
                  capitalizedName = name.charAt(0).toUpperCase() + name.substr(1);
  
                  map = cache[name] = {
                      internal: name,
                      initialized: '_is' + capitalizedName + 'Initialized',
                      apply: 'apply' + capitalizedName,
                      update: 'update' + capitalizedName,
                      'set': 'set' + capitalizedName,
                      'get': 'get' + capitalizedName,
                      doSet : 'doSet' + capitalizedName,
                      changeEvent: name.toLowerCase() + 'change'
                  };
              }
  
              return map;
          }
      });
  
      
      ExtClass.registerPreprocessor('extend', function(Class, data) {
          var Base = Ext.Base,
              basePrototype = Base.prototype,
              extend = data.extend,
              Parent, parentPrototype, i;
  
          delete data.extend;
  
          if (extend && extend !== Object) {
              Parent = extend;
          }
          else {
              Parent = Base;
          }
  
          parentPrototype = Parent.prototype;
  
          if (!Parent.$isClass) {
              for (i in basePrototype) {
                  if (!parentPrototype[i]) {
                      parentPrototype[i] = basePrototype[i];
                  }
              }
          }
  
          Class.extend(Parent);
  
          Class.triggerExtended.apply(Class, arguments);
  
          if (data.onClassExtended) {
              Class.onExtended(data.onClassExtended, Class);
              delete data.onClassExtended;
          }
  
      }, true);
  
      
      ExtClass.registerPreprocessor('statics', function(Class, data) {
          Class.addStatics(data.statics);
  
          delete data.statics;
      });
  
      
      ExtClass.registerPreprocessor('inheritableStatics', function(Class, data) {
          Class.addInheritableStatics(data.inheritableStatics);
  
          delete data.inheritableStatics;
      });
  
      
      ExtClass.registerPreprocessor('config', function(Class, data) {
          var config = data.config,
              prototype = Class.prototype;
  
          delete data.config;
  
          Ext.Object.each(config, function(name, value) {
              var nameMap = ExtClass.getConfigNameMap(name),
                  internalName = nameMap.internal,
                  initializedName = nameMap.initialized,
                  applyName = nameMap.apply,
                  updateName = nameMap.update,
                  setName = nameMap.set,
                  getName = nameMap.get,
                  hasOwnSetter = (setName in prototype) || data.hasOwnProperty(setName),
                  hasOwnApplier = (applyName in prototype) || data.hasOwnProperty(applyName),
                  hasOwnUpdater = (updateName in prototype) || data.hasOwnProperty(updateName),
                  optimizedGetter, customGetter;
  
              if (value === null || (!hasOwnSetter && !hasOwnApplier && !hasOwnUpdater)) {
                  prototype[internalName] = value;
                  prototype[initializedName] = true;
              }
              else {
                  prototype[initializedName] = false;
              }
  
              if (!hasOwnSetter) {
                  data[setName] = function(value) {
                      var oldValue = this[internalName],
                          applier = this[applyName],
                          updater = this[updateName];
  
                      if (!this[initializedName]) {
                          this[initializedName] = true;
                      }
  
                      if (applier) {
                          value = applier.call(this, value, oldValue);
                      }
  
                      if (typeof value != 'undefined') {
                          this[internalName] = value;
  
                          if (updater && value !== oldValue) {
                              updater.call(this, value, oldValue);
                          }
                      }
  
                      return this;
                  };
              }
  
              if (!(getName in prototype) || data.hasOwnProperty(getName)) {
                  customGetter = data[getName] || false;
  
                  if (customGetter) {
                      optimizedGetter = function() {
                          return customGetter.apply(this, arguments);
                      };
                  }
                  else {
                      optimizedGetter = function() {
                          return this[internalName];
                      };
                  }
  
                  data[getName] = function() {
                      var currentGetter;
  
                      if (!this[initializedName]) {
                          this[initializedName] = true;
                          this[setName](this.config[name]);
                      }
  
                      currentGetter = this[getName];
  
                      if ('$previous' in currentGetter) {
                          currentGetter.$previous = optimizedGetter;
                      }
                      else {
                          this[getName] = optimizedGetter;
                      }
  
                      return optimizedGetter.apply(this, arguments);
                  };
              }
          });
  
          Class.addConfig(config, true);
      });
  
      
      ExtClass.registerPreprocessor('mixins', function(Class, data, hooks) {
          var mixins = data.mixins,
              name, mixin, i, ln;
  
          delete data.mixins;
  
          Ext.Function.interceptBefore(hooks, 'onCreated', function() {
              if (mixins instanceof Array) {
                  for (i = 0,ln = mixins.length; i < ln; i++) {
                      mixin = mixins[i];
                      name = mixin.prototype.mixinId || mixin.$className;
  
                      Class.mixin(name, mixin);
                  }
              }
              else {
                  for (var mixinName in mixins) {
                      if (mixins.hasOwnProperty(mixinName)) {
                          Class.mixin(mixinName, mixins[mixinName]);
                      }
                  }
              }
          });
      });
  
      
      Ext.extend = function(Class, Parent, members) {
          if (arguments.length === 2 && Ext.isObject(Parent)) {
              members = Parent;
              Parent = Class;
              Class = null;
          }
  
          var cls;
  
          if (!Parent) {
              throw new Error("[Ext.extend] Attempting to extend from a class which has not been loaded on the page.");
          }
  
          members.extend = Parent;
          members.preprocessors = [
              'extend'
              ,'statics'
              ,'inheritableStatics'
              ,'mixins'
              ,'config'
          ];
  
          if (Class) {
              cls = new ExtClass(Class, members);
              
              cls.prototype.constructor = Class;
          } else {
              cls = new ExtClass(members);
          }
  
          cls.prototype.override = function(o) {
              for (var m in o) {
                  if (o.hasOwnProperty(m)) {
                      this[m] = o[m];
                  }
              }
          };
  
          return cls;
      };
  
  }());
  
  
  (function(Class, alias, arraySlice, arrayFrom, global) {
  
      
      function makeCtor () {
          function constructor () {
              
              
              return this.constructor.apply(this, arguments) || null;
          }
          return constructor;
      }
  
      var Manager = Ext.ClassManager = {
  
          
          classes: {},
  
          
          existCache: {},
  
          
          namespaceRewrites: [{
              from: 'Ext.',
              to: Ext
          }],
  
          
          maps: {
              alternateToName: {},
              aliasToName: {},
              nameToAliases: {},
              nameToAlternates: {}
          },
  
          
          enableNamespaceParseCache: true,
  
          
          namespaceParseCache: {},
  
          
          instantiators: [],
  
          
          isCreated: function(className) {
              var existCache = this.existCache,
                  i, ln, part, root, parts;
  
  
              if (this.classes[className] || existCache[className]) {
                  return true;
              }
  
              root = global;
              parts = this.parseNamespace(className);
  
              for (i = 0, ln = parts.length; i < ln; i++) {
                  part = parts[i];
  
                  if (typeof part != 'string') {
                      root = part;
                  } else {
                      if (!root || !root[part]) {
                          return false;
                      }
  
                      root = root[part];
                  }
              }
  
              existCache[className] = true;
  
              this.triggerCreated(className);
  
              return true;
          },
  
          
          createdListeners: [],
  
          
          nameCreatedListeners: {},
  
          
          triggerCreated: function(className) {
              var listeners = this.createdListeners,
                  nameListeners = this.nameCreatedListeners,
                  alternateNames = this.maps.nameToAlternates[className],
                  names = [className],
                  i, ln, j, subLn, listener, name;
  
              for (i = 0,ln = listeners.length; i < ln; i++) {
                  listener = listeners[i];
                  listener.fn.call(listener.scope, className);
              }
  
              if (alternateNames) {
                  names.push.apply(names, alternateNames);
              }
  
              for (i = 0,ln = names.length; i < ln; i++) {
                  name = names[i];
                  listeners = nameListeners[name];
  
                  if (listeners) {
                      for (j = 0,subLn = listeners.length; j < subLn; j++) {
                          listener = listeners[j];
                          listener.fn.call(listener.scope, name);
                      }
                      delete nameListeners[name];
                  }
              }
          },
  
          
          onCreated: function(fn, scope, className) {
              var listeners = this.createdListeners,
                  nameListeners = this.nameCreatedListeners,
                  listener = {
                      fn: fn,
                      scope: scope
                  };
  
              if (className) {
                  if (this.isCreated(className)) {
                      fn.call(scope, className);
                      return;
                  }
  
                  if (!nameListeners[className]) {
                      nameListeners[className] = [];
                  }
  
                  nameListeners[className].push(listener);
              }
              else {
                  listeners.push(listener);
              }
          },
  
          
          parseNamespace: function(namespace) {
  
              var cache = this.namespaceParseCache,
                  parts,
                  rewrites,
                  root,
                  name,
                  rewrite, from, to, i, ln;
  
              if (this.enableNamespaceParseCache) {
                  if (cache.hasOwnProperty(namespace)) {
                      return cache[namespace];
                  }
              }
  
              parts = [];
              rewrites = this.namespaceRewrites;
              root = global;
              name = namespace;
  
              for (i = 0, ln = rewrites.length; i < ln; i++) {
                  rewrite = rewrites[i];
                  from = rewrite.from;
                  to = rewrite.to;
  
                  if (name === from || name.substring(0, from.length) === from) {
                      name = name.substring(from.length);
  
                      if (typeof to != 'string') {
                          root = to;
                      } else {
                          parts = parts.concat(to.split('.'));
                      }
  
                      break;
                  }
              }
  
              parts.push(root);
  
              parts = parts.concat(name.split('.'));
  
              if (this.enableNamespaceParseCache) {
                  cache[namespace] = parts;
              }
  
              return parts;
          },
  
          
          setNamespace: function(name, value) {
              var root = global,
                  parts = this.parseNamespace(name),
                  ln = parts.length - 1,
                  leaf = parts[ln],
                  i, part;
  
              for (i = 0; i < ln; i++) {
                  part = parts[i];
  
                  if (typeof part != 'string') {
                      root = part;
                  } else {
                      if (!root[part]) {
                          root[part] = {};
                      }
  
                      root = root[part];
                  }
              }
  
              root[leaf] = value;
  
              return root[leaf];
          },
  
          
          createNamespaces: function() {
              var root = global,
                  parts, part, i, j, ln, subLn;
  
              for (i = 0, ln = arguments.length; i < ln; i++) {
                  parts = this.parseNamespace(arguments[i]);
  
                  for (j = 0, subLn = parts.length; j < subLn; j++) {
                      part = parts[j];
  
                      if (typeof part != 'string') {
                          root = part;
                      } else {
                          if (!root[part]) {
                              root[part] = {};
                          }
  
                          root = root[part];
                      }
                  }
              }
  
              return root;
          },
  
          
          set: function(name, value) {
              var me = this,
                  maps = me.maps,
                  nameToAlternates = maps.nameToAlternates,
                  targetName = me.getName(value),
                  alternates;
  
              me.classes[name] = me.setNamespace(name, value);
  
              if (targetName && targetName !== name) {
                  maps.alternateToName[name] = targetName;
                  alternates = nameToAlternates[targetName] || (nameToAlternates[targetName] = []);
                  alternates.push(name);
              }
  
              return this;
          },
  
          
          get: function(name) {
              var classes = this.classes,
                  root,
                  parts,
                  part, i, ln;
  
              if (classes[name]) {
                  return classes[name];
              }
  
              root = global;
              parts = this.parseNamespace(name);
  
              for (i = 0, ln = parts.length; i < ln; i++) {
                  part = parts[i];
  
                  if (typeof part != 'string') {
                      root = part;
                  } else {
                      if (!root || !root[part]) {
                          return null;
                      }
  
                      root = root[part];
                  }
              }
  
              return root;
          },
  
          
          setAlias: function(cls, alias) {
              var aliasToNameMap = this.maps.aliasToName,
                  nameToAliasesMap = this.maps.nameToAliases,
                  className;
  
              if (typeof cls == 'string') {
                  className = cls;
              } else {
                  className = this.getName(cls);
              }
  
              if (alias && aliasToNameMap[alias] !== className) {
  
                  aliasToNameMap[alias] = className;
              }
  
              if (!nameToAliasesMap[className]) {
                  nameToAliasesMap[className] = [];
              }
  
              if (alias) {
                  Ext.Array.include(nameToAliasesMap[className], alias);
              }
  
              return this;
          },
  
          
          getByAlias: function(alias) {
              return this.get(this.getNameByAlias(alias));
          },
  
          
          getNameByAlias: function(alias) {
              return this.maps.aliasToName[alias] || '';
          },
  
          
          getNameByAlternate: function(alternate) {
              return this.maps.alternateToName[alternate] || '';
          },
  
          
          getAliasesByName: function(name) {
              return this.maps.nameToAliases[name] || [];
          },
  
          
          getName: function(object) {
              return object && object.$className || '';
          },
  
          
          getClass: function(object) {
              return object && object.self || null;
          },
  
          
          create: function(className, data, createdFn) {
  
              var ctor = makeCtor();
              if (typeof data == 'function') {
                  data = data(ctor);
              }
  
  
              data.$className = className;
  
              return new Class(ctor, data, function() {
                  var postprocessorStack = data.postprocessors || Manager.defaultPostprocessors,
                      registeredPostprocessors = Manager.postprocessors,
                      postprocessors = [],
                      postprocessor, i, ln, j, subLn, postprocessorProperties, postprocessorProperty;
  
                  delete data.postprocessors;
  
                  for (i = 0,ln = postprocessorStack.length; i < ln; i++) {
                      postprocessor = postprocessorStack[i];
  
                      if (typeof postprocessor == 'string') {
                          postprocessor = registeredPostprocessors[postprocessor];
                          postprocessorProperties = postprocessor.properties;
  
                          if (postprocessorProperties === true) {
                              postprocessors.push(postprocessor.fn);
                          }
                          else if (postprocessorProperties) {
                              for (j = 0,subLn = postprocessorProperties.length; j < subLn; j++) {
                                  postprocessorProperty = postprocessorProperties[j];
  
                                  if (data.hasOwnProperty(postprocessorProperty)) {
                                      postprocessors.push(postprocessor.fn);
                                      break;
                                  }
                              }
                          }
                      }
                      else {
                          postprocessors.push(postprocessor);
                      }
                  }
  
                  data.postprocessors = postprocessors;
                  data.createdFn = createdFn;
                  Manager.processCreate(className, this, data);
              });
          },
          
          processCreate: function(className, cls, clsData){
              var me = this,
                  postprocessor = clsData.postprocessors.shift(),
                  createdFn = clsData.createdFn;
  
              if (!postprocessor) {
                  if (className) {
                      me.set(className, cls);
                  }
  
                  if (createdFn) {
                      createdFn.call(cls, cls);
                  }
  
                  if (className) {
                      me.triggerCreated(className);
                  }
                  return;
              }
  
              if (postprocessor.call(me, className, cls, clsData, me.processCreate) !== false) {
                  me.processCreate(className, cls, clsData);
              }
          },
  
          createOverride: function (className, data, createdFn) {
              var me = this,
                  overriddenClassName = data.override,
                  requires = data.requires,
                  uses = data.uses,
                  classReady = function () {
                      var cls, temp;
  
                      if (requires) {
                          temp = requires;
                          requires = null; 
  
                          
                          
                          
                          Ext.Loader.require(temp, classReady);
                      } else {
                          
                          
                          cls = me.get(overriddenClassName);
  
                          
                          delete data.override;
                          delete data.requires;
                          delete data.uses;
  
                          Ext.override(cls, data);
  
                          
                          
                          
                          me.triggerCreated(className);
  
                          if (uses) {
                              Ext.Loader.addUsedClasses(uses); 
                          }
  
                          if (createdFn) {
                              createdFn.call(cls); 
                          }
                      }
                  };
  
              me.existCache[className] = true;
  
              
              me.onCreated(classReady, me, overriddenClassName);
   
              return me;
          },
  
          
          instantiateByAlias: function() {
              var alias = arguments[0],
                  args = arraySlice.call(arguments),
                  className = this.getNameByAlias(alias);
  
              if (!className) {
                  className = this.maps.aliasToName[alias];
  
  
  
                  Ext.syncRequire(className);
              }
  
              args[0] = className;
  
              return this.instantiate.apply(this, args);
          },
  
          
          instantiate: function() {
              var name = arguments[0],
                  nameType = typeof name,
                  args = arraySlice.call(arguments, 1),
                  alias = name,
                  possibleName, cls;
  
              if (nameType != 'function') {
                  if (nameType != 'string' && args.length === 0) {
                      args = [name];
                      name = name.xclass;
                  }
  
  
                  cls = this.get(name);
              }
              else {
                  cls = name;
              }
  
              
              if (!cls) {
                  possibleName = this.getNameByAlias(name);
  
                  if (possibleName) {
                      name = possibleName;
  
                      cls = this.get(name);
                  }
              }
  
              
              if (!cls) {
                  possibleName = this.getNameByAlternate(name);
  
                  if (possibleName) {
                      name = possibleName;
  
                      cls = this.get(name);
                  }
              }
  
              
              if (!cls) {
  
                  Ext.syncRequire(name);
  
                  cls = this.get(name);
              }
  
  
              return this.getInstantiator(args.length)(cls, args);
          },
  
          
          dynInstantiate: function(name, args) {
              args = arrayFrom(args, true);
              args.unshift(name);
  
              return this.instantiate.apply(this, args);
          },
  
          
          getInstantiator: function(length) {
              var instantiators = this.instantiators,
                  instantiator,
                  i,
                  args;
  
              instantiator = instantiators[length];
  
              if (!instantiator) {
                  i = length;
                  args = [];
  
                  for (i = 0; i < length; i++) {
                      args.push('a[' + i + ']');
                  }
  
                  instantiator = instantiators[length] = new Function('c', 'a', 'return new c(' + args.join(',') + ')');
              }
  
              return instantiator;
          },
  
          
          postprocessors: {},
  
          
          defaultPostprocessors: [],
  
          
          registerPostprocessor: function(name, fn, properties, position, relativeTo) {
              if (!position) {
                  position = 'last';
              }
  
              if (!properties) {
                  properties = [name];
              }
  
              this.postprocessors[name] = {
                  name: name,
                  properties: properties || false,
                  fn: fn
              };
  
              this.setDefaultPostprocessorPosition(name, position, relativeTo);
  
              return this;
          },
  
          
          setDefaultPostprocessors: function(postprocessors) {
              this.defaultPostprocessors = arrayFrom(postprocessors);
  
              return this;
          },
  
          
          setDefaultPostprocessorPosition: function(name, offset, relativeName) {
              var defaultPostprocessors = this.defaultPostprocessors,
                  index;
  
              if (typeof offset == 'string') {
                  if (offset === 'first') {
                      defaultPostprocessors.unshift(name);
  
                      return this;
                  }
                  else if (offset === 'last') {
                      defaultPostprocessors.push(name);
  
                      return this;
                  }
  
                  offset = (offset === 'after') ? 1 : -1;
              }
  
              index = Ext.Array.indexOf(defaultPostprocessors, relativeName);
  
              if (index !== -1) {
                  Ext.Array.splice(defaultPostprocessors, Math.max(0, index + offset), 0, name);
              }
  
              return this;
          },
  
          
          getNamesByExpression: function(expression) {
              var nameToAliasesMap = this.maps.nameToAliases,
                  names = [],
                  name, alias, aliases, possibleName, regex, i, ln;
  
  
              if (expression.indexOf('*') !== -1) {
                  expression = expression.replace(/\*/g, '(.*?)');
                  regex = new RegExp('^' + expression + '$');
  
                  for (name in nameToAliasesMap) {
                      if (nameToAliasesMap.hasOwnProperty(name)) {
                          aliases = nameToAliasesMap[name];
  
                          if (name.search(regex) !== -1) {
                              names.push(name);
                          }
                          else {
                              for (i = 0, ln = aliases.length; i < ln; i++) {
                                  alias = aliases[i];
  
                                  if (alias.search(regex) !== -1) {
                                      names.push(name);
                                      break;
                                  }
                              }
                          }
                      }
                  }
  
              } else {
                  possibleName = this.getNameByAlias(expression);
  
                  if (possibleName) {
                      names.push(possibleName);
                  } else {
                      possibleName = this.getNameByAlternate(expression);
  
                      if (possibleName) {
                          names.push(possibleName);
                      } else {
                          names.push(expression);
                      }
                  }
              }
  
              return names;
          }
      };
  
      
      Manager.registerPostprocessor('alias', function(name, cls, data) {
          var aliases = data.alias,
              i, ln;
  
          for (i = 0,ln = aliases.length; i < ln; i++) {
              alias = aliases[i];
  
              this.setAlias(cls, alias);
          }
  
      }, ['xtype', 'alias']);
  
      
      Manager.registerPostprocessor('singleton', function(name, cls, data, fn) {
          fn.call(this, name, new cls(), data);
          return false;
      });
  
      
      Manager.registerPostprocessor('alternateClassName', function(name, cls, data) {
          var alternates = data.alternateClassName,
              i, ln, alternate;
  
          if (!(alternates instanceof Array)) {
              alternates = [alternates];
          }
  
          for (i = 0, ln = alternates.length; i < ln; i++) {
              alternate = alternates[i];
  
  
              this.set(alternate, cls);
          }
      });
  
      Ext.apply(Ext, {
          
          create: alias(Manager, 'instantiate'),
  
          
          widget: function(name, config) {
              
              
              
              
              
              
              
              var xtype = name,
                  alias, className, T, load;
  
              if (typeof xtype != 'string') { 
                  
                  config = name; 
                  xtype = config.xtype;
              } else {
                  config = config || {};
              }
              
              if (config.isComponent) {
                  return config;
              }
  
              alias = 'widget.' + xtype;
              className = Manager.getNameByAlias(alias);
  
              
              if (!className) {
                  load = true;
              }
              
              T = Manager.get(className);
              if (load || !T) {
                  return Manager.instantiateByAlias(alias, config);
              }
              return new T(config);
          },
  
          
          createByAlias: alias(Manager, 'instantiateByAlias'),
  
          
          define: function (className, data, createdFn) {
              if (data.override) {
                  return Manager.createOverride.apply(Manager, arguments);
              }
  
              return Manager.create.apply(Manager, arguments);
          },
  
          
          getClassName: alias(Manager, 'getName'),
  
          
          getDisplayName: function(object) {
              if (object) {
                  if (object.displayName) {
                      return object.displayName;
                  }
  
                  if (object.$name && object.$class) {
                      return Ext.getClassName(object.$class) + '#' + object.$name;
                  }
  
                  if (object.$className) {
                      return object.$className;
                  }
              }
  
              return 'Anonymous';
          },
  
          
          getClass: alias(Manager, 'getClass'),
  
          
          namespace: alias(Manager, 'createNamespaces')
      });
  
      
      Ext.createWidget = Ext.widget;
  
      
      Ext.ns = Ext.namespace;
  
      Class.registerPreprocessor('className', function(cls, data) {
          if (data.$className) {
              cls.$className = data.$className;
          }
      }, true, 'first');
  
      Class.registerPreprocessor('alias', function(cls, data) {
          var prototype = cls.prototype,
              xtypes = arrayFrom(data.xtype),
              aliases = arrayFrom(data.alias),
              widgetPrefix = 'widget.',
              widgetPrefixLength = widgetPrefix.length,
              xtypesChain = Array.prototype.slice.call(prototype.xtypesChain || []),
              xtypesMap = Ext.merge({}, prototype.xtypesMap || {}),
              i, ln, alias, xtype;
  
          for (i = 0,ln = aliases.length; i < ln; i++) {
              alias = aliases[i];
  
  
              if (alias.substring(0, widgetPrefixLength) === widgetPrefix) {
                  xtype = alias.substring(widgetPrefixLength);
                  Ext.Array.include(xtypes, xtype);
              }
          }
  
          cls.xtype = data.xtype = xtypes[0];
          data.xtypes = xtypes;
  
          for (i = 0,ln = xtypes.length; i < ln; i++) {
              xtype = xtypes[i];
  
              if (!xtypesMap[xtype]) {
                  xtypesMap[xtype] = true;
                  xtypesChain.push(xtype);
              }
          }
  
          data.xtypesChain = xtypesChain;
          data.xtypesMap = xtypesMap;
  
          Ext.Function.interceptAfter(data, 'onClassCreated', function() {
              var mixins = prototype.mixins,
                  key, mixin;
  
              for (key in mixins) {
                  if (mixins.hasOwnProperty(key)) {
                      mixin = mixins[key];
  
                      xtypes = mixin.xtypes;
  
                      if (xtypes) {
                          for (i = 0,ln = xtypes.length; i < ln; i++) {
                              xtype = xtypes[i];
  
                              if (!xtypesMap[xtype]) {
                                  xtypesMap[xtype] = true;
                                  xtypesChain.push(xtype);
                              }
                          }
                      }
                  }
              }
          });
  
          for (i = 0,ln = xtypes.length; i < ln; i++) {
              xtype = xtypes[i];
  
  
              Ext.Array.include(aliases, widgetPrefix + xtype);
          }
  
          data.alias = aliases;
  
      }, ['xtype', 'alias']);
  
  }(Ext.Class, Ext.Function.alias, Array.prototype.slice, Ext.Array.from, Ext.global));
  
  
  
  Ext.Loader = new function() {
      var Loader = this,
          Manager = Ext.ClassManager,
          Class = Ext.Class,
          flexSetter = Ext.Function.flexSetter,
          alias = Ext.Function.alias,
          pass = Ext.Function.pass,
          defer = Ext.Function.defer,
          arrayErase = Ext.Array.erase,
          dependencyProperties = ['extend', 'mixins', 'requires'],
          isInHistory = {},
          history = [],
          slashDotSlashRe = /\/\.\//g,
          dotRe = /\./g;
  
      Ext.apply(Loader, {
  
          
          isInHistory: isInHistory,
  
          
          history: history,
  
          
          config: {
              
              enabled: false,
  
              
              scriptChainDelay : false,
  
              
              disableCaching: true,
  
              
              disableCachingParam: '_dc',
  
              
              garbageCollect : false,
  
              
              paths: {
                  'Ext': '.'
              },
  
              
              preserveScripts : true,
  
              
              scriptCharset : undefined
          },
  
          
          setConfig: function(name, value) {
              if (Ext.isObject(name) && arguments.length === 1) {
                  Ext.merge(Loader.config, name);
              }
              else {
                  Loader.config[name] = (Ext.isObject(value)) ? Ext.merge(Loader.config[name], value) : value;
              }
  
              return Loader;
          },
  
          
          getConfig: function(name) {
              if (name) {
                  return Loader.config[name];
              }
  
              return Loader.config;
          },
  
          
          setPath: flexSetter(function(name, path) {
              Loader.config.paths[name] = path;
  
              return Loader;
          }),
  
          
          getPath: function(className) {
              var path = '',
                  paths = Loader.config.paths,
                  prefix = Loader.getPrefix(className);
  
              if (prefix.length > 0) {
                  if (prefix === className) {
                      return paths[prefix];
                  }
  
                  path = paths[prefix];
                  className = className.substring(prefix.length + 1);
              }
  
              if (path.length > 0) {
                  path += '/';
              }
  
              return path.replace(slashDotSlashRe, '/') + className.replace(dotRe, "/") + '.js';
          },
  
          
          getPrefix: function(className) {
              var paths = Loader.config.paths,
                  prefix, deepestPrefix = '';
  
              if (paths.hasOwnProperty(className)) {
                  return className;
              }
  
              for (prefix in paths) {
                  if (paths.hasOwnProperty(prefix) && prefix + '.' === className.substring(0, prefix.length + 1)) {
                      if (prefix.length > deepestPrefix.length) {
                          deepestPrefix = prefix;
                      }
                  }
              }
  
              return deepestPrefix;
          },
  
          
          isAClassNameWithAKnownPrefix: function(className) {
              var prefix = Loader.getPrefix(className);
  
              
              return prefix !== '' && prefix !== className;
          },
  
          
          require: function(expressions, fn, scope, excludes) {
              if (fn) {
                  fn.call(scope);
              }
          },
  
          
          syncRequire: function() {},
  
          
          exclude: function(excludes) {
              return {
                  require: function(expressions, fn, scope) {
                      return Loader.require(expressions, fn, scope, excludes);
                  },
  
                  syncRequire: function(expressions, fn, scope) {
                      return Loader.syncRequire(expressions, fn, scope, excludes);
                  }
              };
          },
  
          
          onReady: function(fn, scope, withDomReady, options) {
              var oldFn;
  
              if (withDomReady !== false && Ext.onDocumentReady) {
                  oldFn = fn;
  
                  fn = function() {
                      Ext.onDocumentReady(oldFn, scope, options);
                  };
              }
  
              fn.call(scope);
          }
      });
  
      var queue = [],
          isClassFileLoaded = {},
          isFileLoaded = {},
          classNameToFilePathMap = {},
          scriptElements = {},
          readyListeners = [],
          usedClasses = [],
          requiresMap = {};
  
      Ext.apply(Loader, {
          
          documentHead: typeof document != 'undefined' && (document.head || document.getElementsByTagName('head')[0]),
  
          
          isLoading: false,
  
          
          queue: queue,
  
          
          isClassFileLoaded: isClassFileLoaded,
  
          
          isFileLoaded: isFileLoaded,
  
          
          readyListeners: readyListeners,
  
          
          optionalRequires: usedClasses,
  
          
          requiresMap: requiresMap,
  
          
          numPendingFiles: 0,
  
          
          numLoadedFiles: 0,
  
          
          hasFileLoadError: false,
  
          
          classNameToFilePathMap: classNameToFilePathMap,
  
          
          scriptsLoading: 0,
  
          
          syncModeEnabled: false,
  
          scriptElements: scriptElements,
  
          
          refreshQueue: function() {
              var ln = queue.length,
                  i, item, j, requires;
  
              
  
              if (!ln && !Loader.scriptsLoading) {
                  return Loader.triggerReady();
              }
  
              for (i = 0; i < ln; i++) {
                  item = queue[i];
  
                  if (item) {
                      requires = item.requires;
  
                      
                      
                      if (requires.length > Loader.numLoadedFiles) {
                          continue;
                      }
  
                      
                      for (j = 0; j < requires.length; ) {
                          if (Manager.isCreated(requires[j])) {
                              
                              arrayErase(requires, j, 1);
                          }
                          else {
                              j++;
                          }
                      }
  
                      
                      if (item.requires.length === 0) {
                          arrayErase(queue, i, 1);
                          item.callback.call(item.scope);
                          Loader.refreshQueue();
                          break;
                      }
                  }
              }
  
              return Loader;
          },
  
          
          injectScriptElement: function(url, onLoad, onError, scope, charset) {
              var script = document.createElement('script'),
                  dispatched = false,
                  config = Loader.config,
                  onLoadFn = function() {
  
                      if(!dispatched) {
                          dispatched = true;
                          script.onload = script.onreadystatechange = script.onerror = null;
                          if (typeof config.scriptChainDelay == 'number') {
                              
                              defer(onLoad, config.scriptChainDelay, scope);
                          } else {
                              onLoad.call(scope);
                          }
                          Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
                      }
  
                  },
                  onErrorFn = function(arg) {
                      defer(onError, 1, scope);   
                      Loader.cleanupScriptElement(script, config.preserveScripts === false, config.garbageCollect);
                  };
  
              script.type = 'text/javascript';
              script.onerror = onErrorFn;
              charset = charset || config.scriptCharset;
              if (charset) {
                  script.charset = charset;
              }
  
              
              if ('addEventListener' in script ) {
                  script.onload = onLoadFn;
              } else if ('readyState' in script) {   
                  script.onreadystatechange = function() {
                      if ( this.readyState == 'loaded' || this.readyState == 'complete' ) {
                          onLoadFn();
                      }
                  };
              } else {
                   script.onload = onLoadFn;
              }
  
              script.src = url;
              (Loader.documentHead || document.getElementsByTagName('head')[0]).appendChild(script);
  
              return script;
          },
  
          
          removeScriptElement: function(url) {
              if (scriptElements[url]) {
                  Loader.cleanupScriptElement(scriptElements[url], true, !!Loader.getConfig('garbageCollect'));
                  delete scriptElements[url];
              }
  
              return Loader;
          },
  
          
          cleanupScriptElement: function(script, remove, collect) {
              var prop;
              script.onload = script.onreadystatechange = script.onerror = null;
              if (remove) {
                  Ext.removeNode(script);       
                  if (collect) {
                      for (prop in script) {
                          try {
                              script[prop] = null;
                              delete script[prop];      
                          } catch (cleanEx) {
                              
                          }
                      }
                  }
              }
  
              return Loader;
          },
  
          
          loadScript: function (options) {
              var config = Loader.getConfig(),
                  isString = typeof options == 'string',
                  url = isString ? options : options.url,
                  onError = !isString && options.onError,
                  onLoad = !isString && options.onLoad,
                  scope = !isString && options.scope,
                  onScriptError = function() {
                      Loader.numPendingFiles--;
                      Loader.scriptsLoading--;
  
                      if (onError) {
                          onError.call(scope, "Failed loading '" + url + "', please verify that the file exists");
                      }
  
                      if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
                          Loader.refreshQueue();
                      }
                  },
                  onScriptLoad = function () {
                      Loader.numPendingFiles--;
                      Loader.scriptsLoading--;
  
                      if (onLoad) {
                          onLoad.call(scope);
                      }
  
                      if (Loader.numPendingFiles + Loader.scriptsLoading === 0) {
                          Loader.refreshQueue();
                      }
                  },
                  src;
  
              Loader.isLoading = true;
              Loader.numPendingFiles++;
              Loader.scriptsLoading++;
  
              src = config.disableCaching ?
                  (url + '?' + config.disableCachingParam + '=' + Ext.Date.now()) : url;
  
              scriptElements[url] = Loader.injectScriptElement(src, onScriptLoad, onScriptError);
          },
  
          
          loadScriptFile: function(url, onLoad, onError, scope, synchronous) {
              if (isFileLoaded[url]) {
                  return Loader;
              }
  
              var config = Loader.getConfig(),
                  noCacheUrl = url + (config.disableCaching ? ('?' + config.disableCachingParam + '=' + Ext.Date.now()) : ''),
                  isCrossOriginRestricted = false,
                  xhr, status, onScriptError,
                  debugSourceURL = "";
  
              scope = scope || Loader;
  
              Loader.isLoading = true;
  
              if (!synchronous) {
                  onScriptError = function() {
                  };
  
                  scriptElements[url] = Loader.injectScriptElement(noCacheUrl, onLoad, onScriptError, scope);
              } else {
                  if (typeof XMLHttpRequest != 'undefined') {
                      xhr = new XMLHttpRequest();
                  } else {
                      xhr = new ActiveXObject('Microsoft.XMLHTTP');
                  }
  
                  try {
                      xhr.open('GET', noCacheUrl, false);
                      xhr.send(null);
                  } catch (e) {
                      isCrossOriginRestricted = true;
                  }
  
                  status = (xhr.status === 1223) ? 204 :
                      (xhr.status === 0 && (self.location || {}).protocol == 'file:') ? 200 : xhr.status;
  
                  isCrossOriginRestricted = isCrossOriginRestricted || (status === 0);
  
                  if (isCrossOriginRestricted
                  ) {
                  }
                  else if ((status >= 200 && status < 300) || (status === 304)
                  ) {
                      
                      
                      if (!Ext.isIE) {
                          debugSourceURL = "\n//@ sourceURL=" + url;
                      }
  
                      Ext.globalEval(xhr.responseText + debugSourceURL);
  
                      onLoad.call(scope);
                  }
                  else {
                  }
  
                  
                  xhr = null;
              }
          },
  
          
          syncRequire: function() {
              var syncModeEnabled = Loader.syncModeEnabled;
  
              if (!syncModeEnabled) {
                  Loader.syncModeEnabled = true;
              }
  
              Loader.require.apply(Loader, arguments);
  
              if (!syncModeEnabled) {
                  Loader.syncModeEnabled = false;
              }
  
              Loader.refreshQueue();
          },
  
          
          require: function(expressions, fn, scope, excludes) {
              var excluded = {},
                  included = {},
                  excludedClassNames = [],
                  possibleClassNames = [],
                  classNames = [],
                  references = [],
                  callback,
                  syncModeEnabled,
                  filePath, expression, exclude, className,
                  possibleClassName, i, j, ln, subLn;
  
              if (excludes) {
                  
                  excludes = (typeof excludes === 'string') ? [ excludes ] : excludes;
  
                  for (i = 0,ln = excludes.length; i < ln; i++) {
                      exclude = excludes[i];
  
                      if (typeof exclude == 'string' && exclude.length > 0) {
                          excludedClassNames = Manager.getNamesByExpression(exclude);
  
                          for (j = 0,subLn = excludedClassNames.length; j < subLn; j++) {
                              excluded[excludedClassNames[j]] = true;
                          }
                      }
                  }
              }
  
              
              expressions = (typeof expressions === 'string') ? [ expressions ] : (expressions ? expressions : []);
  
              if (fn) {
                  if (fn.length > 0) {
                      callback = function() {
                          var classes = [],
                              i, ln;
  
                          for (i = 0,ln = references.length; i < ln; i++) {
                              classes.push(Manager.get(references[i]));
                          }
  
                          return fn.apply(this, classes);
                      };
                  }
                  else {
                      callback = fn;
                  }
              }
              else {
                  callback = Ext.emptyFn;
              }
  
              scope = scope || Ext.global;
  
              for (i = 0,ln = expressions.length; i < ln; i++) {
                  expression = expressions[i];
  
                  if (typeof expression == 'string' && expression.length > 0) {
                      possibleClassNames = Manager.getNamesByExpression(expression);
                      subLn = possibleClassNames.length;
  
                      for (j = 0; j < subLn; j++) {
                          possibleClassName = possibleClassNames[j];
  
                          if (excluded[possibleClassName] !== true) {
                              references.push(possibleClassName);
  
                              if (!Manager.isCreated(possibleClassName) && !included[possibleClassName]) {
                                  included[possibleClassName] = true;
                                  classNames.push(possibleClassName);
                              }
                          }
                      }
                  }
              }
  
              
              
              if (classNames.length > 0) {
                  if (!Loader.config.enabled) {
                      throw new Error("Ext.Loader is not enabled, so dependencies cannot be resolved dynamically. " +
                               "Missing required class" + ((classNames.length > 1) ? "es" : "") + ": " + classNames.join(', '));
                  }
              }
              else {
                  callback.call(scope);
                  return Loader;
              }
  
              syncModeEnabled = Loader.syncModeEnabled;
  
              if (!syncModeEnabled) {
                  queue.push({
                      requires: classNames.slice(), 
                                                    
                      callback: callback,
                      scope: scope
                  });
              }
  
              ln = classNames.length;
  
              for (i = 0; i < ln; i++) {
                  className = classNames[i];
  
                  filePath = Loader.getPath(className);
  
                  
                  
                  
                  if (syncModeEnabled && isClassFileLoaded.hasOwnProperty(className)) {
                      Loader.numPendingFiles--;
                      Loader.removeScriptElement(filePath);
                      delete isClassFileLoaded[className];
                  }
  
                  if (!isClassFileLoaded.hasOwnProperty(className)) {
                      isClassFileLoaded[className] = false;
  
                      classNameToFilePathMap[className] = filePath;
  
                      Loader.numPendingFiles++;
                      Loader.loadScriptFile(
                          filePath,
                          pass(Loader.onFileLoaded, [className, filePath], Loader),
                          pass(Loader.onFileLoadError, [className, filePath], Loader),
                          Loader,
                          syncModeEnabled
                      );
                  }
              }
  
              if (syncModeEnabled) {
                  callback.call(scope);
  
                  if (ln === 1) {
                      return Manager.get(className);
                  }
              }
  
              return Loader;
          },
  
          
          onFileLoaded: function(className, filePath) {
              Loader.numLoadedFiles++;
  
              isClassFileLoaded[className] = true;
              isFileLoaded[filePath] = true;
  
              Loader.numPendingFiles--;
  
              if (Loader.numPendingFiles === 0) {
                  Loader.refreshQueue();
              }
  
          },
  
          
          onFileLoadError: function(className, filePath, errorMessage, isSynchronous) {
              Loader.numPendingFiles--;
              Loader.hasFileLoadError = true;
  
          },
  
          
          addUsedClasses: function (classes) {
              var cls, i, ln;
  
              if (classes) {
                  classes = (typeof classes == 'string') ? [classes] : classes;
                  for (i = 0, ln = classes.length; i < ln; i++) {
                      cls = classes[i];
                      if (typeof cls == 'string' && !Ext.Array.contains(usedClasses, cls)) {
                          usedClasses.push(cls);
                      }
                  }
              }
  
              return Loader;
          },
  
          
          triggerReady: function() {
              var listener,
                  i, refClasses = usedClasses;
  
              if (Loader.isLoading) {
                  Loader.isLoading = false;
  
                  if (refClasses.length !== 0) {
                      
                      refClasses = refClasses.slice();
                      usedClasses.length = 0;
                      
                      
                      Loader.require(refClasses, Loader.triggerReady, Loader);
                      return Loader;
                  }
              }
  
              
              
              
              while (readyListeners.length && !Loader.isLoading) {
                  
                  
                  listener = readyListeners.shift();
                  listener.fn.call(listener.scope);
              }
  
              return Loader;
          },
  
          
          onReady: function(fn, scope, withDomReady, options) {
              var oldFn;
  
              if (withDomReady !== false && Ext.onDocumentReady) {
                  oldFn = fn;
  
                  fn = function() {
                      Ext.onDocumentReady(oldFn, scope, options);
                  };
              }
  
              if (!Loader.isLoading) {
                  fn.call(scope);
              }
              else {
                  readyListeners.push({
                      fn: fn,
                      scope: scope
                  });
              }
          },
  
          
          historyPush: function(className) {
              if (className && isClassFileLoaded.hasOwnProperty(className) && !isInHistory[className]) {
                  isInHistory[className] = true;
                  history.push(className);
              }
              return Loader;
          }
      });
  
      
      Ext.disableCacheBuster = function (disable, path) {
          var date = new Date();
          date.setTime(date.getTime() + (disable ? 10*365 : -1) * 24*60*60*1000);
          date = date.toGMTString();
          document.cookie = 'ext-cache=1; expires=' + date + '; path='+(path || '/');
      };
  
  
      
      Ext.require = alias(Loader, 'require');
  
      
      Ext.syncRequire = alias(Loader, 'syncRequire');
  
      
      Ext.exclude = alias(Loader, 'exclude');
  
      
      Ext.onReady = function(fn, scope, options) {
          Loader.onReady(fn, scope, true, options);
      };
  
      
      Class.registerPreprocessor('loader', function(cls, data, hooks, continueFn) {
          var me = this,
              dependencies = [],
              dependency,
              className = Manager.getName(cls),
              i, j, ln, subLn, value, propertyName, propertyValue,
              requiredMap, requiredDep;
  
          
  
          for (i = 0,ln = dependencyProperties.length; i < ln; i++) {
              propertyName = dependencyProperties[i];
  
              if (data.hasOwnProperty(propertyName)) {
                  propertyValue = data[propertyName];
  
                  if (typeof propertyValue == 'string') {
                      dependencies.push(propertyValue);
                  }
                  else if (propertyValue instanceof Array) {
                      for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
                          value = propertyValue[j];
  
                          if (typeof value == 'string') {
                              dependencies.push(value);
                          }
                      }
                  }
                  else if (typeof propertyValue != 'function') {
                      for (j in propertyValue) {
                          if (propertyValue.hasOwnProperty(j)) {
                              value = propertyValue[j];
  
                              if (typeof value == 'string') {
                                  dependencies.push(value);
                              }
                          }
                      }
                  }
              }
          }
  
          if (dependencies.length === 0) {
              return;
          }
  
  
          Loader.require(dependencies, function() {
              for (i = 0,ln = dependencyProperties.length; i < ln; i++) {
                  propertyName = dependencyProperties[i];
  
                  if (data.hasOwnProperty(propertyName)) {
                      propertyValue = data[propertyName];
  
                      if (typeof propertyValue == 'string') {
                          data[propertyName] = Manager.get(propertyValue);
                      }
                      else if (propertyValue instanceof Array) {
                          for (j = 0, subLn = propertyValue.length; j < subLn; j++) {
                              value = propertyValue[j];
  
                              if (typeof value == 'string') {
                                  data[propertyName][j] = Manager.get(value);
                              }
                          }
                      }
                      else if (typeof propertyValue != 'function') {
                          for (var k in propertyValue) {
                              if (propertyValue.hasOwnProperty(k)) {
                                  value = propertyValue[k];
  
                                  if (typeof value == 'string') {
                                      data[propertyName][k] = Manager.get(value);
                                  }
                              }
                          }
                      }
                  }
              }
  
              continueFn.call(me, cls, data, hooks);
          });
  
          return false;
      }, true, 'after', 'className');
  
      
      Manager.registerPostprocessor('uses', function(name, cls, data) {
          var uses = data.uses;
          if (uses) {
              Loader.addUsedClasses(uses);
          }
      });
  
      Manager.onCreated(Loader.historyPush);
  };
  
  
  Ext.Error = Ext.extend(Error, {
      statics: {
          
          ignore: false,
  
          
          
  
          
          raise: function(err){
              err = err || {};
              if (Ext.isString(err)) {
                  err = { msg: err };
              }
  
              var method = this.raise.caller,
                  msg;
  
              if (method) {
                  if (method.$name) {
                      err.sourceMethod = method.$name;
                  }
                  if (method.$owner) {
                      err.sourceClass = method.$owner.$className;
                  }
              }
  
              if (Ext.Error.handle(err) !== true) {
                  msg = Ext.Error.prototype.toString.call(err);
  
                  Ext.log({
                      msg: msg,
                      level: 'error',
                      dump: err,
                      stack: true
                  });
  
                  throw new Ext.Error(err);
              }
          },
  
          
          handle: function(){
              return Ext.Error.ignore;
          }
      },
  
      
      name: 'Ext.Error',
  
      
      constructor: function(config){
          if (Ext.isString(config)) {
              config = { msg: config };
          }
  
          var me = this;
  
          Ext.apply(me, config);
  
          me.message = me.message || me.msg; 
          
      },
  
      
      toString: function(){
          var me = this,
              className = me.sourceClass ? me.sourceClass : '',
              methodName = me.sourceMethod ? '.' + me.sourceMethod + '(): ' : '',
              msg = me.msg || '(No description provided)';
  
          return className + methodName + msg;
      }
  });
  
  
  Ext.deprecated = function (suggestion) {
      return Ext.emptyFn;
  };
  
  
  
  
  
  Ext.JSON = (new(function() {
      var me = this,
      encodingFunction,
      decodingFunction,
      useNative = null,
      useHasOwn = !! {}.hasOwnProperty,
      isNative = function() {
          if (useNative === null) {
              useNative = Ext.USE_NATIVE_JSON && window.JSON && JSON.toString() == '[object JSON]';
          }
          return useNative;
      },
      pad = function(n) {
          return n < 10 ? "0" + n : n;
      },
      doDecode = function(json) {
          return eval("(" + json + ')');
      },
      doEncode = function(o, newline) {
          
          if (o === null || o === undefined) {
              return "null";
          } else if (Ext.isDate(o)) {
              return Ext.JSON.encodeDate(o);
          } else if (Ext.isString(o)) {
              return Ext.JSON.encodeString(o);
          } else if (typeof o == "number") {
              
              return isFinite(o) ? String(o) : "null";
          } else if (Ext.isBoolean(o)) {
              return String(o);
          }
          
          
          else if (o.toJSON) {
              return o.toJSON();
          } else if (Ext.isArray(o)) {
              return encodeArray(o, newline);
          } else if (Ext.isObject(o)) {
              return encodeObject(o, newline);
          } else if (typeof o === "function") {
              return "null";
          }
          return 'undefined';
      },
      m = {
          "\b": '\\b',
          "\t": '\\t',
          "\n": '\\n',
          "\f": '\\f',
          "\r": '\\r',
          '"': '\\"',
          "\\": '\\\\',
          '\x0b': '\\u000b' 
      },
      charToReplace = /[\\\"\x00-\x1f\x7f-\uffff]/g,
      encodeString = function(s) {
          return '"' + s.replace(charToReplace, function(a) {
              var c = m[a];
              return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
          }) + '"';
      },
  
  
      encodeArray = function(o, newline) {
  
          var a = ["[", ""], 
              len = o.length,
              i;
          for (i = 0; i < len; i += 1) {
              a.push(Ext.JSON.encodeValue(o[i]), ',');
          }
          
          a[a.length - 1] = ']';
          return a.join("");
      },
  
      encodeObject = function(o, newline) {
  
          var a = ["{", ""], 
              i;
          for (i in o) {
              if (!useHasOwn || o.hasOwnProperty(i)) {
                  a.push(Ext.JSON.encodeValue(i), ":", Ext.JSON.encodeValue(o[i]), ',');
              }
          }
          
          a[a.length - 1] = '}';
          return a.join("");
      };
      
      
      me.encodeString = encodeString;
  
      
      me.encodeValue = doEncode;
  
      
      me.encodeDate = function(o) {
          return '"' + o.getFullYear() + "-"
          + pad(o.getMonth() + 1) + "-"
          + pad(o.getDate()) + "T"
          + pad(o.getHours()) + ":"
          + pad(o.getMinutes()) + ":"
          + pad(o.getSeconds()) + '"';
      };
  
      
      me.encode = function(o) {
          if (!encodingFunction) {
              
              encodingFunction = isNative() ? JSON.stringify : me.encodeValue;
          }
          return encodingFunction(o);
      };
  
      
      me.decode = function(json, safe) {
          if (!decodingFunction) {
              
              decodingFunction = isNative() ? JSON.parse : doDecode;
          }
          try {
              return decodingFunction(json);
          } catch (e) {
              if (safe === true) {
                  return null;
              }
              Ext.Error.raise({
                  sourceClass: "Ext.JSON",
                  sourceMethod: "decode",
                  msg: "You're trying to decode an invalid JSON String: " + json
              });
          }
      };
  })());
  
  Ext.encode = Ext.JSON.encode;
  
  Ext.decode = Ext.JSON.decode;
  
  Ext.apply(Ext, {
      userAgent: navigator.userAgent.toLowerCase(),
      cache: {},
      idSeed: 1000,
      windowId: 'ext-window',
      documentId: 'ext-document',
  
      
      isReady: false,
  
      
      enableGarbageCollector: true,
  
      
      enableListenerCollection: true,
  
      addCacheEntry: function(id, el, dom) {
          dom = dom || el.dom;
  
  
          var key = id || (el && el.id) || dom.id,
              entry = Ext.cache[key] || (Ext.cache[key] = {
                  data: {},
                  events: {},
  
                  dom: dom,
  
                  
                  skipGarbageCollection: !!(dom.getElementById || dom.navigator)
              });
  
          if (el) {
              el.$cache = entry;
              
              
              entry.el = el;
          }
  
          return entry;
      },
      
      updateCacheEntry: function(cacheItem, dom){
          cacheItem.dom = dom;
          if (cacheItem.el) {
              cacheItem.el.dom = dom;
          }
          return cacheItem;
      },
  
      
      id: function(el, prefix) {
          var me = this,
              sandboxPrefix = '';
          el = Ext.getDom(el, true) || {};
          if (el === document) {
              el.id = me.documentId;
          }
          else if (el === window) {
              el.id = me.windowId;
          }
          if (!el.id) {
              if (me.isSandboxed) {
                  sandboxPrefix = Ext.sandboxName.toLowerCase() + '-';
              }
              el.id = sandboxPrefix + (prefix || "ext-gen") + (++Ext.idSeed);
          }
          return el.id;
      },
  
      escapeId: (function(){
          var validIdRe = /^[a-zA-Z_][a-zA-Z0-9_\-]*$/i,
              escapeRx = /([\W]{1})/g,
              leadingNumRx = /^(\d)/g,
              escapeFn = function(match, capture){
                  return "\\" + capture;
              },
              numEscapeFn = function(match, capture){
                  return '\\00' + capture.charCodeAt(0).toString(16) + ' ';
              };
  
          return function(id) {
              return validIdRe.test(id)
                  ? id
                  
                  
                  : id.replace(escapeRx, escapeFn)
                      .replace(leadingNumRx, numEscapeFn);
          };
      }()),
  
      
      getBody: (function() {
          var body;
          return function() {
              return body || (body = Ext.get(document.body));
          };
      }()),
  
      
      getHead: (function() {
          var head;
          return function() {
              return head || (head = Ext.get(document.getElementsByTagName("head")[0]));
          };
      }()),
  
      
      getDoc: (function() {
          var doc;
          return function() {
              return doc || (doc = Ext.get(document));
          };
      }()),
  
      
      getCmp: function(id) {
          return Ext.ComponentManager.get(id);
      },
  
      
      getOrientation: function() {
          return window.innerHeight > window.innerWidth ? 'portrait' : 'landscape';
      },
  
      
      destroy: function() {
          var ln = arguments.length,
          i, arg;
  
          for (i = 0; i < ln; i++) {
              arg = arguments[i];
              if (arg) {
                  if (Ext.isArray(arg)) {
                      this.destroy.apply(this, arg);
                  }
                  else if (Ext.isFunction(arg.destroy)) {
                      arg.destroy();
                  }
                  else if (arg.dom) {
                      arg.remove();
                  }
              }
          }
      },
  
      
      callback: function(callback, scope, args, delay){
          if(Ext.isFunction(callback)){
              args = args || [];
              scope = scope || window;
              if (delay) {
                  Ext.defer(callback, delay, scope, args);
              } else {
                  callback.apply(scope, args);
              }
          }
      },
  
      
      htmlEncode : function(value) {
          return Ext.String.htmlEncode(value);
      },
  
      
      htmlDecode : function(value) {
           return Ext.String.htmlDecode(value);
      },
  
      
      urlAppend : function(url, s) {
          return Ext.String.urlAppend(url, s);
      }
  });
  
  
  Ext.ns = Ext.namespace;
  
  
  window.undefined = window.undefined;
  
  
  (function(){
  
      var check = function(regex){
              return regex.test(Ext.userAgent);
          },
          isStrict = document.compatMode == "CSS1Compat",
          version = function (is, regex) {
              var m;
              return (is && (m = regex.exec(Ext.userAgent))) ? parseFloat(m[1]) : 0;
          },
          docMode = document.documentMode,
          isOpera = check(/opera/),
          isOpera10_5 = isOpera && check(/version\/10\.5/),
          isChrome = check(/\bchrome\b/),
          isWebKit = check(/webkit/),
          isSafari = !isChrome && check(/safari/),
          isSafari2 = isSafari && check(/applewebkit\/4/), 
          isSafari3 = isSafari && check(/version\/3/),
          isSafari4 = isSafari && check(/version\/4/),
          isSafari5_0 = isSafari && check(/version\/5\.0/),
          isSafari5 = isSafari && check(/version\/5/),
          isIE = !isOpera && check(/msie/),
          isIE7 = isIE && ((check(/msie 7/) && docMode != 8 && docMode != 9) || docMode == 7),
          isIE8 = isIE && ((check(/msie 8/) && docMode != 7 && docMode != 9) || docMode == 8),
          isIE9 = isIE && ((check(/msie 9/) && docMode != 7 && docMode != 8) || docMode == 9),
          isIE6 = isIE && check(/msie 6/),
          isGecko = !isWebKit && check(/gecko/),
          isGecko3 = isGecko && check(/rv:1\.9/),
          isGecko4 = isGecko && check(/rv:2\.0/),
          isGecko5 = isGecko && check(/rv:5\./),
          isGecko10 = isGecko && check(/rv:10\./),
          isFF3_0 = isGecko3 && check(/rv:1\.9\.0/),
          isFF3_5 = isGecko3 && check(/rv:1\.9\.1/),
          isFF3_6 = isGecko3 && check(/rv:1\.9\.2/),
          isWindows = check(/windows|win32/),
          isMac = check(/macintosh|mac os x/),
          isLinux = check(/linux/),
          scrollbarSize = null,
          chromeVersion = version(true, /\bchrome\/(\d+\.\d+)/),
          firefoxVersion = version(true, /\bfirefox\/(\d+\.\d+)/),
          ieVersion = version(isIE, /msie (\d+\.\d+)/),
          operaVersion = version(isOpera, /version\/(\d+\.\d+)/),
          safariVersion = version(isSafari, /version\/(\d+\.\d+)/),
          webKitVersion = version(isWebKit, /webkit\/(\d+\.\d+)/),
          isSecure = /^https/i.test(window.location.protocol),
          nullLog;
  
      
      try {
          document.execCommand("BackgroundImageCache", false, true);
      } catch(e) {}
  
  
  
      nullLog = function () {};
      nullLog.info = nullLog.warn = nullLog.error = Ext.emptyFn;
  
      Ext.setVersion('extjs', '4.1.1');
      Ext.apply(Ext, {
          
          SSL_SECURE_URL : isSecure && isIE ? 'javascript:\'\'' : 'about:blank',
  
          
  
          
          scopeResetCSS : Ext.buildSettings.scopeResetCSS,
          
          
          resetCls: Ext.buildSettings.baseCSSPrefix + 'reset',
  
          
          enableNestedListenerRemoval : false,
  
          
          USE_NATIVE_JSON : false,
  
          
          getDom : function(el, strict) {
              if (!el || !document) {
                  return null;
              }
              if (el.dom) {
                  return el.dom;
              } else {
                  if (typeof el == 'string') {
                      var e = Ext.getElementById(el);
                      
                      
                      if (e && isIE && strict) {
                          if (el == e.getAttribute('id')) {
                              return e;
                          } else {
                              return null;
                          }
                      }
                      return e;
                  } else {
                      return el;
                  }
              }
          },
  
          
          removeNode : isIE6 || isIE7 || isIE8
              ? (function() {
                  var d;
                  return function(n){
                      if(n && n.tagName.toUpperCase() != 'BODY'){
                          (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n) : Ext.EventManager.removeAll(n);
  
                          var cache = Ext.cache,
                              id = n.id;
  
                          if (cache[id]) {
                              delete cache[id].dom;
                              delete cache[id];
                          }
  
                          if (isIE8 && n.parentNode) {
                              n.parentNode.removeChild(n);
                          }
                          d = d || document.createElement('div');
                          d.appendChild(n);
                          d.innerHTML = '';
                      }
                  };
              }())
              : function(n) {
                  if (n && n.parentNode && n.tagName.toUpperCase() != 'BODY') {
                      (Ext.enableNestedListenerRemoval) ? Ext.EventManager.purgeElement(n) : Ext.EventManager.removeAll(n);
  
                      var cache = Ext.cache,
                          id = n.id;
  
                      if (cache[id]) {
                          delete cache[id].dom;
                          delete cache[id];
                      }
  
                      n.parentNode.removeChild(n);
                  }
              },
  
          isStrict: isStrict,
  
          isIEQuirks: isIE && !isStrict,
  
          
          isOpera : isOpera,
  
          
          isOpera10_5 : isOpera10_5,
  
          
          isWebKit : isWebKit,
  
          
          isChrome : isChrome,
  
          
          isSafari : isSafari,
  
          
          isSafari3 : isSafari3,
  
          
          isSafari4 : isSafari4,
  
          
          isSafari5 : isSafari5,
  
          
          isSafari5_0 : isSafari5_0,
  
  
          
          isSafari2 : isSafari2,
  
          
          isIE : isIE,
  
          
          isIE6 : isIE6,
  
          
          isIE7 : isIE7,
  
          
          isIE8 : isIE8,
  
          
          isIE9 : isIE9,
  
          
          isGecko : isGecko,
  
          
          isGecko3 : isGecko3,
  
          
          isGecko4 : isGecko4,
  
          
          isGecko5 : isGecko5,
  
          
          isGecko10 : isGecko10,
  
          
          isFF3_0 : isFF3_0,
  
          
          isFF3_5 : isFF3_5,
  
          
          isFF3_6 : isFF3_6,
  
          
          isFF4 : 4 <= firefoxVersion && firefoxVersion < 5,
  
          
          isFF5 : 5 <= firefoxVersion && firefoxVersion < 6,
  
          
          isFF10 : 10 <= firefoxVersion && firefoxVersion < 11,
  
          
          isLinux : isLinux,
  
          
          isWindows : isWindows,
  
          
          isMac : isMac,
  
          
          chromeVersion: chromeVersion,
  
          
          firefoxVersion: firefoxVersion,
  
          
          ieVersion: ieVersion,
  
          
          operaVersion: operaVersion,
  
          
          safariVersion: safariVersion,
  
          
          webKitVersion: webKitVersion,
  
          
          isSecure: isSecure,
          
          
          BLANK_IMAGE_URL : (isIE6 || isIE7) ? '/' + '/www.sencha.com/s.gif' : 'data:image/gif;base64,R0lGODlhAQABAID/AMDAwAAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==',
  
          
          value : function(v, defaultValue, allowBlank){
              return Ext.isEmpty(v, allowBlank) ? defaultValue : v;
          },
  
          
          escapeRe : function(s) {
              return s.replace(/([-.*+?\^${}()|\[\]\/\\])/g, "\\$1");
          },
  
          
          addBehaviors : function(o){
              if(!Ext.isReady){
                  Ext.onReady(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.select(s);
                          }
                          cache[s].on(parts[1], o[b]);
                      }
                  }
                  cache = null;
              }
          },
  
          
          getScrollbarSize: function (force) {
              if (!Ext.isReady) {
                  return {};
              }
  
              if (force || !scrollbarSize) {
                  var db = document.body,
                      div = document.createElement('div');
  
                  div.style.width = div.style.height = '100px';
                  div.style.overflow = 'scroll';
                  div.style.position = 'absolute';
  
                  db.appendChild(div); 
  
                  
                  scrollbarSize = {
                      width: div.offsetWidth - div.clientWidth,
                      height: div.offsetHeight - div.clientHeight
                  };
  
                  db.removeChild(div);
              }
  
              return scrollbarSize;
          },
  
          
          getScrollBarWidth: function(force){
              var size = Ext.getScrollbarSize(force);
              return size.width + 2; 
          },
  
          
          copyTo : function(dest, source, names, usePrototypeKeys){
              if(typeof names == 'string'){
                  names = names.split(/[,;\s]/);
              }
  
              var n,
                  nLen = names.length,
                  name;
  
              for(n = 0; n < nLen; n++) {
                  name = names[n];
  
                  if(usePrototypeKeys || source.hasOwnProperty(name)){
                      dest[name] = source[name];
                  }
              }
  
              return dest;
          },
  
          
          destroyMembers : function(o){
              for (var i = 1, a = arguments, len = a.length; i < len; i++) {
                  Ext.destroy(o[a[i]]);
                  delete o[a[i]];
              }
          },
  
          
          log :
              nullLog,
  
          
          partition : function(arr, truth){
              var ret = [[],[]],
                  a, v,
                  aLen = arr.length;
  
              for (a = 0; a < aLen; a++) {
                  v = arr[a];
                  ret[ (truth && truth(v, a, arr)) || (!truth && v) ? 0 : 1].push(v);
              }
  
              return ret;
          },
  
          
          invoke : function(arr, methodName){
              var ret  = [],
                  args = Array.prototype.slice.call(arguments, 2),
                  a, v,
                  aLen = arr.length;
  
              for (a = 0; a < aLen; a++) {
                  v = arr[a];
  
                  if (v && typeof v[methodName] == 'function') {
                      ret.push(v[methodName].apply(v, args));
                  } else {
                      ret.push(undefined);
                  }
              }
  
              return ret;
          },
  
          
          zip : function(){
              var parts = Ext.partition(arguments, function( val ){ return typeof val != 'function'; }),
                  arrs = parts[0],
                  fn = parts[1][0],
                  len = Ext.max(Ext.pluck(arrs, "length")),
                  ret = [],
                  i,
                  j,
                  aLen;
  
              for (i = 0; i < len; i++) {
                  ret[i] = [];
                  if(fn){
                      ret[i] = fn.apply(fn, Ext.pluck(arrs, i));
                  }else{
                      for (j = 0, aLen = arrs.length; j < aLen; j++){
                          ret[i].push( arrs[j][i] );
                      }
                  }
              }
              return ret;
          },
  
          
          toSentence: function(items, connector) {
              var length = items.length,
                  head,
                  tail;
  
              if (length <= 1) {
                  return items[0];
              } else {
                  head = items.slice(0, length - 1);
                  tail = items[length - 1];
  
                  return Ext.util.Format.format("{0} {1} {2}", head.join(", "), connector || 'and', tail);
              }
          },
  
          
          useShims: isIE6
      });
  }());
  
  
  Ext.application = function(config) {
      Ext.require('Ext.app.Application');
  
      Ext.onReady(function() {
          new Ext.app.Application(config);
      });
  };
  
  
  (function() {
      Ext.ns('Ext.util');
  
      Ext.util.Format = {};
      var UtilFormat     = Ext.util.Format,
          stripTagsRE    = /<\/?[^>]+>/gi,
          stripScriptsRe = /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
          nl2brRe        = /\r?\n/g,
  
          
          formatCleanRe  = /[^\d\.]/g,
  
          
          
          I18NFormatCleanRe;
  
      Ext.apply(UtilFormat, {
          
          
          thousandSeparator: ',',
          
  
          
          
          decimalSeparator: '.',
          
  
          
          
          currencyPrecision: 2,
          
  
           
          
          currencySign: '$',
          
  
          
          
          currencyAtEnd: false,
          
  
          
          undef : function(value) {
              return value !== undefined ? value : "";
          },
  
          
          defaultValue : function(value, defaultValue) {
              return value !== undefined && value !== '' ? value : defaultValue;
          },
  
          
          substr : 'ab'.substr(-1) != 'b'
          ? function (value, start, length) {
              var str = String(value);
              return (start < 0)
                  ? str.substr(Math.max(str.length + start, 0), length)
                  : str.substr(start, length);
          }
          : function(value, start, length) {
              return String(value).substr(start, length);
          },
  
          
          lowercase : function(value) {
              return String(value).toLowerCase();
          },
  
          
          uppercase : function(value) {
              return String(value).toUpperCase();
          },
  
          
          usMoney : function(v) {
              return UtilFormat.currency(v, '$', 2);
          },
  
          
          currency: function(v, currencySign, decimals, end) {
              var negativeSign = '',
                  format = ",0",
                  i = 0;
              v = v - 0;
              if (v < 0) {
                  v = -v;
                  negativeSign = '-';
              }
              decimals = Ext.isDefined(decimals) ? decimals : UtilFormat.currencyPrecision;
              format += format + (decimals > 0 ? '.' : '');
              for (; i < decimals; i++) {
                  format += '0';
              }
              v = UtilFormat.number(v, format);
              if ((end || UtilFormat.currencyAtEnd) === true) {
                  return Ext.String.format("{0}{1}{2}", negativeSign, v, currencySign || UtilFormat.currencySign);
              } else {
                  return Ext.String.format("{0}{1}{2}", negativeSign, currencySign || UtilFormat.currencySign, v);
              }
          },
  
          
          date: function(v, format) {
              if (!v) {
                  return "";
              }
              if (!Ext.isDate(v)) {
                  v = new Date(Date.parse(v));
              }
              return Ext.Date.dateFormat(v, format || Ext.Date.defaultFormat);
          },
  
          
          dateRenderer : function(format) {
              return function(v) {
                  return UtilFormat.date(v, format);
              };
          },
  
          
          stripTags : function(v) {
              return !v ? v : String(v).replace(stripTagsRE, "");
          },
  
          
          stripScripts : function(v) {
              return !v ? v : String(v).replace(stripScriptsRe, "");
          },
  
          
          fileSize : function(size) {
              if (size < 1024) {
                  return size + " bytes";
              } else if (size < 1048576) {
                  return (Math.round(((size*10) / 1024))/10) + " KB";
              } else {
                  return (Math.round(((size*10) / 1048576))/10) + " MB";
              }
          },
  
          
          math : (function(){
              var fns = {};
  
              return function(v, a){
                  if (!fns[a]) {
                      fns[a] = Ext.functionFactory('v', 'return v ' + a + ';');
                  }
                  return fns[a](v);
              };
          }()),
  
          
          round : function(value, precision) {
              var result = Number(value);
              if (typeof precision == 'number') {
                  precision = Math.pow(10, precision);
                  result = Math.round(value * precision) / precision;
              }
              return result;
          },
  
          
          number : function(v, formatString) {
              if (!formatString) {
                  return v;
              }
              v = Ext.Number.from(v, NaN);
              if (isNaN(v)) {
                  return '';
              }
              var comma = UtilFormat.thousandSeparator,
                  dec   = UtilFormat.decimalSeparator,
                  i18n  = false,
                  neg   = v < 0,
                  hasComma,
                  psplit,
                  fnum,
                  cnum,
                  parr,
                  j,
                  m,
                  n,
                  i;
  
              v = Math.abs(v);
  
              
              
              
              
              if (formatString.substr(formatString.length - 2) == '/i') {
                  if (!I18NFormatCleanRe) {
                      I18NFormatCleanRe = new RegExp('[^\\d\\' + UtilFormat.decimalSeparator + ']','g');
                  }
                  formatString = formatString.substr(0, formatString.length - 2);
                  i18n   = true;
                  hasComma = formatString.indexOf(comma) != -1;
                  psplit = formatString.replace(I18NFormatCleanRe, '').split(dec);
              } else {
                  hasComma = formatString.indexOf(',') != -1;
                  psplit = formatString.replace(formatCleanRe, '').split('.');
              }
  
              if (psplit.length > 2) {
              } else if (psplit.length > 1) {
                  v = Ext.Number.toFixed(v, psplit[1].length);
              } else {
                  v = Ext.Number.toFixed(v, 0);
              }
  
              fnum = v.toString();
  
              psplit = fnum.split('.');
  
              if (hasComma) {
                  cnum = psplit[0];
                  parr = [];
                  j = cnum.length;
                  m = Math.floor(j / 3);
                  n = cnum.length % 3 || 3;
  
                  for (i = 0; i < j; i += n) {
                      if (i !== 0) {
                          n = 3;
                      }
  
                      parr[parr.length] = cnum.substr(i, n);
                      m -= 1;
                  }
                  fnum = parr.join(comma);
                  if (psplit[1]) {
                      fnum += dec + psplit[1];
                  }
              } else {
                  if (psplit[1]) {
                      fnum = psplit[0] + dec + psplit[1];
                  }
              }
  
              if (neg) {
                  
                  neg = fnum.replace(/[^1-9]/g, '') !== '';
              }
  
              return (neg ? '-' : '') + formatString.replace(/[\d,?\.?]+/, fnum);
          },
  
          
          numberRenderer : function(format) {
              return function(v) {
                  return UtilFormat.number(v, format);
              };
          },
  
          
          plural : function(v, s, p) {
              return v +' ' + (v == 1 ? s : (p ? p : s+'s'));
          },
  
          
          nl2br : function(v) {
              return Ext.isEmpty(v) ? '' : v.replace(nl2brRe, '<br/>');
          },
  
          
          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");
          }
      });
  }());
  
  
  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;
  });
  
  
  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)',
                          '<tpl if="count">',
                              '<tpl if="childCount">',
                                  ' ({childCount} children)',
                              '</tpl>',
                              '<tpl if="depth - 1">',
                                  ' ({depth} deep)',
                              '</tpl>',
                              '<tpl for="times">',
                                  ', {type}: {[this.time(values.sum)]} msec (',
                                       
                                       'avg={[this.time(values.sum / parent.count)]}',
                                       
                                       ')',
                              '</tpl>',
                          '</tpl>'
                      ].join(''), {
                          time: function (t) {
                              return Math.round(t * 100) / 100;
                          }
                      });
              }
  
              var data = this.getData(calibration);
              data.name = this.name;
              data.pure.type = 'Pure';
              data.total.type = 'Total';
              data.times = [data.pure, data.total];
              return formatTpl.apply(data);
          },
  
          getData: function (calibration) {
              var me = this;
  
              return {
                  count: me.count,
                  childCount: me.childCount,
                  depth: me.maxDepth,
                  pure: setToJSON(me.count, me.childCount, calibration, me.pure),
                  total: setToJSON(me.count, me.childCount, calibration, me.total)
              };
          },
  
          enter: function () {
              var me = this,
                  frame = {
                      accum: me,
                      leave: leaveFrame,
                      childTime: 0,
                      parent: currentFrame
                  };
  
              ++me.depth;
              if (me.maxDepth < me.depth) {
                  me.maxDepth = me.depth;
              }
  
              currentFrame = frame;
              frame.time = getTimestamp(); 
              return frame;
          },
  
          monitor: function (fn, scope, args) {
              var frame = this.enter();
              if (args) {
                  fn.apply(scope, args);
              } else {
                  fn.call(scope);
              }
              frame.leave();
          },
  
          report: function () {
              Ext.log(this.format());
          },
  
          tap: function (className, methodName) {
              var me = this,
                  methods = typeof methodName == 'string' ? [methodName] : methodName,
                  klass, statik, i, parts, length, name, src,
                  tapFunc;
  
              tapFunc = function(){
                  if (typeof className == 'string') {
                      klass = Ext.global;
                      parts = className.split('.');
                      for (i = 0, length = parts.length; i < length; ++i) {
                          klass = klass[parts[i]];
                      }
                  } else {
                      klass = className;
                  }
  
                  for (i = 0, length = methods.length; i < length; ++i) {
                      name = methods[i];
                      statik = name.charAt(0) == '!';
  
                      if (statik) {
                          name = name.substring(1);
                      } else {
                          statik = !(name in klass.prototype);
                      }
  
                      src = statik ? klass : klass.prototype;
                      src[name] = makeTap(me, src[name]);
                  }
              };
  
              Ext.ClassManager.onCreated(tapFunc, me, className);
  
              return me;
          }
      };
  }()),
  
  function () {
      Ext.perf.getTimestamp = this.getTimestamp;
  });
  
  
  Ext.define('Ext.perf.Monitor', {
      singleton: true,
      alternateClassName: 'Ext.Perf',
  
      requires: [
          'Ext.perf.Accumulator'
      ],
  
      constructor: function () {
          this.accumulators = [];
          this.accumulatorsByName = {};
      },
  
      calibrate: function () {
          var accum = new Ext.perf.Accumulator('$'),
              total = accum.total,
              getTimestamp = Ext.perf.Accumulator.getTimestamp,
              count = 0,
              frame,
              endTime,
              startTime;
  
          startTime = getTimestamp();
  
          do {
              frame = accum.enter();
              frame.leave();
              ++count;
          } while (total.sum < 100);
  
          endTime = getTimestamp();
  
          return (endTime - startTime) / count;
      },
  
      get: function (name) {
          var me = this,
              accum = me.accumulatorsByName[name];
  
          if (!accum) {
              me.accumulatorsByName[name] = accum = new Ext.perf.Accumulator(name);
              me.accumulators.push(accum);
          }
  
          return accum;
      },
  
      enter: function (name) {
          return this.get(name).enter();
      },
  
      monitor: function (name, fn, scope) {
          this.get(name).monitor(fn, scope);
      },
  
      report: function () {
          var me = this,
              accumulators = me.accumulators,
              calibration = me.calibrate();
  
          accumulators.sort(function (a, b) {
              return (a.name < b.name) ? -1 : ((b.name < a.name) ? 1 : 0);
          });
  
          me.updateGC();
  
          Ext.log('Calibration: ' + Math.round(calibration * 100) / 100 + ' msec/sample');
          Ext.each(accumulators, function (accum) {
              Ext.log(accum.format(calibration));
          });
      },
  
      getData: function (all) {
          var ret = {},
              accumulators = this.accumulators;
  
          Ext.each(accumulators, function (accum) {
              if (all || accum.count) {
                  ret[accum.name] = accum.getData();
              }
          });
  
          return ret;
      },
  
      reset: function(){
          Ext.each(this.accumulators, function(accum){
              var me = accum;
              me.count = me.childCount = me.depth = me.maxDepth = 0;
              me.pure = {
                  min: Number.MAX_VALUE,
                  max: 0,
                  sum: 0
              };
              me.total = {
                  min: Number.MAX_VALUE,
                  max: 0,
                  sum: 0
              };
          });
      },
  
      updateGC: function () {
          var accumGC = this.accumulatorsByName.GC,
              toolbox = Ext.senchaToolbox,
              bucket;
  
          if (accumGC) {
              accumGC.count = toolbox.garbageCollectionCounter || 0;
  
              if (accumGC.count) {
                  bucket = accumGC.pure;
                  accumGC.total.sum = bucket.sum = toolbox.garbageCollectionMilliseconds;
                  bucket.min = bucket.max = bucket.sum / accumGC.count;
                  bucket = accumGC.total;
                  bucket.min = bucket.max = bucket.sum / accumGC.count;
              }
          }
      },
  
      watchGC: function () {
          Ext.perf.getTimestamp(); 
  
          var toolbox = Ext.senchaToolbox;
  
          if (toolbox) {
              this.get("GC");
              toolbox.watchGarbageCollector(false); 
          }
      },
  
      setup: function (config) {
          if (!config) {
              config = {
                  
                  
  
  
  
  
  
  
                  render: {
                      'Ext.AbstractComponent': 'render'
                  },
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
                  layout: {
                      'Ext.layout.Context': 'run'
                  }
              };
          }
  
          this.currentConfig = config;
  
          var key, prop,
              accum, className, methods;
          for (key in config) {
              if (config.hasOwnProperty(key)) {
                  prop = config[key];
                  accum = Ext.Perf.get(key);
  
                  for (className in prop) {
                      if (prop.hasOwnProperty(className)) {
                          methods = prop[className];
                          accum.tap(className, methods);
                      }
                  }
              }
          }
  
          this.watchGC();
      }
  });
  
  
  Ext.is = {
      init : function(navigator) {
          var platforms = this.platforms,
              ln = platforms.length,
              i, platform;
  
          navigator = navigator || window.navigator;
  
          for (i = 0; i < ln; i++) {
              platform = platforms[i];
              this[platform.identity] = platform.regex.test(navigator[platform.property]);
          }
  
          
          this.Desktop = this.Mac || this.Windows || (this.Linux && !this.Android);
          
          this.Tablet = this.iPad;
          
          this.Phone = !this.Desktop && !this.Tablet;
          
          this.iOS = this.iPhone || this.iPad || this.iPod;
          
          
          this.Standalone = !!window.navigator.standalone;
      },
      
      
      platforms: [{
          property: 'platform',
          regex: /iPhone/i,
          identity: 'iPhone'
      },
      
      
      {
          property: 'platform',
          regex: /iPod/i,
          identity: 'iPod'
      },
      
      
      {
          property: 'userAgent',
          regex: /iPad/i,
          identity: 'iPad'
      },
      
      
      {
          property: 'userAgent',
          regex: /Blackberry/i,
          identity: 'Blackberry'
      },
      
      
      {
          property: 'userAgent',
          regex: /Android/i,
          identity: 'Android'
      },
      
      
      {
          property: 'platform',
          regex: /Mac/i,
          identity: 'Mac'
      },
      
      
      {
          property: 'platform',
          regex: /Win/i,
          identity: 'Windows'
      },
      
      
      {
          property: 'platform',
          regex: /Linux/i,
          identity: 'Linux'
      }]
  };
  
  Ext.is.init();
  
  
  (function(){
  
      
      
      
      var getStyle = function(element, styleName){
          var view = element.ownerDocument.defaultView,
              style = (view ? view.getComputedStyle(element, null) : element.currentStyle) || element.style;
          return style[styleName];
      };
  
  Ext.supports = {
      
      init : function() {
          var me = this,
              doc = document,
              tests = me.tests,
              n = tests.length,
              div = n && Ext.isReady && doc.createElement('div'),
              test, notRun = [];
  
          if (div) {
              div.innerHTML = [
                  '<div style="height:30px;width:50px;">',
                      '<div style="height:20px;width:20px;"></div>',
                  '</div>',
                  '<div style="width: 200px; height: 200px; position: relative; padding: 5px;">',
                      '<div style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"></div>',
                  '</div>',
                  '<div style="position: absolute; left: 10%; top: 10%;"></div>',
                  '<div style="float:left; background-color:transparent;"></div>'
              ].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 = "<!--[if vml]><br/><br/><![endif]-->";
                  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(); 
  
  
  
  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;
          }
      };
  };
  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.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);
  };
  
  
  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();
  
  });
  
  
  
  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;
      }
  
  });
  
  
  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] = '</' + 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;
      }
  
  });
  
  
  (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));
  });
  
  }());
  
  
  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);
          }
      });
  }());
  
  
  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;
      }
  
  });
  
  
  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;
      }
  });
  
  
  (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
              };
          }
      }
  });
  
  }());
  
  
  (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 ? ('<div class="' + (msgCls || (prefix + 'mask-message')) + '">' + msg + '</div>') : ''
              });
  
              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
                  };
              }
          }
      });
  }());
  
  
  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);
      }
  });
  
  
  (function() {
  
  
  var afterbegin = 'afterbegin',
      afterend = 'afterend',
      beforebegin = 'beforebegin',
      beforeend = 'beforeend',
      ts = '<table>',
      te = '</table>',
      tbs = ts+'<tbody>',
      tbe = '</tbody>'+te,
      trs = tbs + '<tr>',
      tre = '</tr>'+tbe,
      detachedDiv = document.createElement('div'),
      bbValues = ['BeforeBegin', 'previousSibling'],
      aeValues = ['AfterEnd', 'nextSibling'],
      bb_ae_PositionHash = {
          beforebegin: bbValues,
          afterend: aeValues
      },
      fullPositionHash = {
          beforebegin: bbValues,
          afterend: aeValues,
          afterbegin: ['AfterBegin', 'firstChild'],
          beforeend: ['BeforeEnd', 'lastChild']
      };
  
  
  Ext.define('Ext.dom.Helper', {
      extend: 'Ext.dom.AbstractHelper',
  
      tableRe: /^table|tbody|tr|td$/i,
  
      tableElRe: /td|tr|tbody/i,
  
      
      useDom : false,
  
      
      createDom: function(o, parentNode){
          var el,
              doc = document,
              useSet,
              attr,
              val,
              cn,
              i, l;
  
          if (Ext.isArray(o)) {                       
              el = doc.createDocumentFragment(); 
              for (i = 0, l = o.length; i < l; i++) {
                  this.createDom(o[i], el);
              }
          } else if (typeof o == 'string') {         
              el = doc.createTextNode(o);
          } else {
              el = doc.createElement(o.tag || 'div');
              useSet = !!el.setAttribute; 
              for (attr in o) {
                  if (!this.confRe.test(attr)) {
                      val = o[attr];
                      if (attr == 'cls') {
                          el.className = val;
                      } else {
                          if (useSet) {
                              el.setAttribute(attr, val);
                          } else {
                              el[attr] = val;
                          }
                      }
                  }
              }
              Ext.DomHelper.applyStyles(el, o.style);
  
              if ((cn = o.children || o.cn)) {
                  this.createDom(cn, el);
              } else if (o.html) {
                  el.innerHTML = o.html;
              }
          }
          if (parentNode) {
              parentNode.appendChild(el);
          }
          return el;
      },
  
      ieTable: function(depth, openingTags, htmlContent, closingTags){
          detachedDiv.innerHTML = [openingTags, htmlContent, closingTags].join('');
  
          var i = -1,
              el = detachedDiv,
              ns;
  
          while (++i < depth) {
              el = el.firstChild;
          }
          
          ns = el.nextSibling;
  
          if (ns) {
              el = document.createDocumentFragment();
              while (ns) {
                  el.appendChild(ns);
                  ns = ns.nextSibling;
              }
          }
          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) || !this.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' && (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;
      },
  
      
      createContextualFragment: function(html) {
          var fragment = document.createDocumentFragment(),
              length, childNodes;
  
          detachedDiv.innerHTML = html;
          childNodes = detachedDiv.childNodes;
          length = childNodes.length;
  
          
          while (length--) {
              fragment.appendChild(childNodes[0]);
          }
          return fragment;
      },
  
      applyStyles: function(el, styles) {
          if (styles) {
              el = Ext.fly(el);
              if (typeof styles == "function") {
                  styles = styles.call();
              }
              if (typeof styles == "string") {
                  styles = Ext.dom.Element.parseStyles(styles);
              }
              if (typeof styles == "object") {
                  el.setStyle(styles);
              }
          }
      },
  
      
      createHtml: function(spec) {
          return this.markup(spec);
      },
  
      doInsert: function(el, o, returnElement, pos, sibling, append) {
          
          el = el.dom || Ext.getDom(el);
  
          var newNode;
  
          if (this.useDom) {
              newNode = this.createDom(o, null);
  
              if (append) {
                  el.appendChild(newNode);
              }
              else {
                  (sibling == 'firstChild' ? el : el.parentNode).insertBefore(newNode, el[sibling] || el);
              }
  
          } else {
              newNode = this.insertHtml(pos, el, this.markup(o));
          }
          return returnElement ? Ext.get(newNode, true) : newNode;
      },
  
      
      overwrite: function(el, html, returnElement) {
          var newNode;
  
          el = Ext.getDom(el);
          html = this.markup(html);
  
          
          if (Ext.isIE && this.tableRe.test(el.tagName)) {
              
              while (el.firstChild) {
                  el.removeChild(el.firstChild);
              }
              if (html) {
                  newNode = this.insertHtml('afterbegin', el, html);
                  return returnElement ? Ext.get(newNode) : newNode;
              }
              return null;
          }
          el.innerHTML = html;
          return returnElement ? Ext.get(el.firstChild) : el.firstChild;
      },
  
      insertHtml: function(where, el, html) {
          var hashVal,
              range,
              rangeEl,
              setStart,
              frag;
  
          where = where.toLowerCase();
  
          
          if (el.insertAdjacentHTML) {
  
              
              if (Ext.isIE && this.tableRe.test(el.tagName) && (frag = this.insertIntoTable(el.tagName.toLowerCase(), where, el, html))) {
                  return frag;
              }
  
              if ((hashVal = fullPositionHash[where])) {
                  el.insertAdjacentHTML(hashVal[0], html);
                  return el[hashVal[1]];
              }
              
          } else {
              
              if (el.nodeType === 3) {
                  where = where === 'afterbegin' ? 'beforebegin' : where;
                  where = where === 'beforeend' ? 'afterend' : where;
              }
              range = Ext.supports.CreateContextualFragment ? el.ownerDocument.createRange() : undefined;
              setStart = 'setStart' + (this.endRe.test(where) ? 'After' : 'Before');
              if (bb_ae_PositionHash[where]) {
                  if (range) {
                      range[setStart](el);
                      frag = range.createContextualFragment(html);
                  } else {
                      frag = this.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) {
                      if (range) {
                          range[setStart](el[rangeEl]);
                          frag = range.createContextualFragment(html);
                      } else {
                          frag = this.createContextualFragment(html);
                      }
  
                      if (where == afterbegin) {
                          el.insertBefore(frag, el.firstChild);
                      } else {
                          el.appendChild(frag);
                      }
                  } else {
                      el.innerHTML = html;
                  }
                  return el[rangeEl];
              }
          }
      },
  
      
      createTemplate: function(o) {
          var html = this.markup(o);
          return new Ext.Template(html);
      }
  
  }, function() {
      Ext.ns('Ext.core');
      Ext.DomHelper = Ext.core.DomHelper = new this;
  });
  
  
  }());
  
  
  
  Ext.ns('Ext.core');
  
  Ext.dom.Query = Ext.core.DomQuery = Ext.DomQuery = (function(){
      var cache = {},
          simpleCache = {},
          valueCache = {},
          nonSpace = /\S/,
          trimRe = /^\s+|\s+$/g,
          tplRe = /\{(\d+)\}/g,
          modeRe = /^(\s?[\/>+~]\s?|\s|$)/,
          tagTokenRe = /^(#)?([\w\-\*\\]+)/,
          nthRe = /(\d*)n\+?(\d*)/,
          nthRe2 = /\D/,
          startIdRe = /^\s*\#/,
          
          
          
          isIE = window.ActiveXObject ? true : false,
          key = 30803,
          longHex = /\\([0-9a-fA-F]{6})/g,
          shortHex = /\\([0-9a-fA-F]{1,6})\s{0,1}/g,
          nonHex = /\\([^0-9a-fA-F]{1})/g,
          escapes = /\\/g,
          num, hasEscapes,
  
          
          
          longHexToChar = function($0, $1) {
              return String.fromCharCode(parseInt($1, 16));
          },
  
          
          shortToLongHex = function($0, $1) {
              while ($1.length < 6) {
                  $1 = '0' + $1;
              }
              return '\\' + $1;
          },
  
          
          charToLongHex = function($0, $1) {
              num = $1.charCodeAt(0).toString(16);
              if (num.length === 1) {
                  num = '0' + num;
              }
              return '\\0000' + num;
          },
  
          
          
          
          unescapeCssSelector = function (selector) {
              return (hasEscapes)
                  ? selector.replace(longHex, longHexToChar)
                  : selector;
          },
          
          
          setupEscapes = function(path){
              hasEscapes = (path.indexOf('\\') > -1);
              if (hasEscapes) {
                  path = path
                      .replace(shortHex, shortToLongHex)
                      .replace(nonHex, charToLongHex)
                      .replace(escapes, '\\\\');  
              }
              return path;
          };
  
      
      
      eval("var batch = 30803;");
  
      
      
      function child(parent, index){
          var i = 0,
              n = parent.firstChild;
          while(n){
              if(n.nodeType == 1){
                 if(++i == index){
                     return n;
                 }
              }
              n = n.nextSibling;
          }
          return null;
      }
  
      
      function next(n){
          while((n = n.nextSibling) && n.nodeType != 1);
          return n;
      }
  
      
      function prev(n){
          while((n = n.previousSibling) && n.nodeType != 1);
          return n;
      }
  
      
      
      function children(parent){
          var n = parent.firstChild,
          nodeIndex = -1,
          nextNode;
          while(n){
              nextNode = n.nextSibling;
              
              if(n.nodeType == 3 && !nonSpace.test(n.nodeValue)){
                  parent.removeChild(n);
              }else{
                  
                  n.nodeIndex = ++nodeIndex;
              }
              n = nextNode;
          }
          return this;
      }
  
      
      
      function byClassName(nodeSet, cls){
          cls = unescapeCssSelector(cls);
          if(!cls){
              return nodeSet;
          }
          var result = [], ri = -1,
              i, ci;
          for(i = 0, ci; ci = nodeSet[i]; i++){
              if((' '+ci.className+' ').indexOf(cls) != -1){
                  result[++ri] = ci;
              }
          }
          return result;
      }
  
      function attrValue(n, attr){
          
          if(!n.tagName && typeof n.length != "undefined"){
              n = n[0];
          }
          if(!n){
              return null;
          }
  
          if(attr == "for"){
              return n.htmlFor;
          }
          if(attr == "class" || attr == "className"){
              return n.className;
          }
          return n.getAttribute(attr) || n[attr];
  
      }
  
  
      
      
      
      function getNodes(ns, mode, tagName){
          var result = [], ri = -1, cs,
              i, ni, j, ci, cn, utag, n, cj;
          if(!ns){
              return result;
          }
          tagName = tagName || "*";
          
          if(typeof ns.getElementsByTagName != "undefined"){
              ns = [ns];
          }
  
          
          
          if(!mode){
              for(i = 0, ni; ni = ns[i]; i++){
                  cs = ni.getElementsByTagName(tagName);
                  for(j = 0, ci; ci = cs[j]; j++){
                      result[++ri] = ci;
                  }
              }
          
          
          } else if(mode == "/" || mode == ">"){
              utag = tagName.toUpperCase();
              for(i = 0, ni, cn; ni = ns[i]; i++){
                  cn = ni.childNodes;
                  for(j = 0, cj; cj = cn[j]; j++){
                      if(cj.nodeName == utag || cj.nodeName == tagName  || tagName == '*'){
                          result[++ri] = cj;
                      }
                  }
              }
          
          
          }else if(mode == "+"){
              utag = tagName.toUpperCase();
              for(i = 0, n; n = ns[i]; i++){
                  while((n = n.nextSibling) && n.nodeType != 1);
                  if(n && (n.nodeName == utag || n.nodeName == tagName || tagName == '*')){
                      result[++ri] = n;
                  }
              }
          
          
          }else if(mode == "~"){
              utag = tagName.toUpperCase();
              for(i = 0, n; n = ns[i]; i++){
                  while((n = n.nextSibling)){
                      if (n.nodeName == utag || n.nodeName == tagName || tagName == '*'){
                          result[++ri] = n;
                      }
                  }
              }
          }
          return result;
      }
  
      function concat(a, b){
          if(b.slice){
              return a.concat(b);
          }
          for(var i = 0, l = b.length; i < l; i++){
              a[a.length] = b[i];
          }
          return a;
      }
  
      function byTag(cs, tagName){
          if(cs.tagName || cs == document){
              cs = [cs];
          }
          if(!tagName){
              return cs;
          }
          var result = [], ri = -1,
              i, ci;
          tagName = tagName.toLowerCase();
          for(i = 0, ci; ci = cs[i]; i++){
              if(ci.nodeType == 1 && ci.tagName.toLowerCase() == tagName){
                  result[++ri] = ci;
              }
          }
          return result;
      }
  
      function byId(cs, id){
          id = unescapeCssSelector(id);
          if(cs.tagName || cs == document){
              cs = [cs];
          }
          if(!id){
              return cs;
          }
          var result = [], ri = -1,
              i, ci;
          for(i = 0, ci; ci = cs[i]; i++){
              if(ci && ci.id == id){
                  result[++ri] = ci;
                  return result;
              }
          }
          return result;
      }
  
      
      
      function byAttribute(cs, attr, value, op, custom){
          var result = [],
              ri = -1,
              useGetStyle = custom == "{",
              fn = Ext.DomQuery.operators[op],
              a,
              xml,
              hasXml,
              i, ci;
  
          value = unescapeCssSelector(value);
  
          for(i = 0, ci; ci = cs[i]; i++){
              
              if(ci.nodeType != 1){
                  continue;
              }
              
              if(!hasXml){
                  xml = Ext.DomQuery.isXml(ci);
                  hasXml = true;
              }
  
              
              if(!xml){
                  if(useGetStyle){
                      a = Ext.DomQuery.getStyle(ci, attr);
                  } else if (attr == "class" || attr == "className"){
                      a = ci.className;
                  } else if (attr == "for"){
                      a = ci.htmlFor;
                  } else if (attr == "href"){
                      
                      
                      a = ci.getAttribute("href", 2);
                  } else{
                      a = ci.getAttribute(attr);
                  }
              }else{
                  a = ci.getAttribute(attr);
              }
              if((fn && fn(a, value)) || (!fn && a)){
                  result[++ri] = ci;
              }
          }
          return result;
      }
  
      function byPseudo(cs, name, value){
          value = unescapeCssSelector(value);
          return Ext.DomQuery.pseudos[name](cs, value);
      }
  
      function nodupIEXml(cs){
          var d = ++key,
              r,
              i, len, c;
          cs[0].setAttribute("_nodup", d);
          r = [cs[0]];
          for(i = 1, len = cs.length; i < len; i++){
              c = cs[i];
              if(!c.getAttribute("_nodup") != d){
                  c.setAttribute("_nodup", d);
                  r[r.length] = c;
              }
          }
          for(i = 0, len = cs.length; i < len; i++){
              cs[i].removeAttribute("_nodup");
          }
          return r;
      }
  
      function nodup(cs){
          if(!cs){
              return [];
          }
          var len = cs.length, c, i, r = cs, cj, ri = -1, d, j;
          if(!len || typeof cs.nodeType != "undefined" || len == 1){
              return cs;
          }
          if(isIE && typeof cs[0].selectSingleNode != "undefined"){
              return nodupIEXml(cs);
          }
          d = ++key;
          cs[0]._nodup = d;
          for(i = 1; c = cs[i]; i++){
              if(c._nodup != d){
                  c._nodup = d;
              }else{
                  r = [];
                  for(j = 0; j < i; j++){
                      r[++ri] = cs[j];
                  }
                  for(j = i+1; cj = cs[j]; j++){
                      if(cj._nodup != d){
                          cj._nodup = d;
                          r[++ri] = cj;
                      }
                  }
                  return r;
              }
          }
          return r;
      }
  
      function quickDiffIEXml(c1, c2){
          var d = ++key,
              r = [],
              i, len;
          for(i = 0, len = c1.length; i < len; i++){
              c1[i].setAttribute("_qdiff", d);
          }
          for(i = 0, len = c2.length; i < len; i++){
              if(c2[i].getAttribute("_qdiff") != d){
                  r[r.length] = c2[i];
              }
          }
          for(i = 0, len = c1.length; i < len; i++){
             c1[i].removeAttribute("_qdiff");
          }
          return r;
      }
  
      function quickDiff(c1, c2){
          var len1 = c1.length,
              d = ++key,
              r = [],
              i, len;
          if(!len1){
              return c2;
          }
          if(isIE && typeof c1[0].selectSingleNode != "undefined"){
              return quickDiffIEXml(c1, c2);
          }
          for(i = 0; i < len1; i++){
              c1[i]._qdiff = d;
          }
          for(i = 0, len = c2.length; i < len; i++){
              if(c2[i]._qdiff != d){
                  r[r.length] = c2[i];
              }
          }
          return r;
      }
  
      function quickId(ns, mode, root, id){
          if(ns == root){
              id = unescapeCssSelector(id);
              var d = root.ownerDocument || root;
              return d.getElementById(id);
          }
          ns = getNodes(ns, mode, "*");
          return byId(ns, id);
      }
  
      return {
          getStyle : function(el, name){
              return Ext.fly(el).getStyle(name);
          },
          
          compile : function(path, type){
              type = type || "select";
  
              
              var fn = ["var f = function(root){\n var mode; ++batch; var n = root || document;\n"],
                  mode,
                  lastPath,
                  matchers = Ext.DomQuery.matchers,
                  matchersLn = matchers.length,
                  modeMatch,
                  
                  lmode = path.match(modeRe),
                  tokenMatch, matched, j, t, m;
  
              path = setupEscapes(path);
  
              if(lmode && lmode[1]){
                  fn[fn.length] = 'mode="'+lmode[1].replace(trimRe, "")+'";';
                  path = path.replace(lmode[1], "");
              }
  
              
              while(path.substr(0, 1)=="/"){
                  path = path.substr(1);
              }
  
              while(path && lastPath != path){
                  lastPath = path;
                  tokenMatch = path.match(tagTokenRe);
                  if(type == "select"){
                      if(tokenMatch){
                          
                          if(tokenMatch[1] == "#"){
                              fn[fn.length] = 'n = quickId(n, mode, root, "'+tokenMatch[2]+'");';
                          }else{
                              fn[fn.length] = 'n = getNodes(n, mode, "'+tokenMatch[2]+'");';
                          }
                          path = path.replace(tokenMatch[0], "");
                      }else if(path.substr(0, 1) != '@'){
                          fn[fn.length] = 'n = getNodes(n, mode, "*");';
                      }
                  
                  }else{
                      if(tokenMatch){
                          if(tokenMatch[1] == "#"){
                              fn[fn.length] = 'n = byId(n, "'+tokenMatch[2]+'");';
                          }else{
                              fn[fn.length] = 'n = byTag(n, "'+tokenMatch[2]+'");';
                          }
                          path = path.replace(tokenMatch[0], "");
                      }
                  }
                  while(!(modeMatch = path.match(modeRe))){
                      matched = false;
                      for(j = 0; j < matchersLn; j++){
                          t = matchers[j];
                          m = path.match(t.re);
                          if(m){
                              fn[fn.length] = t.select.replace(tplRe, function(x, i){
                                  return m[i];
                              });
                              path = path.replace(m[0], "");
                              matched = true;
                              break;
                          }
                      }
                      
                      if(!matched){
                          Ext.Error.raise({
                              sourceClass: 'Ext.DomQuery',
                              sourceMethod: 'compile',
                              msg: 'Error parsing selector. Parsing failed at "' + path + '"'
                          });
                      }
                  }
                  if(modeMatch[1]){
                      fn[fn.length] = 'mode="'+modeMatch[1].replace(trimRe, "")+'";';
                      path = path.replace(modeMatch[1], "");
                  }
              }
              
              fn[fn.length] = "return nodup(n);\n}";
  
              
              eval(fn.join(""));
              return f;
          },
  
          
          jsSelect: function(path, root, type){
              
              root = root || document;
  
              if(typeof root == "string"){
                  root = document.getElementById(root);
              }
              var paths = path.split(","),
                  results = [],
                  i, len, subPath, result;
  
              
              for(i = 0, len = paths.length; i < len; i++){
                  subPath = paths[i].replace(trimRe, "");
                  
                  if(!cache[subPath]){
                      
                      cache[subPath] = Ext.DomQuery.compile(subPath, type);
                      if(!cache[subPath]){
                          Ext.Error.raise({
                              sourceClass: 'Ext.DomQuery',
                              sourceMethod: 'jsSelect',
                              msg: subPath + ' is not a valid selector'
                          });
                      }
                  } else {
                      
                      
                      setupEscapes(subPath);
                  }
                  result = cache[subPath](root);
                  if(result && result != document){
                      results = results.concat(result);
                  }
              }
  
              
              
              if(paths.length > 1){
                  return nodup(results);
              }
              return results;
          },
  
          isXml: function(el) {
              var docEl = (el ? el.ownerDocument || el : 0).documentElement;
              return docEl ? docEl.nodeName !== "HTML" : false;
          },
  
          
          select : document.querySelectorAll ? function(path, root, type) {
              root = root || document;
              if (!Ext.DomQuery.isXml(root)) {
                  try {
                      
                      if (root.parentNode && (root.nodeType !== 9) && path.indexOf(',') === -1 && !startIdRe.test(path)) {
                          path = '#' + Ext.escapeId(Ext.id(root)) + ' ' + path;
                          root = root.parentNode;
                      }
                      return Ext.Array.toArray(root.querySelectorAll(path));
                  }
                  catch (e) {
                  }
              }
              return Ext.DomQuery.jsSelect.call(this, path, root, type);
          } : function(path, root, type) {
              return Ext.DomQuery.jsSelect.call(this, path, root, type);
          },
  
          
          selectNode : function(path, root){
              return Ext.DomQuery.select(path, root)[0];
          },
  
          
          selectValue : function(path, root, defaultValue){
              path = path.replace(trimRe, "");
              if (!valueCache[path]) {
                  valueCache[path] = Ext.DomQuery.compile(path, "select");
              } else {
                  setupEscapes(path);
              }
              
              var n = valueCache[path](root), 
                  v;
                  
              n = n[0] ? n[0] : n;
  
              
              
              
              
              if (typeof n.normalize == 'function') {
                  n.normalize();
              }
  
              v = (n && n.firstChild ? n.firstChild.nodeValue : null);
              return ((v === null||v === undefined||v==='') ? defaultValue : v);
          },
  
          
          selectNumber : function(path, root, defaultValue){
              var v = Ext.DomQuery.selectValue(path, root, defaultValue || 0);
              return parseFloat(v);
          },
  
          
          is : function(el, ss){
              if(typeof el == "string"){
                  el = document.getElementById(el);
              }
              var isArray = Ext.isArray(el),
                  result = Ext.DomQuery.filter(isArray ? el : [el], ss);
              return isArray ? (result.length == el.length) : (result.length > 0);
          },
  
          
          filter : function(els, ss, nonMatches){
              ss = ss.replace(trimRe, "");
              if (!simpleCache[ss]) {
                  simpleCache[ss] = Ext.DomQuery.compile(ss, "simple");
              } else {
                  setupEscapes(ss);
              }
              
              var result = simpleCache[ss](els);
              return nonMatches ? quickDiff(result, els) : result;
          },
  
          
          matchers : [{
                  re: /^\.([\w\-\\]+)/,
                  select: 'n = byClassName(n, " {1} ");'
              }, {
                  re: /^\:([\w\-]+)(?:\(((?:[^\s>\/]*|.*?))\))?/,
                  select: 'n = byPseudo(n, "{1}", "{2}");'
              },{
                  re: /^(?:([\[\{])(?:@)?([\w\-]+)\s?(?:(=|.=)\s?['"]?(.*?)["']?)?[\]\}])/,
                  select: 'n = byAttribute(n, "{2}", "{4}", "{3}", "{1}");'
              }, {
                  re: /^#([\w\-\\]+)/,
                  select: 'n = byId(n, "{1}");'
              },{
                  re: /^@([\w\-]+)/,
                  select: 'return {firstChild:{nodeValue:attrValue(n, "{1}")}};'
              }
          ],
  
          
          operators : {
              "=" : function(a, v){
                  return a == v;
              },
              "!=" : function(a, v){
                  return a != v;
              },
              "^=" : function(a, v){
                  return a && a.substr(0, v.length) == v;
              },
              "$=" : function(a, v){
                  return a && a.substr(a.length-v.length) == v;
              },
              "*=" : function(a, v){
                  return a && a.indexOf(v) !== -1;
              },
              "%=" : function(a, v){
                  return (a % v) == 0;
              },
              "|=" : function(a, v){
                  return a && (a == v || a.substr(0, v.length+1) == v+'-');
              },
              "~=" : function(a, v){
                  return a && (' '+a+' ').indexOf(' '+v+' ') != -1;
              }
          },
  
          
          pseudos : {
              "first-child" : function(c){
                  var r = [], ri = -1, n,
                      i, ci;
                  for(i = 0; (ci = n = c[i]); i++){
                      while((n = n.previousSibling) && n.nodeType != 1);
                      if(!n){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "last-child" : function(c){
                  var r = [], ri = -1, n,
                      i, ci;
                  for(i = 0; (ci = n = c[i]); i++){
                      while((n = n.nextSibling) && n.nodeType != 1);
                      if(!n){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "nth-child" : function(c, a) {
                  var r = [], ri = -1,
                      m = nthRe.exec(a == "even" && "2n" || a == "odd" && "2n+1" || !nthRe2.test(a) && "n+" + a || a),
                      f = (m[1] || 1) - 0, l = m[2] - 0,
                      i, n, j, cn, pn;
                  for(i = 0; n = c[i]; i++){
                      pn = n.parentNode;
                      if (batch != pn._batch) {
                          j = 0;
                          for(cn = pn.firstChild; cn; cn = cn.nextSibling){
                              if(cn.nodeType == 1){
                                 cn.nodeIndex = ++j;
                              }
                          }
                          pn._batch = batch;
                      }
                      if (f == 1) {
                          if (l == 0 || n.nodeIndex == l){
                              r[++ri] = n;
                          }
                      } else if ((n.nodeIndex + l) % f == 0){
                          r[++ri] = n;
                      }
                  }
  
                  return r;
              },
  
              "only-child" : function(c){
                  var r = [], ri = -1,
                      i, ci;
                  for(i = 0; ci = c[i]; i++){
                      if(!prev(ci) && !next(ci)){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "empty" : function(c){
                  var r = [], ri = -1,
                      i, ci, cns, j, cn, empty;
                  for(i = 0, ci; ci = c[i]; i++){
                      cns = ci.childNodes;
                      j = 0;
                      empty = true;
                      while(cn = cns[j]){
                          ++j;
                          if(cn.nodeType == 1 || cn.nodeType == 3){
                              empty = false;
                              break;
                          }
                      }
                      if(empty){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "contains" : function(c, v){
                  var r = [], ri = -1,
                      i, ci;
                  for(i = 0; ci = c[i]; i++){
                      if((ci.textContent||ci.innerText||ci.text||'').indexOf(v) != -1){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "nodeValue" : function(c, v){
                  var r = [], ri = -1,
                      i, ci;
                  for(i = 0; ci = c[i]; i++){
                      if(ci.firstChild && ci.firstChild.nodeValue == v){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "checked" : function(c){
                  var r = [], ri = -1,
                      i, ci;
                  for(i = 0; ci = c[i]; i++){
                      if(ci.checked == true){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "not" : function(c, ss){
                  return Ext.DomQuery.filter(c, ss, true);
              },
  
              "any" : function(c, selectors){
                  var ss = selectors.split('|'),
                      r = [], ri = -1, s,
                      i, ci, j;
                  for(i = 0; ci = c[i]; i++){
                      for(j = 0; s = ss[j]; j++){
                          if(Ext.DomQuery.is(ci, s)){
                              r[++ri] = ci;
                              break;
                          }
                      }
                  }
                  return r;
              },
  
              "odd" : function(c){
                  return this["nth-child"](c, "odd");
              },
  
              "even" : function(c){
                  return this["nth-child"](c, "even");
              },
  
              "nth" : function(c, a){
                  return c[a-1] || [];
              },
  
              "first" : function(c){
                  return c[0] || [];
              },
  
              "last" : function(c){
                  return c[c.length-1] || [];
              },
  
              "has" : function(c, ss){
                  var s = Ext.DomQuery.select,
                      r = [], ri = -1,
                      i, ci;
                  for(i = 0; ci = c[i]; i++){
                      if(s(ss, ci).length > 0){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "next" : function(c, ss){
                  var is = Ext.DomQuery.is,
                      r = [], ri = -1,
                      i, ci, n;
                  for(i = 0; ci = c[i]; i++){
                      n = next(ci);
                      if(n && is(n, ss)){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              },
  
              "prev" : function(c, ss){
                  var is = Ext.DomQuery.is,
                      r = [], ri = -1,
                      i, ci, n;
                  for(i = 0; ci = c[i]; i++){
                      n = prev(ci);
                      if(n && is(n, ss)){
                          r[++ri] = ci;
                      }
                  }
                  return r;
              }
          }
      };
  }());
  
  
  Ext.query = Ext.DomQuery.select;
  
  
  
  (function() {
  
  var HIDDEN = 'hidden',
      DOC             = document,
      VISIBILITY      = "visibility",
      DISPLAY         = "display",
      NONE            = "none",
      XMASKED         = Ext.baseCSSPrefix + "masked",
      XMASKEDRELATIVE = Ext.baseCSSPrefix + "masked-relative",
      EXTELMASKMSG    = Ext.baseCSSPrefix + "mask-msg",
      bodyRe          = /^body/i,
      visFly,
  
      
      noBoxAdjust = Ext.isStrict ? {
          select: 1
      }: {
          input: 1,
          select: 1,
          textarea: 1
      },
  
      
      isScrolled = function(c) {
          var r = [], ri = -1,
              i, ci;
          for (i = 0; ci = c[i]; i++) {
              if (ci.scrollTop > 0 || ci.scrollLeft > 0) {
                  r[++ri] = ci;
              }
          }
          return r;
      },
  
      Element = Ext.define('Ext.dom.Element', {
  
      extend: 'Ext.dom.AbstractElement',
  
      alternateClassName: ['Ext.Element', 'Ext.core.Element'],
  
      addUnits: function() {
          return this.self.addUnits.apply(this.self, arguments);
      },
  
      
      focus: function(defer,  dom) {
          var me = this,
              scrollTop,
              body;
  
          dom = dom || me.dom;
          body = (dom.ownerDocument || DOC).body || DOC.body;
          try {
              if (Number(defer)) {
                  Ext.defer(me.focus, defer, me, [null, dom]);
              } else {
                  
                  
                  if (dom.offsetHeight > Element.getViewHeight()) {
                      scrollTop = body.scrollTop;
                  }
                  dom.focus();
                  if (scrollTop !== undefined) {
                      body.scrollTop = scrollTop;
                  }
              }
          } catch(e) {
          }
          return me;
      },
  
      
      blur: function() {
          try {
              this.dom.blur();
          } catch(e) {
          }
          return this;
      },
  
      
      isBorderBox: function() {
          var box = Ext.isBorderBox;
          if (box) {
              box = !((this.dom.tagName || "").toLowerCase() in noBoxAdjust);
          }
          return box;
      },
  
      
      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;
      },
  
      
      getAttributeNS: function(ns, name) {
          return this.getAttribute(name, ns);
      },
  
      getAttribute: (Ext.isIE && !(Ext.isIE9 && DOC.documentMode === 9)) ?
          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;
          } : function(name, ns) {
              var d = this.dom;
              if (ns) {
                  return d.getAttributeNS(ns, name) || d.getAttribute(ns + ":" + name);
              }
              return  d.getAttribute(name) || d[name] || null;
          },
  
      
      cacheScrollValues: function() {
          var me = this,
              scrolledDescendants,
              el, i,
              scrollValues = [],
              result = function() {
                  for (i = 0; i < scrolledDescendants.length; i++) {
                      el = scrolledDescendants[i];
                      el.scrollLeft = scrollValues[i][0];
                      el.scrollTop  = scrollValues[i][1];
                  }
              };
  
          if (!Ext.DomQuery.pseudos.isScrolled) {
              Ext.DomQuery.pseudos.isScrolled = isScrolled;
          }
          scrolledDescendants = me.query(':isScrolled');
          for (i = 0; i < scrolledDescendants.length; i++) {
              el = scrolledDescendants[i];
              scrollValues[i] = [el.scrollLeft, el.scrollTop];
          }
          return result;
      },
  
      
      autoBoxAdjust: true,
  
      
      isVisible : function(deep) {
          var me = this,
              dom = me.dom,
              stopNode = dom.ownerDocument.documentElement;
  
          if (!visFly) {
              visFly = new Element.Fly();
          }
  
          while (dom !== stopNode) {
              
              
              if (!dom || dom.nodeType === 11 || (visFly.attach(dom)).isStyle(VISIBILITY, HIDDEN) || visFly.isStyle(DISPLAY, NONE)) {
                  return false;
              }
              
              if (!deep) {
                  break;
              }
              dom = dom.parentNode;
          }
          return true;
      },
  
      
      isDisplayed : function() {
          return !this.isStyle(DISPLAY, NONE);
      },
  
      
      enableDisplayMode : function(display) {
          var me = this;
          
          me.setVisibilityMode(Element.DISPLAY);
  
          if (!Ext.isEmpty(display)) {
              (me.$cache || me.getCache()).data.originalDisplay = display;
          }
  
          return me;
      },
  
      
      mask : function(msg, msgCls , elHeight) {
          var me            = this,
              dom           = me.dom,
              
              
              setExpression = dom.style.setExpression,
              data          = (me.$cache || me.getCache()).data,
              maskEl        = data.maskEl,
              maskMsg       = data.maskMsg;
  
          if (!(bodyRe.test(dom.tagName) && me.getStyle('position') == 'static')) {
              me.addCls(XMASKEDRELATIVE);
          }
          
          
          if (maskEl) {
              maskEl.remove();
          }
          
          if (maskMsg) {
              maskMsg.remove();
          }
  
          Ext.DomHelper.append(dom, [{
              cls : Ext.baseCSSPrefix + "mask"
          }, {
              cls : msgCls ? EXTELMASKMSG + " " + msgCls : EXTELMASKMSG,
              cn  : {
                  tag: 'div',
                  html: msg || ''
              }
          }]);
              
          maskMsg = Ext.get(dom.lastChild);
          maskEl = Ext.get(maskMsg.dom.previousSibling);
          data.maskMsg = maskMsg;
          data.maskEl = maskEl;
  
          me.addCls(XMASKED);
          maskEl.setDisplayed(true);
  
          if (typeof msg == 'string') {
              maskMsg.setDisplayed(true);
              maskMsg.center(me);
          } else {
              maskMsg.setDisplayed(false);
          }
          
          
          
          
          
          if (!Ext.supports.IncludePaddingInWidthCalculation && setExpression) {
              
              try {
                  maskEl.dom.style.setExpression('width', 'this.parentNode.clientWidth + "px"');
              } catch (e) {}
          }
  
          
          
          if (!Ext.supports.IncludePaddingInHeightCalculation && setExpression) {
              
              try {
                  maskEl.dom.style.setExpression('height', 'this.parentNode.' + (dom == DOC.body ? 'scrollHeight' : 'offsetHeight') + ' + "px"');
              } catch (e) {}
          }
          
          else if (Ext.isIE && !(Ext.isIE7 && Ext.isStrict) && me.getStyle('height') == 'auto') {
              maskEl.setSize(undefined, elHeight || me.getHeight());
          }
          return maskEl;
      },
  
      
      unmask : function() {
          var me      = this,
              data    = (me.$cache || me.getCache()).data,
              maskEl  = data.maskEl,
              maskMsg = data.maskMsg,
              style;
  
          if (maskEl) {
              style = maskEl.dom.style;
              
              if (style.clearExpression) {
                  style.clearExpression('width');
                  style.clearExpression('height');
              }
              
              if (maskEl) {
                  maskEl.remove();
                  delete data.maskEl;
              }
              
              if (maskMsg) {
                  maskMsg.remove();
                  delete data.maskMsg;
              }
              
              me.removeCls([XMASKED, XMASKEDRELATIVE]);
          }
      },
  
      
      isMasked : function() {
          var me      = this,
              data    = (me.$cache || me.getCache()).data,
              maskEl  = data.maskEl,
              maskMsg = data.maskMsg,
              hasMask = false; 
  
          if (maskEl && maskEl.isVisible()) {
              if (maskMsg) {
                  maskMsg.center(me);
              }
              hasMask = true;
          }
          return hasMask;
      },
  
      
      createShim : function() {
          var el = DOC.createElement('iframe'),
              shim;
  
          el.frameBorder = '0';
          el.className = Ext.baseCSSPrefix + 'shim';
          el.src = Ext.SSL_SECURE_URL;
          shim = Ext.get(this.dom.parentNode.insertBefore(el, this.dom));
          shim.autoBoxAdjust = false;
          return shim;
      },
  
      
      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));
      },
  
      
      
      
      
      
      
      
      
      
      
      
  
      
      
      
      
  
      
      
      
      
      
      
      
  
      
      
      
      
      
      
      
  
      
      
      
      
  
      
      
      
      
      
      
      
      
  
      
      on: function(eventName, fn, scope, options) {
          Ext.EventManager.on(this, eventName, fn, scope || this, options);
          return this;
      },
  
      
      un: function(eventName, fn, scope) {
          Ext.EventManager.un(this, eventName, fn, scope || this);
          return this;
      },
  
      
      removeAllListeners: function() {
          Ext.EventManager.removeAll(this);
          return this;
      },
  
      
      purgeAllListeners: function() {
          Ext.EventManager.purgeElement(this);
          return this;
      }
  
  }, function() {
  
      var EC              = Ext.cache,
          El              = this,
          AbstractElement = Ext.dom.AbstractElement,
          focusRe         = /a|button|embed|iframe|img|input|object|select|textarea/i,
          nonSpaceRe      = /\S/,
          scriptTagRe     = /(?:<script([^>]*)?>)((\n|\r|.)*?)(?:<\/script>)/ig,
          replaceScriptTagRe = /(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)/ig,
          srcRe           = /\ssrc=([\'\"])(.*?)\1/i,
          typeRe          = /\stype=([\'\"])(.*?)\1/i,
          useDocForId = !(Ext.isIE6 || Ext.isIE7 || Ext.isIE8);
  
      El.boxMarkup = '<div class="{0}-tl"><div class="{0}-tr"><div class="{0}-tc"></div></div></div><div class="{0}-ml"><div class="{0}-mr"><div class="{0}-mc"></div></div></div><div class="{0}-bl"><div class="{0}-br"><div class="{0}-bc"></div></div></div>';
      
  
      
      
      
      function garbageCollect() {
          if (!Ext.enableGarbageCollector) {
              clearInterval(El.collectorThreadId);
          } else {
              var eid,
                  d,
                  o,
                  t;
  
              for (eid in EC) {
                  if (!EC.hasOwnProperty(eid)) {
                      continue;
                  }
  
                  o = EC[eid];
  
                  
                  if (o.skipGarbageCollection) {
                      continue;
                  }
  
                  d = o.dom;
  
  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  
                  if (!d.parentNode || (!d.offsetParent && !Ext.getElementById(eid))) {
                      if (d && Ext.enableListenerCollection) {
                          Ext.EventManager.removeAll(d);
                      }
                      delete EC[eid];
                  }
              }
              
              if (Ext.isIE) {
                  t = {};
                  for (eid in EC) {
                      if (!EC.hasOwnProperty(eid)) {
                          continue;
                      }
                      t[eid] = EC[eid];
                  }
                  EC = Ext.cache = t;
              }
          }
      }
  
      El.collectorThreadId = setInterval(garbageCollect, 30000);
  
      
      El.addMethods({
  
          
          monitorMouseLeave: function(delay, handler, scope) {
              var me = this,
                  timer,
                  listeners = {
                      mouseleave: function(e) {
                          timer = setTimeout(Ext.Function.bind(handler, scope||me, [e]), delay);
                      },
                      mouseenter: function() {
                          clearTimeout(timer);
                      },
                      freezeEvent: true
                  };
  
              me.on(listeners);
              return listeners;
          },
  
          
          swallowEvent : function(eventName, preventDefault) {
              var me = this,
                  e, eLen;
              function fn(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;
          },
  
          
          relayEvent : function(eventName, observable) {
              this.on(eventName, function(e) {
                  observable.fireEvent(eventName, e);
              });
          },
  
          
          clean : function(forceReclean) {
              var me   = this,
                  dom  = me.dom,
                  data = (me.$cache || me.getCache()).data,
                  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();
                      n.nodeIndex = ++ni;
                  }
                  n = nx;
              }
  
              data.isCleaned = true;
              return me;
          },
  
          
          load : function(options) {
              this.getLoader().load(options);
              return this;
          },
  
          
          getLoader : function() {
              var me = this,
                  data = (me.$cache || me.getCache()).data,
                  loader = data.loader;
  
              if (!loader) {
                  data.loader = loader = new Ext.ElementLoader({
                      target: me
                  });
              }
              return loader;
          },
  
          
          syncContent: function(source) {
              source = Ext.getDom(source);
              var me = this,
                  sourceNodes = source.childNodes,
                  sourceLen = sourceNodes.length,
                  dest = me.dom,
                  destNodes = dest.childNodes,
                  destLen = destNodes.length,
                  i,  destNode, sourceNode,
                  nodeType;
  
              
              dest.style.cssText = source.style.cssText;
              dest.className = source.className;
  
              
              if (sourceLen !== destLen) {
                  source.innerHTML = dest.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(sourceNode);
                  }
              }
          },
  
          
          update : 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 += '<span id="' + id + '"></span>';
  
              interval = setInterval(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) {
                          if (window.execScript) {
                             window.execScript(match[2]);
                          } else {
                             window.eval(match[2]);
                          }
                      }
                  }
                  Ext.callback(callback, me);
              }, 20);
              dom.innerHTML = html.replace(replaceScriptTagRe, '');
              return me;
          },
  
          
          removeAllListeners : function() {
              this.removeAnchor();
              Ext.EventManager.removeAll(this.dom);
              return this;
          },
  
          
          createProxy : function(config, renderTo, matchBox) {
              config = (typeof config == 'object') ? config : {tag : "div", 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;
          },
          
          
          getScopeParent: function() {
              var parent = this.dom.parentNode;
              if (Ext.scopeResetCSS) {
                  
                  parent = parent.parentNode;
                  if (!Ext.supports.CSS3LinearGradient || !Ext.supports.CSS3BorderRadius) {
                      
                      
                      parent = parent.parentNode;
                  }
              }
              return parent;
          },
  
          
          needsTabIndex: function() {
              if (this.dom) {
                  if ((this.dom.nodeName === 'a') && (!this.dom.href)) {
                      return true;
                  }
                  return !focusRe.test(this.dom.nodeName);
              }
          },
  
          
          focusable: function () {
              var dom = this.dom,
                  nodeName = dom.nodeName,
                  canFocus = false;
  
              if (!dom.disabled) {
                  if (focusRe.test(nodeName)) {
                      if ((nodeName !== 'a') || dom.href) {
                          canFocus = true;
                      }
                  } else {
                      canFocus = !isNaN(dom.tabIndex);
                  }
              }
              return canFocus && this.isVisible(true);
          }
      });
  
      if (Ext.isIE) {
          El.prototype.getById = function (id, asDom) {
              var dom = this.dom,
                  cacheItem, el, ret;
  
              if (dom) {
                  
                  
                  el = (useDocForId && DOC.getElementById(id)) || dom.all[id];
                  if (el) {
                      if (asDom) {
                          ret = el;
                      } else {
                          
                          
                          cacheItem = EC[id];
                          if (cacheItem && cacheItem.el) {
                              ret = Ext.updateCacheEntry(cacheItem, el).el;
                          } else {
                              ret = new Element(el);
                          }
                      }
                      return ret;
                  }
              }
  
              return asDom ? Ext.getDom(id) : El.get(id);
          };
      }
  
      El.createAlias({
          
          addListener: 'on',
          
          removeListener: 'un',
          
          clearListeners: 'removeAllListeners'
      });
  
      El.Fly = AbstractElement.Fly = new Ext.Class({
          extend: El,
  
          constructor: function(dom) {
              this.dom = dom;
          },
          
          attach: AbstractElement.Fly.prototype.attach
      });
  
      if (Ext.isIE) {
          Ext.getElementById = function (id) {
              var el = DOC.getElementById(id),
                  detachedBodyEl;
  
              if (!el && (detachedBodyEl = AbstractElement.detachedBodyEl)) {
                  el = detachedBodyEl.dom.all[id];
              }
  
              return el;
          };
      } else if (!DOC.querySelector) {
          Ext.getDetachedBody = Ext.getBody;
  
          Ext.getElementById = function (id) {
              return DOC.getElementById(id);
          };
      }
  });
  
  }());
  
  
  Ext.dom.Element.override((function() {
  
      var doc = document,
          win = window,
          alignRe = /^([a-z]+)-([a-z]+)(\?)?$/,
          round = Math.round;
  
      return {
  
          
          getAnchorXY: function(anchor, local, mySize) {
              
              
              anchor = (anchor || "tl").toLowerCase();
              mySize = mySize || {};
  
              var me = this,
                  isViewport = me.dom == doc.body || me.dom == doc,
                  myWidth = mySize.width || isViewport ? Ext.dom.Element.getViewWidth() : me.getWidth(),
                  myHeight = mySize.height || isViewport ? Ext.dom.Element.getViewHeight() : me.getHeight(),
                  xy,
                  myPos = me.getXY(),
                  scroll = me.getScroll(),
                  extraX = isViewport ? scroll.left : !local ? myPos[0] : 0,
                  extraY = isViewport ? scroll.top : !local ? myPos[1] : 0;
  
              
              
              switch (anchor) {
                  case 'tl' : xy = [ 0,                    0];
                              break;
                  case 'bl' : xy = [ 0,                    myHeight];
                              break;
                  case 'tr' : xy = [ myWidth,              0];
                              break;
                  case 'c'  : xy = [ round(myWidth * 0.5), round(myHeight * 0.5)];
                              break;
                  case 't'  : xy = [ round(myWidth * 0.5), 0];
                              break;
                  case 'l'  : xy = [ 0,                    round(myHeight * 0.5)];
                              break;
                  case 'r'  : xy = [ myWidth,              round(myHeight * 0.5)];
                              break;
                  case 'b'  : xy = [ round(myWidth * 0.5), myHeight];
                              break;
                  case 'br' : xy = [ myWidth,              myHeight];
              }
              return [xy[0] + extraX, xy[1] + extraY];
          },
  
          
          getAlignToXY : function(alignToEl, posSpec, offset) {
              alignToEl = Ext.get(alignToEl);
  
              if (!alignToEl || !alignToEl.dom) {
              }
  
              offset = offset || [0,0];
              posSpec = (!posSpec || posSpec == "?" ? "tl-bl?" : (!(/-/).test(posSpec) && posSpec !== "" ? "tl-" + posSpec : posSpec || "tl-bl")).toLowerCase();
  
              var me = this,
                      myPosition,
                      alignToElPosition,
                      x,
                      y,
                      myWidth,
                      myHeight,
                      alignToElRegion,
                      viewportWidth = Ext.dom.Element.getViewWidth() - 10, 
                      viewportHeight = Ext.dom.Element.getViewHeight() - 10, 
                      p1y,
                      p1x,
                      p2y,
                      p2x,
                      swapY,
                      swapX,
                      docElement = doc.documentElement,
                      docBody = doc.body,
                      scrollX = (docElement.scrollLeft || docBody.scrollLeft || 0),
                      scrollY = (docElement.scrollTop  || docBody.scrollTop  || 0),
                      constrain, 
                      align1,
                      align2,
                      alignMatch = posSpec.match(alignRe);
  
  
              align1 = alignMatch[1];
              align2 = alignMatch[2];
              constrain = !!alignMatch[3];
  
              
              
              myPosition = me.getAnchorXY(align1, true);
              alignToElPosition = alignToEl.getAnchorXY(align2, false);
  
              x = alignToElPosition[0] - myPosition[0] + offset[0];
              y = alignToElPosition[1] - myPosition[1] + offset[1];
  
              
              if (constrain) {
                  myWidth = me.getWidth();
                  myHeight = me.getHeight();
                  alignToElRegion = alignToEl.getRegion();
                  
                  
                  
                  p1y = align1.charAt(0);
                  p1x = align1.charAt(align1.length - 1);
                  p2y = align2.charAt(0);
                  p2x = align2.charAt(align2.length - 1);
                  swapY = ((p1y == "t" && p2y == "b") || (p1y == "b" && p2y == "t"));
                  swapX = ((p1x == "r" && p2x == "l") || (p1x == "l" && p2x == "r"));
  
                  if (x + myWidth > viewportWidth + scrollX) {
                      x = swapX ? alignToElRegion.left - myWidth : viewportWidth + scrollX - myWidth;
                  }
                  if (x < scrollX) {
                      x = swapX ? alignToElRegion.right : scrollX;
                  }
                  if (y + myHeight > viewportHeight + scrollY) {
                      y = swapY ? alignToElRegion.top - myHeight : viewportHeight + scrollY - myHeight;
                  }
                  if (y < scrollY) {
                      y = swapY ? alignToElRegion.bottom : scrollY;
                  }
              }
              return [x,y];
          },
  
  
          
          anchorTo : function(el, alignment, offsets, animate, monitorScroll, callback) {
              var me = this,
                  dom = me.dom,
                  scroll = !Ext.isEmpty(monitorScroll),
                  action = function() {
                      Ext.fly(dom).alignTo(el, alignment, offsets, animate);
                      Ext.callback(callback, Ext.fly(dom));
                  },
                  anchor = this.getAnchor();
  
              
              this.removeAnchor();
              Ext.apply(anchor, {
                  fn: action,
                  scroll: scroll
              });
  
              Ext.EventManager.onWindowResize(action, null);
  
              if (scroll) {
                  Ext.EventManager.on(win, 'scroll', action, null,
                          {buffer: !isNaN(monitorScroll) ? monitorScroll : 50});
              }
              action.call(me); 
              return me;
          },
  
          
          removeAnchor : function() {
              var me = this,
                  anchor = this.getAnchor();
  
              if (anchor && anchor.fn) {
                  Ext.EventManager.removeResizeListener(anchor.fn);
                  if (anchor.scroll) {
                      Ext.EventManager.un(win, 'scroll', anchor.fn);
                  }
                  delete anchor.fn;
              }
              return me;
          },
  
          getAlignVector: function(el, spec, offset) {
              var me = this,
                  myPos = me.getXY(),
                  alignedPos = me.getAlignToXY(el, spec, offset);
  
              el = Ext.get(el);
  
              alignedPos[0] -= myPos[0];
              alignedPos[1] -= myPos[1];
              return alignedPos;
          },
  
          
          alignTo: function(element, position, offsets, animate) {
              var me = this;
              return me.setXY(me.getAlignToXY(element, position, offsets),
                      me.anim && !!animate ? me.anim(animate) : false);
          },
  
          
          getConstrainVector: function(constrainTo, proposedPosition) {
              if (!(constrainTo instanceof Ext.util.Region)) {
                  constrainTo = Ext.get(constrainTo).getViewRegion();
              }
              var thisRegion = this.getRegion(),
                      vector = [0, 0],
                      shadowSize = (this.shadow && !this.shadowDisabled) ? this.shadow.getShadowSize() : undefined,
                      overflowed = false;
  
              
              if (proposedPosition) {
                  thisRegion.translateBy(proposedPosition[0] - thisRegion.x, proposedPosition[1] - thisRegion.y);
              }
  
              
              if (shadowSize) {
                  constrainTo.adjust(shadowSize[0], -shadowSize[1], -shadowSize[2], shadowSize[3]);
              }
  
              
              if (thisRegion.right > constrainTo.right) {
                  overflowed = true;
                  vector[0] = (constrainTo.right - thisRegion.right);    
              }
              if (thisRegion.left + vector[0] < constrainTo.left) {
                  overflowed = true;
                  vector[0] = (constrainTo.left - thisRegion.left);      
              }
  
              
              if (thisRegion.bottom > constrainTo.bottom) {
                  overflowed = true;
                  vector[1] = (constrainTo.bottom - thisRegion.bottom);  
              }
              if (thisRegion.top + vector[1] < constrainTo.top) {
                  overflowed = true;
                  vector[1] = (constrainTo.top - thisRegion.top);        
              }
              return overflowed ? vector : false;
          },
  
          
          getCenterXY : function(){
              return this.getAlignToXY(doc, 'c-c');
          },
  
          
          center : function(centerIn){
              return this.alignTo(centerIn || doc, 'c-c');
          }
      };
  }()));
  
  
  
  Ext.dom.Element.override({
      
      animate: function(config) {
          var me = this,
              listeners,
              anim,
              animId = me.dom.id || Ext.id(me.dom);
  
          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;
              }
              anim = new Ext.fx.Anim(me.anim(config));
              if (listeners) {
                  anim.on(listeners);
              }
              Ext.fx.Manager.queueFx(anim);
          }
          return me;
      },
  
      
      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;
      },
  
      
      slideIn: function(anchor, obj, slideOut) {
          var me = this,
              elStyle = me.dom.style,
              beforeAnim,
              wrapAnim,
              restoreScroll,
              wrapDomParentNode;
  
          anchor = anchor || "t";
          obj = obj || {};
  
          beforeAnim = function() {
              var animScope = this,
                  listeners = obj.listeners,
                  box, originalStyles, anim, wrap;
  
              if (!slideOut) {
                  me.fixDisplay();
              }
  
              box = me.getBox();
              if ((anchor == 't' || anchor == 'b') && box.height === 0) {
                  box.height = me.dom.scrollHeight;
              }
              else if ((anchor == 'l' || anchor == 'r') && box.width === 0) {
                  box.width = me.dom.scrollWidth;
              }
  
              originalStyles = me.getStyles('width', 'height', 'left', 'right', 'top', 'bottom', 'position', 'z-index', true);
              me.setSize(box.width, box.height);
  
              
              if (obj.preserveScroll) {
                  restoreScroll = me.cacheScrollValues();
              }
  
              wrap = me.wrap({
                  id: Ext.id() + '-anim-wrap-for-' + me.id,
                  style: {
                      visibility: slideOut ? 'visible' : 'hidden'
                  }
              });
              wrapDomParentNode = wrap.dom.parentNode;
              wrap.setPositioning(me.getPositioning());
              if (wrap.isStyle('position', 'static')) {
                  wrap.position('relative');
              }
              me.clearPositioning('auto');
              wrap.clip();
  
              
              if (restoreScroll) {
                  restoreScroll();
              }
  
              
              
              
              me.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'
                          }
                      };
                      elStyle.right = '0px';
                      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'
                          }
                      };
                      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';
                      elStyle.right = '0px';
                      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'
                          }
                      };
                      elStyle.bottom = '0px';
                      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'
                          }
                      };
                      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.right = '0px';
                      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() {
                  me.setStyle(originalStyles);
                  if (slideOut) {
                      if (obj.useDisplay) {
                          me.setDisplayed(false);
                      } else {
                          me.hide();
                      }
                  }
                  if (wrap.dom) {
                      if (wrap.dom.parentNode) {
                          wrap.dom.parentNode.insertBefore(me.dom, wrap.dom);
                      } else {
                          wrapDomParentNode.appendChild(me.dom);
                      }
                      wrap.remove();
                  }
                  
                  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);
      },
  
      
      puff: function(obj) {
          var me = this,
              beforeAnim,
              box = me.getBox(),
              originalStyles = me.getStyles('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() {
              me.clearOpacity();
              me.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() {
                  if (me.dom) {
                      if (obj.useDisplay) {
                          me.setDisplayed(false);
                      } else {
                          me.hide();
                      }
                      me.setStyle(originalStyles);
                      obj.callback.call(obj.scope);
                  }
              });
          };
  
          me.animate({
              duration: obj.duration,
              easing: obj.easing,
              listeners: {
                  beforeanimate: {
                      fn: beforeAnim
                  }
              }
          });
          return me;
      },
  
      
      switchOff: function(obj) {
          var me = this,
              beforeAnim;
  
          obj = Ext.applyIf(obj || {}, {
              easing: 'ease-in',
              duration: 500,
              remove: false,
              useDisplay: false
          });
  
          beforeAnim = function() {
              var animScope = this,
                  size = me.getSize(),
                  xy = me.getXY(),
                  keyframe, position;
              me.clearOpacity();
              me.clip();
              position = me.getPositioning();
  
              keyframe = new Ext.fx.Animator({
                  target: me,
                  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() {
                  if (obj.useDisplay) {
                      me.setDisplayed(false);
                  } else {
                      me.hide();
                  }
                  me.clearOpacity();
                  me.setPositioning(position);
                  me.setSize(size);
                  
                  animScope.end();
              });
          };
          
          me.animate({
              
              duration: (Math.max(obj.duration, 500) * 2),
              listeners: {
                  beforeanimate: {
                      fn: beforeAnim
                  }
              }
          });
          return me;
      },
  
      
      frame : function(color, count, obj){
          var me = this,
              beforeAnim;
  
          color = color || '#C3DAF9';
          count = count || 1;
          obj = obj || {};
  
          beforeAnim = function() {
              me.show();
              var animScope = this,
                  box = me.getBox(),
                  proxy = Ext.getBody().createChild({
                      id: me.id + '-anim-proxy',
                      style: {
                          position : 'absolute',
                          'pointer-events': 'none',
                          'z-index': 35000,
                          border : '0px solid ' + color
                      }
                  }),
                  proxyAnim;
              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.remove();
                  
                  animScope.end();
              });
          };
  
          me.animate({
              
              duration: (Math.max(obj.duration, 500) * 2) || 2000,
              listeners: {
                  beforeanimate: {
                      fn: beforeAnim
                  }
              }
          });
          return me;
      },
  
      
      ghost: function(anchor, obj) {
          var me = this,
              beforeAnim;
  
          anchor = anchor || "b";
          beforeAnim = function() {
              var width = me.getWidth(),
                  height = me.getHeight(),
                  xy = me.getXY(),
                  position = me.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 () {
                  if (me.dom) {
                      me.hide();
                      me.clearOpacity();
                      me.setPositioning(position);
                  }
              });
          };
  
          me.animate(Ext.applyIf(obj || {}, {
              duration: 500,
              easing: 'ease-out',
              listeners: {
                  beforeanimate: {
                      fn: beforeAnim
                  }
              }
          }));
          return me;
      },
  
      
      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];
                  me.clearOpacity();
                  me.show();
  
                  event = lns.beforeanimate;
                  if (event) {
                      fn = event.fn || event;
                      return fn.apply(event.scope || lns.scope || window, arguments);
                  }
              },
              afteranimate: function() {
                  if (dom) {
                      dom.style[attr] = restore;
                  }
  
                  event = lns.afteranimate;
                  if (event) {
                      fn = event.fn || event;
                      fn.apply(event.scope || lns.scope || window, arguments);
                  }
              }
          });
  
          me.animate(Ext.apply({}, o, {
              duration: 1000,
              easing: 'ease-in',
              from: from,
              to: to
          }));
          return me;
      },
  
     
      pause: function(ms) {
          var me = this;
          Ext.fx.Manager.setFxDefaults(me.id, {
              delay: ms
          });
          return me;
      },
  
      
      fadeIn: function(o) {
          var me = this;
          me.animate(Ext.apply({}, o, {
              opacity: 1,
              internalListeners: {
                  beforeanimate: function(anim){
                      
                      
                      if (me.isStyle('display', 'none')) {
                          me.setDisplayed('');
                      } else {
                          me.show();
                      } 
                  }
              }
          }));
          return this;
      },
  
      
      fadeOut: function(o) {
          var me = this;
          o = Ext.apply({
              opacity: 0,
              internalListeners: {
                  afteranimate: function(anim){
                      var dom = me.dom;
                      if (dom && anim.to.opacity === 0) {
                          if (o.useDisplay) {
                              me.setDisplayed(false);
                          } else {
                              me.hide();
                          }
                      }         
                  }
              }
          }, o);
          me.animate(o);
          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;
      }
  });
  
  
  Ext.dom.Element.override({
      
      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);
      }
  });
  
  
  (function() {
  
  var Element         = Ext.dom.Element,
      VISIBILITY      = "visibility",
      DISPLAY         = "display",
      NONE            = "none",
      HIDDEN          = 'hidden',
      VISIBLE         = 'visible',
      OFFSETS         = "offsets",
      ASCLASS         = "asclass",
      NOSIZE          = 'nosize',
      ORIGINALDISPLAY = 'originalDisplay',
      VISMODE         = 'visibilityMode',
      ISVISIBLE       = 'isVisible',
      OFFSETCLASS     = Ext.baseCSSPrefix + 'hide-offsets',
      getDisplay = function(el) {
          var data = (el.$cache || el.getCache()).data,
              display = data[ORIGINALDISPLAY];
              
          if (display === undefined) {
              data[ORIGINALDISPLAY] = display = '';
          }
          return display;
      },
      getVisMode = function(el){
          var data = (el.$cache || el.getCache()).data,
              visMode = data[VISMODE];
              
          if (visMode === undefined) {
              data[VISMODE] = visMode = Element.VISIBILITY;
          }
          return visMode;
      };
  
  Element.override({
      
      originalDisplay : "",
      visibilityMode : 1,
  
      
      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;
                  case NOSIZE:
                  case ASCLASS:
                      visMode = Element.ASCLASS;
                      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 (visMode == Element.ASCLASS) {
                  me[visible?'removeCls':'addCls'](me.visibilityCls || Element.visibilityCls);
              }
          } 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) {
                          me.setVisible(false).setOpacity(1);
                      }
                  },
                  to: {
                      opacity: (visible) ? 1 : 0
                  }
              }, animate));
          }
          (me.$cache || me.getCache()).data[ISVISIBLE] = visible;
          return me;
      },
  
      
      hasMetrics  : function(){
          var visMode = getVisMode(this);
          return this.isVisible() || (visMode == Element.OFFSETS) || (visMode == Element.VISIBILITY);
      },
  
      
      toggle : function(animate){
          var me = this;
          me.setVisible(!me.isVisible(), me.anim(animate));
          return me;
      },
  
      
      setDisplayed : function(value) {
          if(typeof value == "boolean"){
             value = value ? getDisplay(this) : NONE;
          }
          this.setStyle(DISPLAY, value);
          return this;
      },
  
      
      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");
              }
          }
      },
  
      
      hide : function(animate){
          
          if (typeof animate == 'string'){
              this.setVisible(false, animate);
              return this;
          }
          this.setVisible(false, this.anim(animate));
          return this;
      },
  
      
      show : function(animate){
          
          if (typeof animate == 'string'){
              this.setVisible(true, animate);
              return this;
          }
          this.setVisible(true, this.anim(animate));
          return this;
      }
  });
  
  }());
  
  
  (function() {
  
  var Element = Ext.dom.Element,
      LEFT = "left",
      RIGHT = "right",
      TOP = "top",
      BOTTOM = "bottom",
      POSITION = "position",
      STATIC = "static",
      RELATIVE = "relative",
      AUTO = "auto",
      ZINDEX = "z-index",
      BODY = 'BODY',
  
      PADDING = 'padding',
      BORDER = 'border',
      SLEFT = '-left',
      SRIGHT = '-right',
      STOP = '-top',
      SBOTTOM = '-bottom',
      SWIDTH = '-width',
      
      borders = {l: BORDER + SLEFT + SWIDTH, r: BORDER + SRIGHT + SWIDTH, t: BORDER + STOP + SWIDTH, b: BORDER + SBOTTOM + SWIDTH},
      paddings = {l: PADDING + SLEFT, r: PADDING + SRIGHT, t: PADDING + STOP, b: PADDING + SBOTTOM},
      paddingsTLRB = [paddings.l, paddings.r, paddings.t, paddings.b],
      bordersTLRB = [borders.l,  borders.r,  borders.t,  borders.b],
      positionTopLeft = ['position', 'top', 'left'];
  
  Element.override({
  
      getX: function() {
          return Element.getX(this.dom);
      },
  
      getY: function() {
          return Element.getY(this.dom);
      },
  
      
      getXY: function() {
          return Element.getXY(this.dom);
      },
  
      
      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, animate) {
          return this.setXY([x, this.getY()], animate);
      },
  
      setY: function(y, animate) {
          return this.setXY([this.getX(), y], animate);
      },
  
      setLeft: function(left) {
          this.setStyle(LEFT, this.addUnits(left));
          return this;
      },
  
      setTop: function(top) {
          this.setStyle(TOP, this.addUnits(top));
          return this;
      },
  
      setRight: function(right) {
          this.setStyle(RIGHT, this.addUnits(right));
          return this;
      },
  
      setBottom: function(bottom) {
          this.setStyle(BOTTOM, this.addUnits(bottom));
          return this;
      },
  
      
      setXY: function(pos, animate) {
          var me = this;
          if (!animate || !me.anim) {
              Element.setXY(me.dom, pos);
          }
          else {
              if (!Ext.isObject(animate)) {
                  animate = {};
              }
              me.animate(Ext.applyIf({ to: { x: pos[0], y: pos[1] } }, animate));
          }
          return me;
      },
  
      pxRe: /^\d+(?:\.\d*)?px$/i,
  
      
      getLocalX: function() {
          var me = this,
              offsetParent,
              x = me.getStyle(LEFT);
  
          if (!x || x === AUTO) {
              return 0;
          }
          if (x && me.pxRe.test(x)) {
              return parseFloat(x);
          }
  
          x = me.getX();
  
          offsetParent = me.dom.offsetParent;
          if (offsetParent) {
              x -= Ext.fly(offsetParent).getX();
          }
  
          return x;
      },
  
      
      getLocalY: function() {
          var me = this,
              offsetParent,
              y = me.getStyle(TOP);
  
          if (!y || y === AUTO) {
              return 0;
          }
          if (y && me.pxRe.test(y)) {
              return parseFloat(y);
          }
  
          y = me.getY();
  
          offsetParent = me.dom.offsetParent;
          if (offsetParent) {
              y -= Ext.fly(offsetParent).getY();
          }
  
          return y;
      },
  
      getLeft: function(local) {
          return local ? this.getLocalX() : this.getX();
      },
  
      getRight: function(local) {
          return (local ? this.getLocalX() : this.getX()) + this.getWidth();
      },
  
      getTop: function(local) {
          return local ? this.getLocalY() : this.getY();
      },
  
      getBottom: function(local) {
          return (local ? this.getLocalY() : this.getY()) + this.getHeight();
      },
  
      translatePoints: function(x, y) {
          var me = this,
              styles = me.getStyle(positionTopLeft),
              relative = styles.position == 'relative',
              left = parseFloat(styles.left),
              top = parseFloat(styles.top),
              xy = me.getXY();
  
          if (Ext.isArray(x)) {
               y = x[1];
               x = x[0];
          }
          if (isNaN(left)) {
              left = relative ? 0 : me.dom.offsetLeft;
          }
          if (isNaN(top)) {
              top = relative ? 0 : me.dom.offsetTop;
          }
          left = (typeof x == 'number') ? x - xy[0] + left : undefined;
          top = (typeof y == 'number') ? y - xy[1] + top : undefined;
          return {
              left: left,
              top: top
          };
  
      },
  
      setBox: function(box, adjust, animate) {
          var me = this,
                  w = box.width,
                  h = box.height;
          if ((adjust && !me.autoBoxAdjust) && !me.isBorderBox()) {
              w -= (me.getBorderWidth("lr") + me.getPadding("lr"));
              h -= (me.getBorderWidth("tb") + me.getPadding("tb"));
          }
          me.setBounds(box.x, box.y, w, h, animate);
          return me;
      },
  
      getBox: function(contentBox, local) {
          var me = this,
              xy,
              left,
              top,
              paddingWidth,
              bordersWidth,
              l, r, t, b, w, h, bx;
  
          if (!local) {
              xy = me.getXY();
          } else {
              xy = me.getStyle([LEFT, TOP]);
              xy = [ parseFloat(xy.left) || 0, parseFloat(xy.top) || 0];
          }
          w = me.getWidth();
          h = me.getHeight();
          if (!contentBox) {
              bx = {
                  x: xy[0],
                  y: xy[1],
                  0: xy[0],
                  1: xy[1],
                  width: w,
                  height: h
              };
          } else {
              paddingWidth = me.getStyle(paddingsTLRB);
              bordersWidth = me.getStyle(bordersTLRB);
  
              l = (parseFloat(bordersWidth[borders.l]) || 0) + (parseFloat(paddingWidth[paddings.l]) || 0);
              r = (parseFloat(bordersWidth[borders.r]) || 0) + (parseFloat(paddingWidth[paddings.r]) || 0);
              t = (parseFloat(bordersWidth[borders.t]) || 0) + (parseFloat(paddingWidth[paddings.t]) || 0);
              b = (parseFloat(bordersWidth[borders.b]) || 0) + (parseFloat(paddingWidth[paddings.b]) || 0);
  
              bx = {
                  x: xy[0] + l,
                  y: xy[1] + t,
                  0: xy[0] + l,
                  1: xy[1] + t,
                  width: w - (l + r),
                  height: h - (t + b)
              };
          }
          bx.right = bx.x + bx.width;
          bx.bottom = bx.y + bx.height;
  
          return bx;
      },
  
      getPageBox: function(getRegion) {
          var me = this,
              el = me.dom,
              isDoc = el.nodeName == BODY,
              w = isDoc ? Ext.dom.AbstractElement.getViewWidth() : el.offsetWidth,
              h = isDoc ? Ext.dom.AbstractElement.getViewHeight() : el.offsetHeight,
              xy = me.getXY(),
              t = xy[1],
              r = xy[0] + w,
              b = xy[1] + h,
              l = xy[0];
  
          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
              };
          }
      },
  
      
      setLocation : function(x, y, animate) {
          return this.setXY([x, y], animate);
      },
  
      
      moveTo : function(x, y, animate) {
          return this.setXY([x, y], animate);
      },
  
      
      position : function(pos, zIndex, x, y) {
          var me = this;
  
          if (!pos && me.isStyle(POSITION, STATIC)) {
              me.setStyle(POSITION, RELATIVE);
          } else if (pos) {
              me.setStyle(POSITION, pos);
          }
          if (zIndex) {
              me.setStyle(ZINDEX, zIndex);
          }
          if (x || y) {
              me.setXY([x || false, y || false]);
          }
      },
  
      
      clearPositioning : function(value) {
          value = value || '';
          this.setStyle({
              left : value,
              right : value,
              top : value,
              bottom : value,
              "z-index" : "",
              position : STATIC
          });
          return this;
      },
  
      
      getPositioning : function(){
          var styles = this.getStyle([LEFT, TOP, POSITION, RIGHT, BOTTOM, ZINDEX]);
          styles[RIGHT] =  styles[LEFT] ? '' : styles[RIGHT];
          styles[BOTTOM] = styles[TOP] ? '' : styles[BOTTOM];
          return styles;
      },
  
      
      setPositioning : function(pc) {
          var me = this,
              style = me.dom.style;
  
          me.setStyle(pc);
  
          if (pc.right == AUTO) {
              style.right = "";
          }
          if (pc.bottom == AUTO) {
              style.bottom = "";
          }
  
          return me;
      },
  
      
      move: function(direction, distance, animate) {
          var me = this,
              xy = me.getXY(),
              x = xy[0],
              y = xy[1],
              left = [x - distance, y],
              right = [x + distance, y],
              top = [x, y - distance],
              bottom = [x, y + distance],
              hash = {
                  l: left,
                  left: left,
                  r: right,
                  right: right,
                  t: top,
                  top: top,
                  up: top,
                  b: bottom,
                  bottom: bottom,
                  down: bottom
              };
  
          direction = direction.toLowerCase();
          me.moveTo(hash[direction][0], hash[direction][1], animate);
      },
  
      
      setLeftTop: function(left, top) {
          var style = this.dom.style;
  
          style.left = Element.addUnits(left);
          style.top = Element.addUnits(top);
  
          return this;
      },
  
      
      getRegion: function() {
          return this.getPageBox(true);
      },
  
      
      getViewRegion: function() {
          var me = this,
              isBody = me.dom.nodeName == BODY,
              scroll, pos, top, left, width, height;
  
          
          if (isBody) {
              scroll = me.getScroll();
              left = scroll.left;
              top = scroll.top;
              width = Ext.dom.AbstractElement.getViewportWidth();
              height = Ext.dom.AbstractElement.getViewportHeight();
          }
          else {
              pos = me.getXY();
              left = pos[0] + me.getBorderWidth('l') + me.getPadding('l');
              top = pos[1] + me.getBorderWidth('t') + me.getPadding('t');
              width = me.getWidth(true);
              height = me.getHeight(true);
          }
  
          return new Ext.util.Region(top, left + width - 1, top + height - 1, left);
      },
  
      
      setBounds: function(x, y, width, height, animate) {
          var me = this;
          if (!animate || !me.anim) {
              me.setSize(width, height);
              me.setLocation(x, y);
          } else {
              if (!Ext.isObject(animate)) {
                  animate = {};
              }
              me.animate(Ext.applyIf({
                  to: {
                      x: x,
                      y: y,
                      width: me.adjustWidth(width),
                      height: me.adjustHeight(height)
                  }
              }, animate));
          }
          return me;
      },
  
      
      setRegion: function(region, animate) {
          return this.setBounds(region.left, region.top, region.right - region.left, region.bottom - region.top, animate);
      }
  });
  
  }());
  
  
  
  Ext.dom.Element.override({
      
      isScrollable: function() {
          var dom = this.dom;
          return dom.scrollHeight > dom.clientHeight || dom.scrollWidth > dom.clientWidth;
      },
  
      
      getScroll: function() {
          var d = this.dom,
              doc = document,
              body = doc.body,
              docElement = doc.documentElement,
              l,
              t,
              ret;
  
          if (d == doc || d == body) {
              if (Ext.isIE && Ext.isStrict) {
                  l = docElement.scrollLeft;
                  t = docElement.scrollTop;
              } else {
                  l = window.pageXOffset;
                  t = window.pageYOffset;
              }
              ret = {
                  left: l || (body ? body.scrollLeft : 0),
                  top : t || (body ? body.scrollTop : 0)
              };
          } else {
              ret = {
                  left: d.scrollLeft,
                  top : d.scrollTop
              };
          }
  
          return ret;
      },
  
      
      scrollBy: function(deltaX, deltaY, animate) {
          var me = this,
              dom = me.dom;
  
          
          if (deltaX.length) {
              animate = deltaY;
              deltaY = deltaX[1];
              deltaX = deltaX[0];
          } else if (typeof deltaX != 'number') { 
              animate = deltaY;
              deltaY = deltaX.y;
              deltaX = deltaX.x;
          }
  
          if (deltaX) {
              me.scrollTo('left', Math.max(Math.min(dom.scrollLeft + deltaX, dom.scrollWidth - dom.clientWidth), 0), animate);
          }
          if (deltaY) {
              me.scrollTo('top', Math.max(Math.min(dom.scrollTop + deltaY, dom.scrollHeight - dom.clientHeight), 0), animate);
          }
  
          return me;
      },
  
      
      scrollTo: function(side, value, animate) {
          
          var top = /top/i.test(side),
              me = this,
              dom = me.dom,
              animCfg,
              prop;
  
          if (!animate || !me.anim) {
              
              prop = 'scroll' + (top ? 'Top' : 'Left');
              dom[prop] = value;
              
              dom[prop] = value;
          }
          else {
              animCfg = {
                  to: {}
              };
              animCfg.to['scroll' + (top ? 'Top' : 'Left')] = value;
              if (Ext.isObject(animate)) {
                  Ext.applyIf(animCfg, animate);
              }
              me.animate(animCfg);
          }
          return me;
      },
  
      
      scrollIntoView: function(container, hscroll, animate) {
          container = Ext.getDom(container) || Ext.getBody().dom;
          var el = this.dom,
              offsets = this.getOffsetsTo(container),
          
              left = offsets[0] + container.scrollLeft,
              top = offsets[1] + container.scrollTop,
              bottom = top + el.offsetHeight,
              right = left + el.offsetWidth,
          
              ctClientHeight = container.clientHeight,
              ctScrollTop = parseInt(container.scrollTop, 10),
              ctScrollLeft = parseInt(container.scrollLeft, 10),
              ctBottom = ctScrollTop + ctClientHeight,
              ctRight = ctScrollLeft + container.clientWidth,
              newPos;
  
          if (el.offsetHeight > ctClientHeight || top < ctScrollTop) {
              newPos = top;
          } else if (bottom > ctBottom) {
              newPos = bottom - ctClientHeight;
          }
          if (newPos != null) {
              Ext.get(container).scrollTo('top', newPos, animate);
          }
  
          if (hscroll !== false) {
              newPos = null;
              if (el.offsetWidth > container.clientWidth || left < ctScrollLeft) {
                  newPos = left;
              } else if (right > ctRight) {
                  newPos = right - container.clientWidth;
              }
              if (newPos != null) {
                  Ext.get(container).scrollTo('left', newPos, animate);
              }
          }
          return this;
      },
  
      
      scrollChildIntoView: function(child, hscroll) {
          Ext.fly(child, '_scrollChildIntoView').scrollIntoView(this, hscroll);
      },
  
      
      scroll: function(direction, distance, animate) {
          if (!this.isScrollable()) {
              return false;
          }
          var el = this.dom,
              l = el.scrollLeft, t = el.scrollTop,
              w = el.scrollWidth, h = el.scrollHeight,
              cw = el.clientWidth, ch = el.clientHeight,
              scrolled = false, v,
              hash = {
                  l: Math.min(l + distance, w - cw),
                  r: v = Math.max(l - distance, 0),
                  t: Math.max(t - distance, 0),
                  b: Math.min(t + distance, h - ch)
              };
  
          hash.d = hash.b;
          hash.u = hash.t;
  
          direction = direction.substr(0, 1);
          if ((v = hash[direction]) > -1) {
              scrolled = true;
              this.scrollTo(direction == 'l' || direction == 'r' ? 'left' : 'top', v, this.anim(animate));
          }
          return scrolled;
      }
  });
  
  
  (function() {
  
  var Element = Ext.dom.Element,
      view = document.defaultView,
      adjustDirect2DTableRe = /table-row|table-.*-group/,
      INTERNAL = '_internal',
      HIDDEN = 'hidden',
      HEIGHT = 'height',
      WIDTH = 'width',
      ISCLIPPED = 'isClipped',
      OVERFLOW = 'overflow',
      OVERFLOWX = 'overflow-x',
      OVERFLOWY = 'overflow-y',
      ORIGINALCLIP = 'originalClip',
      DOCORBODYRE = /#document|body/i,
      
      
      styleHooks,
      edges, k, edge, borderWidth;
  
  if (!view || !view.getComputedStyle) {
      Element.prototype.getStyle = function (property, inline) {
          var me = this,
              dom = me.dom,
              multiple = typeof property != 'string',
              hooks = me.styleHooks,
              prop = property,
              props = prop,
              len = 1,
              isInline = inline,
              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 = hooks[prop];
  
              if (!hook) {
                  hooks[prop] = hook = { name: Element.normalize(prop) };
              }
  
              if (hook.get) {
                  out = hook.get(dom, me, isInline, style);
              } else {
                  camel = hook.name;
  
                  
                  
                  
                  
                  if (hook.canThrow) {
                      try {
                          out = style[camel];
                      } catch (e) {
                          out = '';
                      }
                  } else {
                      
                      
                      out = style ? style[camel] : '';
                  }
              }
  
              if (!multiple) {
                  return out;
              }
  
              values[prop] = out;
              prop = props[++i];
          } while (i < len);
  
          return values;
      };
  }
  
  Element.override({
      getHeight: function(contentHeight, preciseHeight) {
          var me = this,
              dom = me.dom,
              hidden = me.isStyle('display', 'none'),
              height,
              floating;
  
          if (hidden) {
              return 0;
          }
  
          height = Math.max(dom.offsetHeight, dom.clientHeight) || 0;
  
          
          if (Ext.supports.Direct2DBug) {
              floating = me.adjustDirect2DDimension(HEIGHT);
              if (preciseHeight) {
                  height += floating;
              }
              else if (floating > 0 && floating < 0.5) {
                  height++;
              }
          }
  
          if (contentHeight) {
              height -= me.getBorderWidth("tb") + me.getPadding("tb");
          }
  
          return (height < 0) ? 0 : height;
      },
  
      getWidth: function(contentWidth, preciseWidth) {
          var me = this,
              dom = me.dom,
              hidden = me.isStyle('display', 'none'),
              rect, width, floating;
  
          if (hidden) {
              return 0;
          }
  
          
          
          
          
          
          
          if (Ext.supports.BoundingClientRect) {
              rect = dom.getBoundingClientRect();
              width = rect.right - rect.left;
              width = preciseWidth ? width : Math.ceil(width);
          } else {
              width = dom.offsetWidth;
          }
  
          width = Math.max(width, dom.clientWidth) || 0;
  
          
          if (Ext.supports.Direct2DBug) {
              
              floating = me.adjustDirect2DDimension(WIDTH);
              if (preciseWidth) {
                  width += floating;
              }
              
              
              
              else if (floating > 0 && floating < 0.5) {
                  width++;
              }
          }
  
          if (contentWidth) {
              width -= me.getBorderWidth("lr") + me.getPadding("lr");
          }
  
          return (width < 0) ? 0 : width;
      },
  
      setWidth: function(width, animate) {
          var me = this;
          width = me.adjustWidth(width);
          if (!animate || !me.anim) {
              me.dom.style.width = me.addUnits(width);
          }
          else {
              if (!Ext.isObject(animate)) {
                  animate = {};
              }
              me.animate(Ext.applyIf({
                  to: {
                      width: width
                  }
              }, animate));
          }
          return me;
      },
  
      setHeight : function(height, animate) {
          var me = this;
  
          height = me.adjustHeight(height);
          if (!animate || !me.anim) {
              me.dom.style.height = me.addUnits(height);
          }
          else {
              if (!Ext.isObject(animate)) {
                  animate = {};
              }
              me.animate(Ext.applyIf({
                  to: {
                      height: height
                  }
              }, animate));
          }
  
          return me;
      },
  
      applyStyles: function(style) {
          Ext.DomHelper.applyStyles(this.dom, style);
          return this;
      },
  
      setSize: function(width, height, animate) {
          var me = this;
  
          if (Ext.isObject(width)) { 
              animate = height;
              height = width.height;
              width = width.width;
          }
  
          width = me.adjustWidth(width);
          height = me.adjustHeight(height);
  
          if (!animate || !me.anim) {
              me.dom.style.width = me.addUnits(width);
              me.dom.style.height = me.addUnits(height);
          }
          else {
              if (animate === true) {
                  animate = {};
              }
              me.animate(Ext.applyIf({
                  to: {
                      width: width,
                      height: height
                  }
              }, animate));
          }
  
          return me;
      },
  
      getViewSize : function() {
          var me = this,
              dom = me.dom,
              isDoc = DOCORBODYRE.test(dom.nodeName),
              ret;
  
          
          if (isDoc) {
              ret = {
                  width : Element.getViewWidth(),
                  height : Element.getViewHeight()
              };
          } else {
              ret = {
                  width : dom.clientWidth,
                  height : dom.clientHeight
              };
          }
  
          return ret;
      },
  
      getSize: function(contentSize) {
          return {width: this.getWidth(contentSize), height: this.getHeight(contentSize)};
      },
  
      
  
      
      adjustWidth : function(width) {
          var me = this,
              isNum = (typeof width == 'number');
  
          if (isNum && me.autoBoxAdjust && !me.isBorderBox()) {
              width -= (me.getBorderWidth("lr") + me.getPadding("lr"));
          }
          return (isNum && width < 0) ? 0 : width;
      },
  
      
      adjustHeight : function(height) {
          var me = this,
              isNum = (typeof height == "number");
  
          if (isNum && me.autoBoxAdjust && !me.isBorderBox()) {
              height -= (me.getBorderWidth("tb") + me.getPadding("tb"));
          }
          return (isNum && height < 0) ? 0 : height;
      },
  
      
      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);
      },
  
      
      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;
      },
  
      
      clearOpacity : function() {
          return this.setOpacity('');
      },
  
      
      adjustDirect2DDimension: function(dimension) {
          var me = this,
              dom = me.dom,
              display = me.getStyle('display'),
              inlineDisplay = dom.style.display,
              inlinePosition = dom.style.position,
              originIndex = dimension === WIDTH ? 0 : 1,
              currentStyle = dom.currentStyle,
              floating;
  
          if (display === 'inline') {
              dom.style.display = 'inline-block';
          }
  
          dom.style.position = display.match(adjustDirect2DTableRe) ? 'absolute' : 'static';
  
          
          
          
          
          
          floating = (parseFloat(currentStyle[dimension]) || parseFloat(currentStyle.msTransformOrigin.split(' ')[originIndex]) * 2) % 1;
  
          dom.style.position = inlinePosition;
  
          if (display === 'inline') {
              dom.style.display = inlineDisplay;
          }
  
          return floating;
      },
  
      
      clip : function() {
          var me = this,
              data = (me.$cache || me.getCache()).data,
              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;
      },
  
      
      unclip : function() {
          var me = this,
              data = (me.$cache || me.getCache()).data,
              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;
      },
  
      
      boxWrap : function(cls) {
          cls = cls || Ext.baseCSSPrefix + 'box';
          var el = Ext.get(this.insertHtml("beforeBegin", "<div class='" + cls + "'>" + Ext.String.format(Element.boxMarkup, cls) + "</div>"));
          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;
                  }
              }  
          });
      }
      
      
  });
  
  
  Ext.dom.Element.override({
      select: function(selector) {
          return Ext.dom.Element.select(selector, false,  this.dom);
      }
  });
  
  
  Ext.define('Ext.dom.CompositeElementLite', {
      alternateClassName: 'Ext.CompositeElementLite',
  
      requires: ['Ext.dom.Element'],
  
      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.dom.CompositeElement', {
      alternateClassName: 'Ext.CompositeElement',
  
      extend: 'Ext.dom.CompositeElementLite',
  
      
      getElement: function(el) {
          
          return el;
      },
  
      
      transformElement: function(el) {
          return Ext.get(el);
      }
  
  }, function() {
      
  
      Ext.dom.Element.select = function(selector, unique, root) {
          var elements;
  
          if (typeof selector == "string") {
              elements = Ext.dom.Element.selectorFunction(selector, root);
          }
          else if (selector.length !== undefined) {
              elements = selector;
          }
          else {
          }
          return (unique === true) ? new Ext.CompositeElement(elements) : new Ext.CompositeElementLite(elements);
      };
  });
  
  
  Ext.select = Ext.Element.select;
  